inet::PingApp Class Reference

Generates ping requests and calculates the packet loss and round trip parameters of the replies. More...

#include <PingApp.h>

Inheritance diagram for inet::PingApp:

Public Member Functions
	PingApp ()
virtual	~PingApp ()
int	getPid () const
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::INetworkSocket::ICallback
virtual	~ICallback ()

Protected Member Functions
virtual void	initialize (int stage) override
virtual int	numInitStages () const override
virtual void	handleMessageWhenUp (cMessage *msg) override
virtual void	handleSelfMessage (cMessage *msg)
virtual void	finish () override
virtual void	refreshDisplay () const override
virtual void	parseDestAddressesPar ()
virtual void	startSendingPingRequests ()
virtual void	scheduleNextPingRequest (simtime_t previous, bool withSleep)
virtual void	cancelNextPingRequest ()
virtual bool	isEnabled ()
virtual std::vector< L3Address >	getAllAddresses ()
virtual void	sendPingRequest ()
virtual void	processPingResponse (int identifier, int seqNumber, Packet *packet)
virtual void	countPingResponse (int bytes, long seqNo, simtime_t rtt, bool isDup)
virtual void	handleStartOperation (LifecycleOperation *operation) override
virtual void	handleStopOperation (LifecycleOperation *operation) override
virtual void	handleCrashOperation (LifecycleOperation *operation) override
virtual void	socketDataArrived (INetworkSocket *socket, Packet *packet) override
virtual void	socketClosed (INetworkSocket *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
L3Address	destAddr
L3Address	srcAddr
std::vector< L3Address >	destAddresses
int	packetSize = 0
cPar *	sendIntervalPar = nullptr
cPar *	sleepDurationPar = nullptr
int	hopLimit = 0
int	count = 0
int	destAddrIdx = -1
simtime_t	startTime
simtime_t	stopTime
CrcMode	crcMode = CRC_MODE_UNDEFINED
bool	printPing = false
bool	continuous = false
SocketMap	socketMap
INetworkSocket *	currentSocket = nullptr
int	pid = 0
cMessage *	timer = nullptr
NodeStatus *	nodeStatus = nullptr
simtime_t	lastStart
long	sendSeqNo = 0
long	expectedReplySeqNo = 0
simtime_t	sendTimeHistory [PING_HISTORY_SIZE]
bool	pongReceived [PING_HISTORY_SIZE]
cStdDev	rttStat
long	sentCount = 0
long	lossCount = 0
long	outOfOrderArrivalCount = 0
long	numPongs = 0
long	numDuplicatedPongs = 0
Protected Attributes inherited from inet::OperationalMixin< cSimpleModule >
State	operationalState
simtime_t	lastChange
Operation	activeOperation
cMessage *	activeOperationTimeout
cMessage *	activeOperationExtraTimer

Static Protected Attributes
static const std::map< const Protocol *, const Protocol * >	l3Echo
static simsignal_t	rttSignal = registerSignal("rtt")
static simsignal_t	numLostSignal = registerSignal("numLost")
static simsignal_t	numOutOfOrderArrivalsSignal = registerSignal("numOutOfOrderArrivals")
static simsignal_t	pingTxSeqSignal = registerSignal("pingTxSeq")
static simsignal_t	pingRxSeqSignal = registerSignal("pingRxSeq")

Additional Inherited Members
Protected Types inherited from inet::OperationalMixin< cSimpleModule >
enum	State

Detailed Description

Generates ping requests and calculates the packet loss and round trip parameters of the replies.

See NED file for detailed description of operation.

Constructor & Destructor Documentation

PingApp()

inet::PingApp::PingApp

(

)

{
}

~PingApp()

inet::PingApp::~PingApp ( )

virtual

{
    cancelAndDelete(timer);
    socketMap.deleteSockets();
}

Member Function Documentation

cancelNextPingRequest()

void inet::PingApp::cancelNextPingRequest ( )

protectedvirtual

{
    cancelEvent(timer);
}

Referenced by handleCrashOperation(), and handleStopOperation().

countPingResponse()

void inet::PingApp::countPingResponse ( int  bytes, long  seqNo, simtime_t  rtt, bool  isDup  )

protectedvirtual

{
    EV_INFO << "Ping reply #" << seqNo << " arrived, rtt=" << (rtt == SIMTIME_ZERO ? "unknown" : rtt.str().c_str()) << (isDup ? ", duplicated" : "") << "\n";
    emit(pingRxSeqSignal, seqNo);
 
    if (isDup)
        numDuplicatedPongs++;
    else
        numPongs++;
 
    // count only non 0 RTT values as 0s are invalid
    if (rtt > SIMTIME_ZERO && !isDup) {
        rttStat.collect(rtt);
        emit(rttSignal, rtt);
    }
 
    if (seqNo == expectedReplySeqNo) {
        // expected ping reply arrived; expect next sequence number
        expectedReplySeqNo++;
    }
    else if (seqNo > expectedReplySeqNo) {
        EV_DETAIL << "Jump in seq numbers, assuming pings since #" << expectedReplySeqNo << " got lost\n";
 
        // jump in the sequence: count pings in gap as lost for now
        // (if they arrive later, we'll decrement back the loss counter)
        long jump = seqNo - expectedReplySeqNo;
        lossCount += jump;
        emit(numLostSignal, lossCount);
 
        // expect sequence numbers to continue from here
        expectedReplySeqNo = seqNo + 1;
    }
    else { // seqNo < expectedReplySeqNo
           // ping reply arrived too late: count as out-of-order arrival (not loss after all)
        EV_DETAIL << "Arrived out of order (too late)\n";
        outOfOrderArrivalCount++;
        if (!isDup && rtt > SIMTIME_ZERO)
            lossCount--;
        emit(numOutOfOrderArrivalsSignal, outOfOrderArrivalCount);
        emit(numLostSignal, lossCount);
    }
}

Referenced by processPingResponse().

finish()

void inet::PingApp::finish ( )

overrideprotectedvirtual

{
    if (sendSeqNo == 0) {
        if (printPing)
            EV_DETAIL << getFullPath() << ": No pings sent, skipping recording statistics and printing results.\n";
        return;
    }
 
    lossCount += sendSeqNo - expectedReplySeqNo;
    // record statistics
    recordScalar("Pings sent", sendSeqNo);
    recordScalar("ping loss rate (%)", 100 * lossCount / (double)sendSeqNo);
    recordScalar("ping out-of-order rate (%)", 100 * outOfOrderArrivalCount / (double)sendSeqNo);
 
    // print it to stdout as well
    if (printPing) {
        cout << "--------------------------------------------------------" << endl;
        cout << "\t" << getFullPath() << endl;
        cout << "--------------------------------------------------------" << endl;
 
        cout << "sent: " << sendSeqNo << "   received: " << numPongs << "   loss rate (%): " << (100 * lossCount / (double)sendSeqNo) << endl;
        cout << "round-trip min/avg/max (ms): " << (rttStat.getMin() * 1000.0) << "/"
             << (rttStat.getMean() * 1000.0) << "/" << (rttStat.getMax() * 1000.0) << endl;
        cout << "stddev (ms): " << (rttStat.getStddev() * 1000.0) << "   variance:" << rttStat.getVariance() << endl;
        cout << "--------------------------------------------------------" << endl;
    }
}

getAllAddresses()

std::vector< L3Address > inet::PingApp::getAllAddresses ( )

protectedvirtual

{
    std::vector<L3Address> result;
 
    int lastId = getSimulation()->getLastComponentId();
 
    for (int i = 0; i <= lastId; i++) {
        IInterfaceTable *ift = dynamic_cast<IInterfaceTable *>(getSimulation()->getModule(i));
        if (ift) {
            for (int j = 0; j < ift->getNumInterfaces(); j++) {
                NetworkInterface *ie = ift->getInterface(j);
                if (ie && !ie->isLoopback()) {
#ifdef INET_WITH_IPv4
                    auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
                    if (ipv4Data != nullptr) {
                        Ipv4Address address = ipv4Data->getIPAddress();
                        if (!address.isUnspecified())
                            result.push_back(L3Address(address));
                    }
#endif // ifdef INET_WITH_IPv4
#ifdef INET_WITH_IPv6
                    auto ipv6Data = ie->findProtocolData<Ipv6InterfaceData>();
                    if (ipv6Data != nullptr) {
                        for (int k = 0; k < ipv6Data->getNumAddresses(); k++) {
                            Ipv6Address address = ipv6Data->getAddress(k);
                            if (!address.isUnspecified() && address.isGlobal())
                                result.push_back(L3Address(address));
                        }
                    }
#endif // ifdef INET_WITH_IPv6
                }
            }
        }
    }
    return result;
}

Referenced by parseDestAddressesPar().

getPid()

int inet::PingApp::getPid ( ) const

inline

{ return pid; }

handleCrashOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    pid = -1;
    lastStart = -1;
    sendSeqNo = expectedReplySeqNo = 0;
    srcAddr = destAddr = L3Address();
    destAddresses.clear();
    destAddrIdx = -1;
    cancelNextPingRequest();
    currentSocket = nullptr;
    // TODO remove check?
    if (operation->getRootModule() != getContainingNode(this)) {
        // TODO destroy sockets
        for (auto socket : socketMap.getMap())
            socket.second->destroy();
        socketMap.deleteSockets();
    }
}

