inet::UDPBasicApp Class Reference

UDP application. More...

#include <UDPBasicApp.h>

Inheritance diagram for inet::UDPBasicApp:

Public Member Functions
	UDPBasicApp ()
	~UDPBasicApp ()
Public Member Functions inherited from inet::ApplicationBase
	ApplicationBase ()
Public Member Functions inherited from inet::OperationalBase
	OperationalBase ()
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()

Protected Types
enum	SelfMsgKinds { START = 1, SEND, STOP }

Protected Member Functions
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual L3Address	chooseDestAddr ()
virtual void	sendPacket ()
virtual void	processPacket (cPacket *msg)
virtual void	setSocketOptions ()
virtual void	processStart ()
virtual void	processSend ()
virtual void	processStop ()
virtual bool	handleNodeStart (IDoneCallback *doneCallback) override
virtual bool	handleNodeShutdown (IDoneCallback *doneCallback) override
virtual void	handleNodeCrash () override
Protected Member Functions inherited from inet::ApplicationBase
virtual bool	isInitializeStage (int stage) override
virtual bool	isNodeStartStage (int stage) override
virtual bool	isNodeShutdownStage (int stage) override
Protected Member Functions inherited from inet::OperationalBase
virtual void	handleMessage (cMessage *msg) override
virtual void	handleMessageWhenDown (cMessage *msg)
virtual bool	handleOperationStage (LifecycleOperation *operation, int stage, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
virtual void	setOperational (bool isOperational)

Protected Attributes
std::vector< L3Address >	destAddresses
int	localPort = -1
int	destPort = -1
simtime_t	startTime
simtime_t	stopTime
const char *	packetName = nullptr
UDPSocket	socket
cMessage *	selfMsg = nullptr
int	numSent = 0
int	numReceived = 0
Protected Attributes inherited from inet::OperationalBase
bool	isOperational
simtime_t	lastChange

Static Protected Attributes
static simsignal_t	sentPkSignal = registerSignal("sentPk")
static simsignal_t	rcvdPkSignal = registerSignal("rcvdPk")

Detailed Description

UDP application.

See NED for more info.

Member Enumeration Documentation

enum inet::UDPBasicApp::SelfMsgKinds

protected

Enumerator
START
SEND
STOP

{ START = 1, SEND, STOP };

Constructor & Destructor Documentation

inet::UDPBasicApp::UDPBasicApp ( )

inline

{}

inet::UDPBasicApp::~UDPBasicApp

(

)

{
    cancelAndDelete(selfMsg);
}

Member Function Documentation

L3Address inet::UDPBasicApp::chooseDestAddr ( )

protectedvirtual

Referenced by sendPacket().

{
    int k = intrand(destAddresses.size());
    if (destAddresses[k].isLinkLocal()) {    // KLUDGE for IPv6
        const char *destAddrs = par("destAddresses");
        cStringTokenizer tokenizer(destAddrs);
        const char *token = nullptr;

        for (int i = 0; i <= k; ++i)
            token = tokenizer.nextToken();
        destAddresses[k] = L3AddressResolver().resolve(token);
    }
    return destAddresses[k];
}

void inet::UDPBasicApp::finish ( )

overrideprotectedvirtual

{
    recordScalar("packets sent", numSent);
    recordScalar("packets received", numReceived);
    ApplicationBase::finish();
}

void inet::UDPBasicApp::handleMessageWhenUp ( cMessage *  msg )

overrideprotectedvirtual

Implements inet::OperationalBase.

{
    if (msg->isSelfMessage()) {
        ASSERT(msg == selfMsg);
        switch (selfMsg->getKind()) {
            case START:
                processStart();
                break;

            case SEND:
                processSend();
                break;

            case STOP:
                processStop();
                break;

            default:
                throw cRuntimeError("Invalid kind %d in self message", (int)selfMsg->getKind());
        }
    }
    else if (msg->getKind() == UDP_I_DATA) {
        // process incoming packet
        processPacket(PK(msg));
    }
    else if (msg->getKind() == UDP_I_ERROR) {
        EV_WARN << "Ignoring UDP error report\n";
        delete msg;
    }
    else {
        throw cRuntimeError("Unrecognized message (%s)%s", msg->getClassName(), msg->getName());
    }
}

void inet::UDPBasicApp::handleNodeCrash ( )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    if (selfMsg)
        cancelEvent(selfMsg);
}

bool inet::UDPBasicApp::handleNodeShutdown ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    if (selfMsg)
        cancelEvent(selfMsg);
    //TODO if(socket.isOpened()) socket.close();
    return true;
}

bool inet::UDPBasicApp::handleNodeStart ( IDoneCallback *  doneCallback )

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    simtime_t start = std::max(startTime, simTime());
    if ((stopTime < SIMTIME_ZERO) || (start < stopTime) || (start == stopTime && startTime == stopTime)) {
        selfMsg->setKind(START);
        scheduleAt(start, selfMsg);
    }
    return true;
}

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

overrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{
    ApplicationBase::initialize(stage);

    if (stage == INITSTAGE_LOCAL) {
        numSent = 0;
        numReceived = 0;
        WATCH(numSent);
        WATCH(numReceived);

        localPort = par("localPort");
        destPort = par("destPort");
        startTime = par("startTime").doubleValue();
        stopTime = par("stopTime").doubleValue();
        packetName = par("packetName");
        if (stopTime >= SIMTIME_ZERO && stopTime < startTime)
            throw cRuntimeError("Invalid startTime/stopTime parameters");
        selfMsg = new cMessage("sendTimer");
    }
}

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

inlineoverrideprotectedvirtual

