inet::Icmp Class Reference

Icmp module. More...

#include <Icmp.h>

Inheritance diagram for inet::Icmp:

Public Member Functions
virtual void	sendErrorMessage (Packet *packet, int inputInterfaceId, IcmpType type, IcmpCode code)
	This method can be called from other modules to send an ICMP error packet in response to a received bogus packet. More...
virtual void	sendPtbMessage (Packet *packet, int mtu)
void	insertCrc (const Ptr< IcmpHeader > &icmpHeader, Packet *payload)
bool	verifyCrc (const Packet *packet)
Public Member Functions inherited from inet::DefaultProtocolRegistrationListener
virtual void	handleRegisterServiceGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocolGroup (const ProtocolGroup &protocolGroup, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyService (cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterAnyProtocol (cGate *gate, ServicePrimitive servicePrimitive) override

Static Public Member Functions
static void	insertCrc (CrcMode crcMode, const Ptr< IcmpHeader > &icmpHeader, Packet *payload)

Protected Member Functions
virtual void	processIcmpMessage (Packet *)
virtual void	errorOut (Packet *)
virtual void	processEchoRequest (Packet *)
virtual void	sendToIP (Packet *, const Ipv4Address &dest)
virtual void	sendToIP (Packet *msg)
virtual bool	possiblyLocalBroadcast (const Ipv4Address &addr, int interfaceId)
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual int	numInitStages () const override
virtual void	initialize (int stage) override
virtual void	handleMessage (cMessage *msg) override
virtual void	handleParameterChange (const char *name) override
virtual void	parseQuoteLengthParameter ()
virtual bool	maySendErrorMessage (Packet *packet, int inputInterfaceId)
virtual void	sendOrProcessIcmpPacket (Packet *packet, Ipv4Address origSrcAddr)

Protected Attributes
std::set< int >	transportProtocols
CrcMode	crcMode = CRC_MODE_UNDEFINED
B	quoteLength
ModuleRefByPar< IIpv4RoutingTable >	rt
ModuleRefByPar< IInterfaceTable >	ift

Static Protected Attributes
static long	ctr = 0

Detailed Description

Icmp module.

Member Function Documentation

errorOut()

void inet::Icmp::errorOut ( Packet *  packet )

protectedvirtual

{
    delete packet;
}

Referenced by processIcmpMessage().

handleMessage()

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

overrideprotectedvirtual

{
    cGate *arrivalGate = msg->getArrivalGate();
 
    // process arriving ICMP message
    if (arrivalGate->isName("ipIn")) {
        EV_INFO << "Received " << msg << " from network protocol.\n";
        processIcmpMessage(check_and_cast<Packet *>(msg));
        return;
    }
    else
        throw cRuntimeError("Message %s(%s) arrived in unknown '%s' gate", msg->getName(), msg->getClassName(), msg->getArrivalGate()->getName());
}

handleParameterChange()

void inet::Icmp::handleParameterChange ( const char *  name )

overrideprotectedvirtual

{
    if (name == nullptr)
        ;
    else if (!strcmp(name, "crcMode"))
        crcMode = parseCrcMode(par("crcMode"), false);
    else if (!strcmp(name, "quoteLength"))
        parseQuoteLengthParameter();
}

handleRegisterProtocol()

void inet::Icmp::handleRegisterProtocol ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterProtocol");
    if (!strcmp("transportOut", gate->getBaseName())) {
        int protocolNumber = ProtocolGroup::ipprotocol.findProtocolNumber(&protocol);
        if (protocolNumber != -1)
            transportProtocols.insert(protocolNumber);
    }
}

handleRegisterService()

void inet::Icmp::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

initialize()

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

overrideprotectedvirtual

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        ift.reference(this, "interfaceTableModule", true);
        rt.reference(this, "routingTableModule", true);
        crcMode = parseCrcMode(par("crcMode"), false);
        parseQuoteLengthParameter();
    }
    if (stage == INITSTAGE_NETWORK_LAYER_PROTOCOLS) {
        registerService(Protocol::icmpv4, gate("transportIn"), gate("transportOut"));
        registerProtocol(Protocol::icmpv4, gate("ipOut"), gate("ipIn"));
    }
}