handleMessageWhenUp()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (msg->isSelfMessage())
        handleSelfMessage(msg);
    else {
        auto socket = check_and_cast_nullable<INetworkSocket *>(socketMap.findSocketFor(msg));
        if (socket)
            socket->processMessage(msg);
        else
            throw cRuntimeError("Unaccepted message: %s(%s)", msg->getName(), msg->getClassName());
    }
    if (operationalState == State::STOPPING_OPERATION && socketMap.size() == 0)
        startActiveOperationExtraTimeOrFinish(par("stopOperationExtraTime"));
}

handleSelfMessage()

void inet::PingApp::handleSelfMessage ( cMessage *  msg )

protectedvirtual

{
    if (msg->getKind() == PING_FIRST_ADDR) {
        srcAddr = L3AddressResolver().resolve(par("srcAddr"));
        parseDestAddressesPar();
        if (destAddresses.empty()) {
            return;
        }
        destAddrIdx = 0;
        msg->setKind(PING_CHANGE_ADDR);
    }
 
    if (msg->getKind() == PING_CHANGE_ADDR) {
        if (destAddrIdx >= (int)destAddresses.size())
            return;
        destAddr = destAddresses[destAddrIdx];
        EV_INFO << "Starting up: dest=" << destAddr << "  src=" << srcAddr << "seqNo=" << sendSeqNo << endl;
        ASSERT(!destAddr.isUnspecified());
        const Protocol *networkProtocol = nullptr;
        const char *networkProtocolAsString = par("networkProtocol");
        if (*networkProtocolAsString)
            networkProtocol = Protocol::getProtocol(networkProtocolAsString);
        else {
            switch (destAddr.getType()) {
                case L3Address::IPv4: networkProtocol = &Protocol::ipv4; break;
                case L3Address::IPv6: networkProtocol = &Protocol::ipv6; break;
                case L3Address::MODULEID:
                case L3Address::MODULEPATH: networkProtocol = &Protocol::nextHopForwarding; break;
                default: throw cRuntimeError("unknown address type: %d(%s)", (int)destAddr.getType(), L3Address::getTypeName(destAddr.getType()));
            }
        }
        const Protocol *icmp = l3Echo.at(networkProtocol);
 
        for (auto socket : socketMap.getMap()) {
            socket.second->close();
        }
        currentSocket = nullptr;
        if (networkProtocol == &Protocol::ipv4)
            currentSocket = new Ipv4Socket(gate("socketOut"));
        else if (networkProtocol == &Protocol::ipv6)
            currentSocket = new Ipv6Socket(gate("socketOut"));
        else
            currentSocket = new L3Socket(networkProtocol, gate("socketOut"));
        socketMap.addSocket(currentSocket);
        currentSocket->bind(icmp, L3Address());
        currentSocket->setCallback(this);
        msg->setKind(PING_SEND);
    }
 
    ASSERT2(msg->getKind() == PING_SEND, "Unknown kind in self message.");
 
    // send a ping
    sendPingRequest();
 
    if (count > 0 && sendSeqNo % count == 0) {
        // choose next dest address
        destAddrIdx++;
        msg->setKind(PING_CHANGE_ADDR);
        if (destAddrIdx >= (int)destAddresses.size()) {
            if (continuous) {
                destAddrIdx = destAddrIdx % destAddresses.size();
            }
        }
    }
 
    // then schedule next one if needed
    scheduleNextPingRequest(simTime(), msg->getKind() == PING_CHANGE_ADDR);
}