Reimplemented from inet::OperationalBase.

{ return NUM_INIT_STAGES; }

void inet::UDPBasicApp::processPacket ( cPacket *  msg )

protectedvirtual

Referenced by handleMessageWhenUp().

{
    emit(rcvdPkSignal, pk);
    EV_INFO << "Received packet: " << UDPSocket::getReceivedPacketInfo(pk) << endl;
    delete pk;
    numReceived++;
}

void inet::UDPBasicApp::processSend ( )

protectedvirtual

Referenced by handleMessageWhenUp(), and processStart().

{
    sendPacket();
    simtime_t d = simTime() + par("sendInterval").doubleValue();
    if (stopTime < SIMTIME_ZERO || d < stopTime) {
        selfMsg->setKind(SEND);
        scheduleAt(d, selfMsg);
    }
    else {
        selfMsg->setKind(STOP);
        scheduleAt(stopTime, selfMsg);
    }
}

void inet::UDPBasicApp::processStart ( )

protectedvirtual

Referenced by handleMessageWhenUp().

{
    socket.setOutputGate(gate("udpOut"));
    const char *localAddress = par("localAddress");
    socket.bind(*localAddress ? L3AddressResolver().resolve(localAddress) : L3Address(), localPort);
    setSocketOptions();

    const char *destAddrs = par("destAddresses");
    cStringTokenizer tokenizer(destAddrs);
    const char *token;

    while ((token = tokenizer.nextToken()) != nullptr) {
        L3Address result;
        L3AddressResolver().tryResolve(token, result);
        if (result.isUnspecified())
            EV_ERROR << "cannot resolve destination address: " << token << endl;
        else
            destAddresses.push_back(result);
    }

    if (!destAddresses.empty()) {
        selfMsg->setKind(SEND);
        processSend();
    }
    else {
        if (stopTime >= SIMTIME_ZERO) {
            selfMsg->setKind(STOP);
            scheduleAt(stopTime, selfMsg);
        }
    }
}

void inet::UDPBasicApp::processStop ( )

protectedvirtual

Referenced by handleMessageWhenUp().

{
    socket.close();
}

void inet::UDPBasicApp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    char buf[100];
    sprintf(buf, "rcvd: %d pks\nsent: %d pks", numReceived, numSent);
    getDisplayString().setTagArg("t", 0, buf);
}

void inet::UDPBasicApp::sendPacket ( )

protectedvirtual

Referenced by processSend().

{
    std::ostringstream str;
    str << packetName << "-" << numSent;
    ApplicationPacket *payload = new ApplicationPacket(str.str().c_str());
    payload->setByteLength(par("messageLength").longValue());
    payload->setSequenceNumber(numSent);

    L3Address destAddr = chooseDestAddr();

    emit(sentPkSignal, payload);
    socket.sendTo(payload, destAddr, destPort);
    numSent++;
}

void inet::UDPBasicApp::setSocketOptions ( )

protectedvirtual

Referenced by processStart().

{
    int timeToLive = par("timeToLive");
    if (timeToLive != -1)
        socket.setTimeToLive(timeToLive);

    int typeOfService = par("typeOfService");
    if (typeOfService != -1)
        socket.setTypeOfService(typeOfService);

    const char *multicastInterface = par("multicastInterface");
    if (multicastInterface[0]) {
        IInterfaceTable *ift = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        InterfaceEntry *ie = ift->getInterfaceByName(multicastInterface);
        if (!ie)
            throw cRuntimeError("Wrong multicastInterface setting: no interface named \"%s\"", multicastInterface);
        socket.setMulticastOutputInterface(ie->getInterfaceId());
    }

    bool receiveBroadcast = par("receiveBroadcast");
    if (receiveBroadcast)
        socket.setBroadcast(true);

    bool joinLocalMulticastGroups = par("joinLocalMulticastGroups");
    if (joinLocalMulticastGroups) {
        MulticastGroupList mgl = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this)->collectMulticastGroups();
        socket.joinLocalMulticastGroups(mgl);
    }
}

Member Data Documentation

std::vector<L3Address> inet::UDPBasicApp::destAddresses

protected

Referenced by chooseDestAddr(), and processStart().

int inet::UDPBasicApp::destPort = -1

protected

Referenced by initialize(), and sendPacket().

int inet::UDPBasicApp::localPort = -1

protected

Referenced by initialize(), and processStart().

int inet::UDPBasicApp::numReceived = 0

protected

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

int inet::UDPBasicApp::numSent = 0

protected

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

const char* inet::UDPBasicApp::packetName = nullptr

protected

Referenced by initialize(), and sendPacket().

simsignal_t inet::UDPBasicApp::rcvdPkSignal = registerSignal("rcvdPk")

staticprotected

Referenced by processPacket().

cMessage* inet::UDPBasicApp::selfMsg = nullptr

protected

Referenced by handleMessageWhenUp(), handleNodeCrash(), handleNodeShutdown(), handleNodeStart(), initialize(), processSend(), processStart(), and ~UDPBasicApp().

simsignal_t inet::UDPBasicApp::sentPkSignal = registerSignal("sentPk")

staticprotected

Referenced by sendPacket().

UDPSocket inet::UDPBasicApp::socket

protected

Referenced by processStart(), processStop(), sendPacket(), and setSocketOptions().

simtime_t inet::UDPBasicApp::startTime

protected

Referenced by handleNodeStart(), and initialize().

simtime_t inet::UDPBasicApp::stopTime

protected

Referenced by handleNodeStart(), initialize(), processSend(), and processStart().

---

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

• UDPBasicApp.h
• UDPBasicApp.cc