insertCrc() [1/2]

void inet::Icmp::insertCrc ( const Ptr< IcmpHeader > &  icmpHeader, Packet *  payload  )

inline

{ insertCrc(crcMode, icmpHeader, payload); }

Referenced by insertCrc().

insertCrc() [2/2]

void inet::Icmp::insertCrc ( CrcMode  crcMode, const Ptr< IcmpHeader > &  icmpHeader, Packet *  payload  )

static

{
    icmpHeader->setCrcMode(crcMode);
    switch (crcMode) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then set the CRC to an easily recognizable value
            icmpHeader->setChksum(0xC00D);
            break;
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then set the CRC to an easily recognizable value
            icmpHeader->setChksum(0xBAAD);
            break;
        case CRC_COMPUTED: {
            // if the CRC mode is computed, then compute the CRC and set it
            icmpHeader->setChksum(0x0000); // make sure that the CRC is 0 in the header before computing the CRC
            MemoryOutputStream icmpStream;
            Chunk::serialize(icmpStream, icmpHeader);
            if (packet->getByteLength() > 0)
                Chunk::serialize(icmpStream, packet->peekDataAsBytes());
            uint16_t crc = TcpIpChecksum::checksum(icmpStream.getData());
            icmpHeader->setChksum(crc);
            break;
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
}

Referenced by processEchoRequest(), sendErrorMessage(), inet::PingApp::sendPingRequest(), and sendPtbMessage().

maySendErrorMessage()

bool inet::Icmp::maySendErrorMessage ( Packet *  packet, int  inputInterfaceId  )

protectedvirtual

{
    const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
    Ipv4Address origSrcAddr = ipv4Header->getSrcAddress();
    Ipv4Address origDestAddr = ipv4Header->getDestAddress();
 
    // don't send ICMP error messages in response to broadcast or multicast messages
    if (origDestAddr.isMulticast() || origDestAddr.isLimitedBroadcastAddress() || possiblyLocalBroadcast(origDestAddr, inputInterfaceId)) {
        EV_DETAIL << "won't send ICMP error messages for broadcast/multicast message " << ipv4Header << endl;
        return false;
    }
 
    // don't send ICMP error messages response to unspecified, broadcast or multicast addresses
    if ((inputInterfaceId != -1 && origSrcAddr.isUnspecified())
            || origSrcAddr.isMulticast()
            || origSrcAddr.isLimitedBroadcastAddress()
            || possiblyLocalBroadcast(origSrcAddr, inputInterfaceId)) {
        EV_DETAIL << "won't send ICMP error messages to broadcast/multicast address, message " << ipv4Header << endl;
        return false;
    }
 
    // ICMP messages are only sent about errors in handling fragment zero of fragmented datagrams
    if (ipv4Header->getFragmentOffset() != 0) {
        EV_DETAIL << "won't send ICMP error messages about errors in non-first fragments" << endl;
        return false;
    }
 
    // do not reply with error message to error message
    if (ipv4Header->getProtocolId() == IP_PROT_ICMP) {
        const auto& recICMPMsg = packet->peekDataAt<IcmpHeader>(B(ipv4Header->getHeaderLength()));
        if (!isIcmpInfoType(recICMPMsg->getType())) {
            EV_DETAIL << "ICMP error received -- do not reply to it" << endl;
            return false;
        }
    }
 
    return true;
}

Referenced by sendErrorMessage(), and sendPtbMessage().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

parseQuoteLengthParameter()

void inet::Icmp::parseQuoteLengthParameter ( )

protectedvirtual

{
    quoteLength = B(par("quoteLength"));
    if (quoteLength < B(8))
        throw cRuntimeError("The quoteLength must be 8 bytes or larger");
}

Referenced by handleParameterChange(), and initialize().

possiblyLocalBroadcast()

bool inet::Icmp::possiblyLocalBroadcast ( const Ipv4Address &  addr, int  interfaceId  )

protectedvirtual

{
    if ((addr.getInt() & 1) == 0)
        return false;
 
    if (rt->isLocalBroadcastAddress(addr))
        return true;
 
    // if the input interface is unconfigured, we won't recognize network-directed broadcasts because we don't what network we are on
    if (interfaceId != -1) {
        NetworkInterface *ie = ift->getInterfaceById(interfaceId);
        auto ipv4Data = ie->findProtocolData<Ipv4InterfaceData>();
        bool interfaceUnconfigured = (ipv4Data == nullptr) || ipv4Data->getIPAddress().isUnspecified();
        return interfaceUnconfigured;
    }
    else {
        // if all interfaces are configured, we are OK
        bool allInterfacesConfigured = true;
        for (int i = 0; i < ift->getNumInterfaces(); i++) {
            auto ipv4Data = ift->getInterface(i)->findProtocolData<Ipv4InterfaceData>();
            if ((ipv4Data == nullptr) || ipv4Data->getIPAddress().isUnspecified())
                allInterfacesConfigured = false;
        }
 
        return !allInterfacesConfigured;
    }
}

Referenced by maySendErrorMessage().

processEchoRequest()

void inet::Icmp::processEchoRequest ( Packet *  request )

protectedvirtual

{
    // turn request into a reply
    const auto& icmpReq = request->popAtFront<IcmpEchoRequest>();
    Packet *reply = new Packet((std::string(request->getName()) + "-reply").c_str());
    const auto& icmpReply = makeShared<IcmpEchoReply>();
    icmpReply->setIdentifier(icmpReq->getIdentifier());
    icmpReply->setSeqNumber(icmpReq->getSeqNumber());
    auto addressInd = request->getTag<L3AddressInd>();
    Ipv4Address src = addressInd->getSrcAddress().toIpv4();
    Ipv4Address dest = addressInd->getDestAddress().toIpv4();
    reply->insertAtBack(request->peekData());
    insertCrc(icmpReply, reply);
    reply->insertAtFront(icmpReply);
 
    // swap src and dest
    // TODO check what to do if dest was multicast etc?
    // A. Ariza Modification 5/1/2011 clean the interface id, this forces the use of routing table in the Ipv4 layer
    auto addressReq = reply->addTag<L3AddressReq>();
    addressReq->setSrcAddress(addressInd->getDestAddress().toIpv4());
    addressReq->setDestAddress(addressInd->getSrcAddress().toIpv4());
 
    sendToIP(reply);
    delete request;
}

Referenced by processIcmpMessage().

processIcmpMessage()

void inet::Icmp::processIcmpMessage ( Packet *  packet )

protectedvirtual

{
    if (!verifyCrc(packet)) {
        EV_WARN << "incoming ICMP packet has wrong CRC, dropped\n";
        // drop packet
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    const auto& icmpmsg = packet->peekAtFront<IcmpHeader>();
    switch (icmpmsg->getType()) {
        case ICMP_REDIRECT:
            // TODO implement redirect handling
            EV_ERROR << "ICMP_REDIRECT not implemented yet, packet " << EV_FORMAT_OBJECT(packet) << " dropped.\n";
            delete packet;
            break;
 
        case ICMP_DESTINATION_UNREACHABLE:
        case ICMP_TIME_EXCEEDED:
        case ICMP_PARAMETER_PROBLEM: {
            // ICMP errors are delivered to the appropriate higher layer protocol
            const auto& bogusL3Packet = packet->peekDataAt<Ipv4Header>(icmpmsg->getChunkLength());
            int transportProtocol = bogusL3Packet->getProtocolId();
            if (transportProtocol == IP_PROT_ICMP) {
                // received ICMP error answer to an ICMP packet:
                // FIXME should send up dest unreachable answers to pingapps
                errorOut(packet);
            }
            else {
                if (!contains(transportProtocols, transportProtocol)) {
                    EV_ERROR << "Transport protocol " << transportProtocol << " not registered, packet dropped\n";
                    delete packet;
                }
                else {
                    auto dispatchProtocolReq = packet->addTagIfAbsent<DispatchProtocolReq>();
                    dispatchProtocolReq->setServicePrimitive(SP_INDICATION);
                    dispatchProtocolReq->setProtocol(ProtocolGroup::ipprotocol.getProtocol(transportProtocol));
                    packet->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::icmpv4);
                    send(packet, "transportOut");
                }
            }
            break;
        }
 
        case ICMP_ECHO_REQUEST:
            processEchoRequest(packet);
            break;
 
        case ICMP_ECHO_REPLY:
            delete packet;
            break;
 
        case ICMP_TIMESTAMP_REQUEST:
            processEchoRequest(packet);
            break;
 
        case ICMP_TIMESTAMP_REPLY:
            delete packet;
            break;
 
        default:
            throw cRuntimeError("Unknown ICMP type %d", icmpmsg->getType());
    }
}

Referenced by handleMessage(), and sendOrProcessIcmpPacket().

sendErrorMessage()

void inet::Icmp::sendErrorMessage ( Packet *  packet, int  inputInterfaceId, IcmpType  type, IcmpCode  code  )

virtual

This method can be called from other modules to send an ICMP error packet in response to a received bogus packet.

It will not send ICMP error in response to broadcast or multicast packets – in that case it will simply delete the packet. KLUDGE if inputInterfaceId cannot be determined, pass in -1.

{
    Enter_Method("sendErrorMessage(datagram, type=%d, code=%d)", type, code);
 
    if (maySendErrorMessage(packet, inputInterfaceId)) {
        // assemble a message name
        char msgname[80];
        sprintf(msgname, "ICMP-error-#%ld-type%d-code%d", ++ctr, type, code);
 
        // debugging information
        EV_DETAIL << "sending ICMP error " << msgname << endl;
 
        // create and send ICMP packet
        Packet *errorPacket = new Packet(msgname);
        const auto& icmpHeader = makeShared<IcmpHeader>();
        icmpHeader->setType(type);
        icmpHeader->setCode(code);
        // ICMP message length: the internet header plus the first quoteLength bytes of
        // the original datagram's data is returned to the sender.
        const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
        B curQuoteLength = std::min(B(packet->getDataLength()), ipv4Header->getHeaderLength() + quoteLength);
        errorPacket->insertAtBack(packet->peekDataAt(B(0), curQuoteLength));
        insertCrc(icmpHeader, errorPacket);
        errorPacket->insertAtFront(icmpHeader);
 
        sendOrProcessIcmpPacket(errorPacket, ipv4Header->getSrcAddress());
    }
}

Referenced by inet::Ipv4FragBuf::purgeStaleFragments().

sendOrProcessIcmpPacket()

void inet::Icmp::sendOrProcessIcmpPacket ( Packet *  packet, Ipv4Address  origSrcAddr  )

protectedvirtual

{
    packet->addTag<PacketProtocolTag>()->setProtocol(&Protocol::icmpv4);
 
    // if srcAddr is not filled in, we're still in the src node, so we just
    // process the ICMP message locally, right away
    if (origSrcAddr.isUnspecified()) {
        // pretend it came from the Ipv4 layer
        packet->addTag<L3AddressInd>()->setDestAddress(Ipv4Address::LOOPBACK_ADDRESS);    // FIXME maybe use configured loopback address
 
        // then process it locally
        processIcmpMessage(packet);
    }
    else {
        sendToIP(packet, origSrcAddr);
    }
}

Referenced by sendErrorMessage(), and sendPtbMessage().

sendPtbMessage()

void inet::Icmp::sendPtbMessage ( Packet *  packet, int  mtu  )

virtual

{
    Enter_Method("sendPtbMessage(datagram, mtu=%d)", mtu);
 
    if (maySendErrorMessage(packet, -1)) {
        // assemble a message name
        char msgname[80];
        sprintf(msgname, "ICMP-PTB-#%ld-mtu%d", ++ctr, mtu);
 
        // debugging information
        EV_DETAIL << "sending ICMP PTB " << msgname << endl;
 
        // create and send ICMP packet
        Packet *errorPacket = new Packet(msgname);
        const auto& icmpPtb = makeShared<IcmpPtb>();
        icmpPtb->setMtu(mtu);
        // ICMP message length: the internet header plus the first quoteLength bytes of
        // the original datagram's data is returned to the sender.
        const auto& ipv4Header = packet->peekAtFront<Ipv4Header>();
        B curQuoteLength = std::min(B(packet->getDataLength()), ipv4Header->getHeaderLength() + quoteLength);
        errorPacket->insertAtBack(packet->peekDataAt(b(0), curQuoteLength));
        insertCrc(icmpPtb, errorPacket);
        errorPacket->insertAtFront(icmpPtb);
 
        sendOrProcessIcmpPacket(errorPacket, ipv4Header->getSrcAddress());
    }
}

sendToIP() [1/2]

void inet::Icmp::sendToIP ( Packet *  msg, const Ipv4Address &  dest  )

protectedvirtual

{
    msg->addTagIfAbsent<L3AddressReq>()->setDestAddress(dest);
    sendToIP(msg);
}

Referenced by processEchoRequest(), and sendOrProcessIcmpPacket().

sendToIP() [2/2]

void inet::Icmp::sendToIP ( Packet *  msg )

protectedvirtual

{
    EV_INFO << "Sending " << msg << " to lower layer.\n";
    msg->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv4);
    msg->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::icmpv4);
    send(msg, "ipOut");
}