Referenced by handleMessageWhenUp().

handleStartOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    if (isEnabled())
        startSendingPingRequests();
}

handleStopOperation()

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

overrideprotectedvirtual

Implements inet::OperationalMixin< cSimpleModule >.

{
    pid = -1;
    lastStart = -1;
    sendSeqNo = expectedReplySeqNo = 0;
    srcAddr = destAddr = L3Address();
    destAddresses.clear();
    destAddrIdx = -1;
    cancelNextPingRequest();
    currentSocket = nullptr;
    // TODO close sockets
    // TODO remove getMap()
    if (socketMap.size() > 0) {
        for (auto socket : socketMap.getMap())
            socket.second->close();
    }
    delayActiveOperationFinish(par("stopOperationTimeout"));
}

initialize()

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

overrideprotectedvirtual

Reimplemented from inet::OperationalMixin< cSimpleModule >.

{
    ApplicationBase::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        // read params
        // (defer reading srcAddr/destAddr to when ping starts, maybe
        // addresses will be assigned later by some protocol)
        packetSize = par("packetSize");
        sendIntervalPar = &par("sendInterval");
        sleepDurationPar = &par("sleepDuration");
        hopLimit = par("hopLimit");
        count = par("count");
//        if (count <= 0 && count != -1)
//            throw cRuntimeError("Invalid count=%d parameter (should use -1 or a larger than zero value)", count);
        startTime = par("startTime");
        stopTime = par("stopTime");
        if (stopTime >= SIMTIME_ZERO && stopTime < startTime)
            throw cRuntimeError("Invalid startTime/stopTime parameters");
        printPing = par("printPing");
        continuous = par("continuous");
 
        const char *crcModeString = par("crcMode");
        crcMode = parseCrcMode(crcModeString, false);
 
        // state
        pid = -1;
        lastStart = -1;
        sendSeqNo = expectedReplySeqNo = 0;
        for (int i = 0; i < PING_HISTORY_SIZE; i++) {
            sendTimeHistory[i] = SIMTIME_MAX;
            pongReceived[i] = false;
        }
        WATCH(sendSeqNo);
        WATCH(expectedReplySeqNo);
 
        // statistics
        rttStat.setName("pingRTT");
        sentCount = lossCount = outOfOrderArrivalCount = numPongs = 0;
        WATCH(lossCount);
        WATCH(outOfOrderArrivalCount);
        WATCH(numPongs);
 
        // references
        timer = new cMessage("sendPing", PING_FIRST_ADDR);
    }
}

isEnabled()

bool inet::PingApp::isEnabled ( )

protectedvirtual

{
    return par("destAddr").stringValue()[0] && (count == -1 || sentCount < count);
}

Referenced by handleStartOperation().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

parseDestAddressesPar()

void inet::PingApp::parseDestAddressesPar ( )

protectedvirtual

{
    srcAddr = L3AddressResolver().resolve(par("srcAddr"));
    const char *destAddrs = par("destAddr");
    if (!strcmp(destAddrs, "*")) {
        destAddresses = getAllAddresses();
    }
    else {
        cStringTokenizer tokenizer(destAddrs);
        const char *token;
 
        while ((token = tokenizer.nextToken()) != nullptr) {
            L3Address addr = L3AddressResolver().resolve(token);
            destAddresses.push_back(addr);
        }
    }
}

Referenced by handleSelfMessage().

processPingResponse()

void inet::PingApp::processPingResponse ( int  identifier, int  seqNumber, Packet *  packet  )

protectedvirtual

{
    const auto& pingPayload = packet->peekDataAt(B(0), packet->getDataLength());
    if (originatorId != pid) {
        EV_WARN << "Received response was not sent by this application, dropping packet\n";
        return;
    }
 
    // get src, hopCount etc from packet, and print them
    L3Address src = packet->getTag<L3AddressInd>()->getSrcAddress();
//    L3Address dest = msg->getTag<L3AddressInd>()->getDestination();
    auto& msgHopCountTag = packet->findTag<HopLimitInd>();
    int msgHopCount = msgHopCountTag ? msgHopCountTag->getHopLimit() : -1;
 
    // calculate the RTT time by looking up the the send time of the packet
    // if the send time is no longer available (i.e. the packet is very old and the
    // sendTime was overwritten in the circular buffer) then we just return a 0
    // to signal that this value should not be used during the RTT statistics)
    simtime_t rtt = SIMTIME_ZERO;
    bool isDup = false;
    if (sendSeqNo - seqNo < PING_HISTORY_SIZE) {
        int idx = seqNo % PING_HISTORY_SIZE;
        rtt = simTime() - sendTimeHistory[idx];
        isDup = pongReceived[idx];
        pongReceived[idx] = true;
    }
 
    if (printPing) {
        cout << getFullPath() << ": reply of " << packet->getByteLength()
             << " bytes from " << src
             << " icmp_seq=" << seqNo << " ttl=" << msgHopCount
             << " time=" << (rtt * 1000) << " msec"
             << " (" << packet->getName() << ")" << endl;
    }
 
    // update statistics
    countPingResponse(B(pingPayload->getChunkLength()).get(), seqNo, rtt, isDup);
}