verifyCrc()

bool inet::Icmp::verifyCrc

(

const Packet *

packet

)

{
    const auto& icmpHeader = packet->peekAtFront<IcmpHeader>(b(-1), Chunk::PF_ALLOW_INCORRECT);
    switch (icmpHeader->getCrcMode()) {
        case CRC_DECLARED_CORRECT:
            // if the CRC mode is declared to be correct, then the check passes if and only if the chunks are correct
            return icmpHeader->isCorrect();
        case CRC_DECLARED_INCORRECT:
            // if the CRC mode is declared to be incorrect, then the check fails
            return false;
        case CRC_COMPUTED: {
            // otherwise compute the CRC, the check passes if the result is 0xFFFF (includes the received CRC)
            auto dataBytes = packet->peekDataAsBytes(Chunk::PF_ALLOW_INCORRECT);
            uint16_t crc = TcpIpChecksum::checksum(dataBytes->getBytes());
            // TODO delete these isCorrect calls, rely on CRC only
            return crc == 0 && icmpHeader->isCorrect();
        }
        default:
            throw cRuntimeError("Unknown CRC mode");
    }
}

Referenced by processIcmpMessage().

Member Data Documentation

crcMode

CrcMode inet::Icmp::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by handleParameterChange(), initialize(), and insertCrc().

ctr

long inet::Icmp::ctr = 0

staticprotected

Referenced by sendErrorMessage(), and sendPtbMessage().

ift

ModuleRefByPar<IInterfaceTable> inet::Icmp::ift

protected

Referenced by initialize(), and possiblyLocalBroadcast().

quoteLength

B inet::Icmp::quoteLength

protected

Referenced by parseQuoteLengthParameter(), sendErrorMessage(), and sendPtbMessage().

rt

ModuleRefByPar<IIpv4RoutingTable> inet::Icmp::rt

protected

Referenced by initialize(), and possiblyLocalBroadcast().

transportProtocols

std::set<int> inet::Icmp::transportProtocols

protected

Referenced by handleRegisterProtocol(), and processIcmpMessage().

---

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

• Icmp.h
• Icmp.cc