Referenced by socketDataArrived().

refreshDisplay()

void inet::PingApp::refreshDisplay ( ) const

overrideprotectedvirtual

{
    ApplicationBase::refreshDisplay();
 
    char buf[40];
    sprintf(buf, "sent: %ld pks\nrcvd: %ld pks", sentCount, numPongs);
    getDisplayString().setTagArg("t", 0, buf);
}

scheduleNextPingRequest()

void inet::PingApp::scheduleNextPingRequest ( simtime_t  previous, bool  withSleep  )

protectedvirtual

{
    simtime_t next;
    if (previous < SIMTIME_ZERO)
        next = simTime() <= startTime ? startTime : simTime();
    else {
        next = previous + *sendIntervalPar;
        if (withSleep)
            next += *sleepDurationPar;
    }
    if (stopTime < SIMTIME_ZERO || next < stopTime)
        scheduleAt(next, timer);
}

Referenced by handleSelfMessage(), and startSendingPingRequests().

sendPingRequest()

void inet::PingApp::sendPingRequest ( )

protectedvirtual

{
    char name[32];
    sprintf(name, "ping%ld", sendSeqNo);
 
    ASSERT(pid != -1);
 
    Packet *outPacket = new Packet(name);
    auto payload = makeShared<ByteCountChunk>(B(packetSize));
 
    switch (destAddr.getType()) {
        case L3Address::IPv4: {
#ifdef INET_WITH_IPv4
            const auto& request = makeShared<IcmpEchoRequest>();
            request->setIdentifier(pid);
            request->setSeqNumber(sendSeqNo);
            outPacket->insertAtBack(payload);
            Icmp::insertCrc(crcMode, request, outPacket);
            outPacket->insertAtFront(request);
            outPacket->addTag<PacketProtocolTag>()->setProtocol(&Protocol::icmpv4);
            break;
#else
            throw cRuntimeError("INET compiled without Ipv4");
#endif
        }
        case L3Address::IPv6: {
#ifdef INET_WITH_IPv6
            const auto& request = makeShared<Icmpv6EchoRequestMsg>();
            request->setIdentifier(pid);
            request->setSeqNumber(sendSeqNo);
            outPacket->insertAtBack(payload);
            Icmpv6::insertCrc(crcMode, request, outPacket);
            outPacket->insertAtFront(request);
            outPacket->addTag<PacketProtocolTag>()->setProtocol(&Protocol::icmpv6);
            break;
#else
            throw cRuntimeError("INET compiled without Ipv6");
#endif
        }
        case L3Address::MODULEID:
        case L3Address::MODULEPATH: {
#ifdef INET_WITH_NEXTHOP
            const auto& request = makeShared<EchoPacket>();
            request->setChunkLength(B(8));
            request->setType(ECHO_PROTOCOL_REQUEST);
            request->setIdentifier(pid);
            request->setSeqNumber(sendSeqNo);
            outPacket->insertAtBack(payload);
//            insertCrc(crcMode, request, outPacket);
            outPacket->insertAtFront(request);
            outPacket->addTag<PacketProtocolTag>()->setProtocol(&Protocol::echo);
            break;
#else
            throw cRuntimeError("INET compiled without Next Hop Forwarding");
#endif
        }
        default:
            throw cRuntimeError("Unaccepted destination address type: %d (address: %s)", (int)destAddr.getType(), destAddr.str().c_str());
    }
 
    auto addressReq = outPacket->addTag<L3AddressReq>();
    addressReq->setSrcAddress(srcAddr);
    addressReq->setDestAddress(destAddr);
    if (hopLimit != -1)
        outPacket->addTag<HopLimitReq>()->setHopLimit(hopLimit);
    EV_INFO << "Sending ping request #" << sendSeqNo << " to lower layer.\n";
    currentSocket->send(outPacket);
 
    // store the sending time in a circular buffer so we can compute RTT when the packet returns
    sendTimeHistory[sendSeqNo % PING_HISTORY_SIZE] = simTime();
    pongReceived[sendSeqNo % PING_HISTORY_SIZE] = false;
    emit(pingTxSeqSignal, sendSeqNo);
 
    sendSeqNo++;
    sentCount++;
}

Referenced by handleSelfMessage().

socketClosed()

void inet::PingApp::socketClosed ( INetworkSocket *  socket )

overrideprotectedvirtual

Implements inet::INetworkSocket::ICallback.

{
    if (socket == currentSocket)
        currentSocket = nullptr;
    delete socketMap.removeSocket(socket);
}

socketDataArrived()

void inet::PingApp::socketDataArrived ( INetworkSocket *  socket, Packet *  packet  )

overrideprotectedvirtual

Implements inet::INetworkSocket::ICallback.

{
#ifdef INET_WITH_IPv4
    if (packet->getTag<PacketProtocolTag>()->getProtocol() == &Protocol::icmpv4) {
        const auto& icmpHeader = packet->popAtFront<IcmpHeader>();
        if (icmpHeader->getType() == ICMP_ECHO_REPLY) {
            const auto& echoReply = CHK(dynamicPtrCast<const IcmpEchoReply>(icmpHeader));
            processPingResponse(echoReply->getIdentifier(), echoReply->getSeqNumber(), packet);
        }
        else {
            // process other icmp messages, process icmp errors
        }
        delete packet;
    }
    else
#endif
#ifdef INET_WITH_IPv6
    if (packet->getTag<PacketProtocolTag>()->getProtocol() == &Protocol::icmpv6) {
        const auto& icmpHeader = packet->popAtFront<Icmpv6Header>();
        if (icmpHeader->getType() == ICMPv6_ECHO_REPLY) {
            const auto& echoReply = CHK(dynamicPtrCast<const Icmpv6EchoReplyMsg>(icmpHeader));
            processPingResponse(echoReply->getIdentifier(), echoReply->getSeqNumber(), packet);
        }
        else {
            // process other icmpv6 messages, process icmpv6 errors
        }
        delete packet;
    }
    else
#endif
#ifdef INET_WITH_NEXTHOP
    if (packet->getTag<PacketProtocolTag>()->getProtocol() == &Protocol::echo) {
        const auto& icmpHeader = packet->popAtFront<EchoPacket>();
        if (icmpHeader->getType() == ECHO_PROTOCOL_REPLY) {
            processPingResponse(icmpHeader->getIdentifier(), icmpHeader->getSeqNumber(), packet);
        }
        else {
            // process other icmp messages, process icmp errors
        }
        delete packet;
    }
    else
#endif
    {
        throw cRuntimeError("Unaccepted packet: %s(%s)", packet->getName(), packet->getClassName());
    }
}

startSendingPingRequests()

void inet::PingApp::startSendingPingRequests ( )

protectedvirtual

{
    ASSERT(!timer->isScheduled());
    pid = getSimulation()->getUniqueNumber();
    lastStart = simTime();
    timer->setKind(PING_FIRST_ADDR);
    sentCount = 0;
    sendSeqNo = 0;
    scheduleNextPingRequest(-1, false);
}

Referenced by handleStartOperation().

Member Data Documentation

continuous

bool inet::PingApp::continuous = false

protected

Referenced by handleSelfMessage(), and initialize().

count

int inet::PingApp::count = 0

protected

Referenced by handleSelfMessage(), initialize(), and isEnabled().

crcMode

CrcMode inet::PingApp::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by initialize(), and sendPingRequest().

currentSocket

INetworkSocket* inet::PingApp::currentSocket = nullptr

protected

Referenced by handleCrashOperation(), handleSelfMessage(), handleStopOperation(), sendPingRequest(), and socketClosed().

destAddr

L3Address inet::PingApp::destAddr

protected

Referenced by handleCrashOperation(), handleSelfMessage(), handleStopOperation(), and sendPingRequest().

destAddresses

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

protected

Referenced by handleCrashOperation(), handleSelfMessage(), handleStopOperation(), and parseDestAddressesPar().

destAddrIdx

int inet::PingApp::destAddrIdx = -1

protected

Referenced by handleCrashOperation(), handleSelfMessage(), and handleStopOperation().

expectedReplySeqNo

long inet::PingApp::expectedReplySeqNo = 0

protected

Referenced by countPingResponse(), finish(), handleCrashOperation(), handleStopOperation(), and initialize().

hopLimit

int inet::PingApp::hopLimit = 0

protected

Referenced by initialize(), and sendPingRequest().

l3Echo

const std::map< const Protocol *, const Protocol * > inet::PingApp::l3Echo

staticprotected

Referenced by handleSelfMessage().

lastStart

simtime_t inet::PingApp::lastStart

protected

Referenced by handleCrashOperation(), handleStopOperation(), initialize(), and startSendingPingRequests().

lossCount

long inet::PingApp::lossCount = 0

protected

Referenced by countPingResponse(), finish(), and initialize().

nodeStatus

NodeStatus* inet::PingApp::nodeStatus = nullptr

protected

numDuplicatedPongs

long inet::PingApp::numDuplicatedPongs = 0

protected

Referenced by countPingResponse().

numLostSignal

simsignal_t inet::PingApp::numLostSignal = registerSignal("numLost")

staticprotected

Referenced by countPingResponse().

numOutOfOrderArrivalsSignal

simsignal_t inet::PingApp::numOutOfOrderArrivalsSignal = registerSignal("numOutOfOrderArrivals")

staticprotected

Referenced by countPingResponse().

numPongs

long inet::PingApp::numPongs = 0

protected

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

outOfOrderArrivalCount

long inet::PingApp::outOfOrderArrivalCount = 0

protected

Referenced by countPingResponse(), finish(), and initialize().

packetSize

int inet::PingApp::packetSize = 0

protected

Referenced by initialize(), and sendPingRequest().

pid

int inet::PingApp::pid = 0

protected

Referenced by handleCrashOperation(), handleStopOperation(), initialize(), processPingResponse(), sendPingRequest(), and startSendingPingRequests().

pingRxSeqSignal

simsignal_t inet::PingApp::pingRxSeqSignal = registerSignal("pingRxSeq")

staticprotected

Referenced by countPingResponse().

pingTxSeqSignal

simsignal_t inet::PingApp::pingTxSeqSignal = registerSignal("pingTxSeq")

staticprotected

Referenced by sendPingRequest().

pongReceived

bool inet::PingApp::pongReceived[PING_HISTORY_SIZE]

protected

Referenced by initialize(), processPingResponse(), and sendPingRequest().

printPing

bool inet::PingApp::printPing = false

protected

Referenced by finish(), initialize(), and processPingResponse().

rttSignal

simsignal_t inet::PingApp::rttSignal = registerSignal("rtt")

staticprotected

Referenced by countPingResponse().

rttStat

cStdDev inet::PingApp::rttStat

protected

Referenced by countPingResponse(), finish(), and initialize().

sendIntervalPar

cPar* inet::PingApp::sendIntervalPar = nullptr

protected

Referenced by initialize(), and scheduleNextPingRequest().

sendSeqNo

long inet::PingApp::sendSeqNo = 0

protected

Referenced by finish(), handleCrashOperation(), handleSelfMessage(), handleStopOperation(), initialize(), processPingResponse(), sendPingRequest(), and startSendingPingRequests().

sendTimeHistory

simtime_t inet::PingApp::sendTimeHistory[PING_HISTORY_SIZE]

protected

Referenced by initialize(), processPingResponse(), and sendPingRequest().

sentCount

long inet::PingApp::sentCount = 0

protected

Referenced by initialize(), isEnabled(), refreshDisplay(), sendPingRequest(), and startSendingPingRequests().

sleepDurationPar

cPar* inet::PingApp::sleepDurationPar = nullptr

protected

Referenced by initialize(), and scheduleNextPingRequest().

socketMap

SocketMap inet::PingApp::socketMap

protected

Referenced by handleCrashOperation(), handleMessageWhenUp(), handleSelfMessage(), handleStopOperation(), socketClosed(), and ~PingApp().

srcAddr

L3Address inet::PingApp::srcAddr

protected

Referenced by handleCrashOperation(), handleSelfMessage(), handleStopOperation(), parseDestAddressesPar(), and sendPingRequest().

startTime

simtime_t inet::PingApp::startTime

protected

Referenced by initialize(), and scheduleNextPingRequest().

stopTime

simtime_t inet::PingApp::stopTime

protected

Referenced by initialize(), and scheduleNextPingRequest().

timer

cMessage* inet::PingApp::timer = nullptr

protected

Referenced by cancelNextPingRequest(), initialize(), scheduleNextPingRequest(), startSendingPingRequests(), and ~PingApp().

---

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

• PingApp.h
• PingApp.cc