inet::Icmpv6 Class Reference

ICMPv6 implementation. More...

#include <Icmpv6.h>

Inheritance diagram for inet::Icmpv6:

Public Member Functions
virtual void	sendErrorMessage (Packet *datagram, Icmpv6Type type, int code)
	This method can be called from other modules to send an ICMPv6 error packet. More...
void	insertCrc (const Ptr< Icmpv6Header > &icmpHeader, Packet *packet)
Public Member Functions inherited from inet::LifecycleUnsupported
virtual bool	handleOperationStage (LifecycleOperation *operation, IDoneCallback *doneCallback) override
	Perform one stage of a lifecycle operation. More...
Public Member Functions inherited from inet::ILifecycle
virtual	~ILifecycle ()
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 bool	verifyCrc (const Packet *packet)
static void	insertCrc (CrcMode crcMode, const Ptr< Icmpv6Header > &icmpHeader, Packet *packet)

Protected Types
typedef std::map< long, int >	PingMap

Protected Member Functions
virtual void	sendToIP (Packet *msg, const Ipv6Address &dest)
virtual void	sendToIP (Packet *msg)
virtual Packet *	createDestUnreachableMsg (Icmpv6DestUnav code)
virtual Packet *	createPacketTooBigMsg (int mtu)
virtual Packet *	createTimeExceededMsg (Icmpv6TimeEx code)
virtual Packet *	createParamProblemMsg (Icmpv6ParameterProblem code)
virtual void	initialize (int stage) override
	Initialization. More...
virtual int	numInitStages () const override
virtual void	handleMessage (cMessage *msg) override
	Processing of messages that arrive in this module. More...
virtual void	processICMPv6Message (Packet *packet)
virtual void	processEchoRequest (Packet *packet, const Ptr< const Icmpv6EchoRequestMsg > &header)
	Respond to the machine that tried to ping us. More...
virtual void	processEchoReply (Packet *packet, const Ptr< const Icmpv6EchoReplyMsg > &header)
	Forward the ping reply to the "pingOut" of this module. More...
virtual bool	validateDatagramPromptingError (Packet *packet)
	Validate the received Ipv6 datagram before responding with error message. More...
virtual void	errorOut (const Ptr< const Icmpv6Header > &header)
virtual void	handleRegisterService (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override
virtual void	handleRegisterProtocol (const Protocol &protocol, cGate *gate, ServicePrimitive servicePrimitive) override

Protected Attributes
CrcMode	crcMode = CRC_MODE_UNDEFINED
PingMap	pingMap
std::set< int >	transportProtocols

Detailed Description

ICMPv6 implementation.

Member Typedef Documentation

PingMap

typedef std::map<long, int> inet::Icmpv6::PingMap

protected

Member Function Documentation

createDestUnreachableMsg()

Packet * inet::Icmpv6::createDestUnreachableMsg ( Icmpv6DestUnav  code )

protectedvirtual

{
    auto errorMsg = makeShared<Icmpv6DestUnreachableMsg>();
    errorMsg->setType(ICMPv6_DESTINATION_UNREACHABLE);
    errorMsg->setCode(code);
    auto packet = new Packet("Dest Unreachable");
    packet->insertAtBack(errorMsg);
    return packet;
}

Referenced by sendErrorMessage().

createPacketTooBigMsg()

Packet * inet::Icmpv6::createPacketTooBigMsg ( int  mtu )

protectedvirtual

{
    auto errorMsg = makeShared<Icmpv6PacketTooBigMsg>();
    errorMsg->setType(ICMPv6_PACKET_TOO_BIG);
    errorMsg->setCode(0); // Set to 0 by sender and ignored by receiver.
    errorMsg->setMTU(mtu);
    auto packet = new Packet("Packet Too Big");
    packet->insertAtBack(errorMsg);
    return packet;
}

Referenced by sendErrorMessage().

createParamProblemMsg()

Packet * inet::Icmpv6::createParamProblemMsg ( Icmpv6ParameterProblem  code )

protectedvirtual

{
    auto errorMsg = makeShared<Icmpv6ParamProblemMsg>();
    errorMsg->setType(ICMPv6_PARAMETER_PROBLEM);
    errorMsg->setCode(code);
    // TODO What Pointer? section 3.4
    auto packet = new Packet("Parameter Problem");
    packet->insertAtBack(errorMsg);
    return packet;
}

Referenced by sendErrorMessage().

createTimeExceededMsg()

Packet * inet::Icmpv6::createTimeExceededMsg ( Icmpv6TimeEx  code )

protectedvirtual

{
    auto errorMsg = makeShared<Icmpv6TimeExceededMsg>();
    errorMsg->setType(ICMPv6_TIME_EXCEEDED);
    errorMsg->setCode(code);
    auto packet = new Packet("Time Exceeded");
    packet->insertAtBack(errorMsg);
    return packet;
}

Referenced by sendErrorMessage().

errorOut()

void inet::Icmpv6::errorOut ( const Ptr< const Icmpv6Header > &  header )

protectedvirtual

{
}

Referenced by processICMPv6Message().

handleMessage()

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

overrideprotectedvirtual

Processing of messages that arrive in this module.

Messages arrived here could be for ICMP ping requests or ICMPv6 messages that require processing.

{
    ASSERT(!msg->isSelfMessage()); // no timers in ICMPv6
 
    // process arriving ICMP message
    if (msg->getArrivalGate()->isName("ipv6In")) {
        EV_INFO << "Processing ICMPv6 message.\n";
        processICMPv6Message(check_and_cast<Packet *>(msg));
        return;
    }
    else
        throw cRuntimeError("Message %s(%s) arrived in unknown '%s' gate", msg->getName(), msg->getClassName(), msg->getArrivalGate()->getName());
}

handleRegisterProtocol()

void inet::Icmpv6::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::Icmpv6::handleRegisterService ( const Protocol &  protocol, cGate *  gate, ServicePrimitive  servicePrimitive  )

overrideprotectedvirtual

Reimplemented from inet::DefaultProtocolRegistrationListener.

{
    Enter_Method("handleRegisterService");
}

initialize()

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

overrideprotectedvirtual

Initialization.

{
    cSimpleModule::initialize(stage);
 
    if (stage == INITSTAGE_LOCAL) {
        const char *crcModeString = par("crcMode");
        crcMode = parseCrcMode(crcModeString, false);
    }
    else if (stage == INITSTAGE_NETWORK_LAYER_PROTOCOLS) {
        bool isOperational;
        NodeStatus *nodeStatus = dynamic_cast<NodeStatus *>(getContainingNode(this)->getSubmodule("status"));
        isOperational = (!nodeStatus) || nodeStatus->getState() == NodeStatus::UP;
        if (!isOperational)
            throw cRuntimeError("This module doesn't support starting in node DOWN state");
        registerService(Protocol::icmpv6, gate("transportIn"), gate("transportOut"));
        registerProtocol(Protocol::icmpv6, gate("ipv6Out"), gate("ipv6In"));
    }
}

insertCrc() [1/2]

void inet::Icmpv6::insertCrc ( const Ptr< Icmpv6Header > &  icmpHeader, Packet *  packet  )

inline

{ insertCrc(crcMode, icmpHeader, packet); }

Referenced by insertCrc().

insertCrc() [2/2]

void inet::Icmpv6::insertCrc ( CrcMode  crcMode, const Ptr< Icmpv6Header > &  icmpHeader, Packet *  packet  )

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 inet::Ipv6NeighbourDiscovery::createAndSendNsPacket(), inet::Ipv6NeighbourDiscovery::createAndSendRaPacket(), inet::Ipv6NeighbourDiscovery::createAndSendRsPacket(), processEchoRequest(), sendErrorMessage(), inet::PingApp::sendPingRequest(), inet::Ipv6NeighbourDiscovery::sendSolicitedNa(), and inet::Ipv6NeighbourDiscovery::sendUnsolicitedNa().

numInitStages()

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

inlineoverrideprotectedvirtual

{ return NUM_INIT_STAGES; }

processEchoReply()

void inet::Icmpv6::processEchoReply ( Packet *  packet, const Ptr< const Icmpv6EchoReplyMsg > &  header  )

protectedvirtual

Forward the ping reply to the "pingOut" of this module.

{
    delete packet;
}

Referenced by processICMPv6Message().

processEchoRequest()

void inet::Icmpv6::processEchoRequest ( Packet *  packet, const Ptr< const Icmpv6EchoRequestMsg > &  header  )

protectedvirtual

Respond to the machine that tried to ping us.

{
    // Create an ICMPv6 Reply Message
    auto replyPacket = new Packet();
    replyPacket->setName((std::string(requestPacket->getName()) + "-reply").c_str());
    auto replyHeader = makeShared<Icmpv6EchoReplyMsg>();
    replyHeader->setIdentifier(requestHeader->getIdentifier());
    replyHeader->setSeqNumber(requestHeader->getSeqNumber());
    replyPacket->insertAtBack(requestPacket->peekData());
    insertCrc(replyHeader, replyPacket);
    replyPacket->insertAtFront(replyHeader);
 
    auto addressInd = requestPacket->getTag<L3AddressInd>();
    replyPacket->addTag<PacketProtocolTag>()->setProtocol(&Protocol::icmpv6);
    auto addressReq = replyPacket->addTag<L3AddressReq>();
    addressReq->setDestAddress(addressInd->getSrcAddress());
 
    if (addressInd->getDestAddress().isMulticast() /*TODO check for anycast too*/) {
        IInterfaceTable *it = getModuleFromPar<IInterfaceTable>(par("interfaceTableModule"), this);
        auto ipv6Data = it->getInterfaceById(requestPacket->getTag<InterfaceInd>()->getInterfaceId())->getProtocolDataForUpdate<Ipv6InterfaceData>();
        addressReq->setSrcAddress(ipv6Data->getPreferredAddress());
        // TODO implement default address selection properly.
        //      According to RFC 3484, the source address to be used
        //      depends on the destination address
    }
    else
        addressReq->setSrcAddress(addressInd->getDestAddress());
 
    delete requestPacket;
    sendToIP(replyPacket);
}

Referenced by processICMPv6Message().

processICMPv6Message()

void inet::Icmpv6::processICMPv6Message ( Packet *  packet )

protectedvirtual

{
    if (!verifyCrc(packet)) {
        // drop packet
        EV_WARN << "incoming ICMP packet has wrong CRC, dropped\n";
        PacketDropDetails details;
        details.setReason(INCORRECTLY_RECEIVED);
        emit(packetDroppedSignal, packet, &details);
        delete packet;
        return;
    }
 
    auto icmpv6msg = packet->peekAtFront<Icmpv6Header>();
    int type = icmpv6msg->getType();
    if (type < 128) {
        // ICMP errors are delivered to the appropriate higher layer protocols
        EV_INFO << "ICMPv6 packet: passing it to higher layer\n";
        const auto& bogusIpv6Header = packet->peekDataAt<Ipv6Header>(icmpv6msg->getChunkLength());
        int transportProtocol = bogusIpv6Header->getProtocolId();
        if (transportProtocol == IP_PROT_IPv6_ICMP) {
            // ICMP error answer to an ICMP packet:
            errorOut(icmpv6msg);
            delete packet;
        }
        else {
            auto dispatchProtocolReq = packet->addTagIfAbsent<DispatchProtocolReq>();
            dispatchProtocolReq->setServicePrimitive(SP_INDICATION);
            dispatchProtocolReq->setProtocol(ProtocolGroup::ipprotocol.getProtocol(transportProtocol));
            send(packet, "transportOut");
        }
    }
    else {
        auto icmpv6msg = packet->popAtFront<Icmpv6Header>();
        if (dynamicPtrCast<const Icmpv6DestUnreachableMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Destination Unreachable Message Received." << endl;
            errorOut(icmpv6msg);
            delete packet;
        }
        else if (dynamicPtrCast<const Icmpv6PacketTooBigMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Packet Too Big Message Received." << endl;
            errorOut(icmpv6msg);
            delete packet;
        }
        else if (dynamicPtrCast<const Icmpv6TimeExceededMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Time Exceeded Message Received." << endl;
            errorOut(icmpv6msg);
            delete packet;
        }
        else if (dynamicPtrCast<const Icmpv6ParamProblemMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Parameter Problem Message Received." << endl;
            errorOut(icmpv6msg);
            delete packet;
        }
        else if (auto echoRequest = dynamicPtrCast<const Icmpv6EchoRequestMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Echo Request Message Received." << endl;
            processEchoRequest(packet, echoRequest);
        }
        else if (auto echoReply = dynamicPtrCast<const Icmpv6EchoReplyMsg>(icmpv6msg)) {
            EV_INFO << "ICMPv6 Echo Reply Message Received." << endl;
            processEchoReply(packet, echoReply);
        }
        else
            throw cRuntimeError("Unknown message type received: (%s)%s.\n", icmpv6msg->getClassName(), icmpv6msg->getName());
    }
}

Referenced by handleMessage(), and sendErrorMessage().

sendErrorMessage()

void inet::Icmpv6::sendErrorMessage ( Packet *  datagram, Icmpv6Type  type, int  code  )

virtual

This method can be called from other modules to send an ICMPv6 error packet.

RFC 2463, Section 3: ICMPv6 Error Messages There are a total of 4 ICMPv6 error messages as described in the RFC. This method will construct and send error messages corresponding to the given type. Error Types:

• Destination Unreachable Message - 1
• Packet Too Big Message - 2
• Time Exceeded Message - 3
• Parameter Problem Message - 4 Code Types have different semantics for each error type. See RFC 2463.

{
    Enter_Method("sendErrorMessage(datagram, type=%d, code=%d)", type, code);
 
    if (!validateDatagramPromptingError(origDatagram))
        return;
 
    Packet *errorMsg;
 
    if (type == ICMPv6_DESTINATION_UNREACHABLE)
        errorMsg = createDestUnreachableMsg(static_cast<Icmpv6DestUnav>(code));
    // TODO implement MTU support.
    else if (type == ICMPv6_PACKET_TOO_BIG)
        errorMsg = createPacketTooBigMsg(0);
    else if (type == ICMPv6_TIME_EXCEEDED)
        errorMsg = createTimeExceededMsg(static_cast<Icmpv6TimeEx>(code));
    else if (type == ICMPv6_PARAMETER_PROBLEM)
        errorMsg = createParamProblemMsg(static_cast<Icmpv6ParameterProblem>(code));
    else
        throw cRuntimeError("Unknown ICMPv6 error type: %d\n", type);
 
    // Encapsulate the original datagram, but the whole ICMPv6 error
    // packet cannot be larger than the minimum Ipv6 MTU (RFC 4443 2.4. (c)).
    // NOTE: since we just overwrite the errorMsg length without actually
    // truncating origDatagram, one can get "packet length became negative"
    // error when decapsulating the origDatagram on the receiver side.
    // A workaround is to avoid decapsulation, or to manually set the
    // errorMessage length to be larger than the encapsulated message.
    b copyLength = B(IPv6_MIN_MTU) - errorMsg->getTotalLength();
    errorMsg->insertAtBack(origDatagram->peekDataAt(b(0), std::min(copyLength, origDatagram->getDataLength())));
 
    auto icmpHeader = errorMsg->removeAtFront<Icmpv6Header>();
    insertCrc(icmpHeader, errorMsg);
    errorMsg->insertAtFront(icmpHeader);
 
    // debugging information
    EV_DEBUG << "sending ICMP error: (" << errorMsg->getClassName() << ")" << errorMsg->getName()
             << " type=" << type << " code=" << code << endl;
 
    // if srcAddr is not filled in, we're still in the src node, so we just
    // process the ICMP message locally, right away
    const auto& ipv6Header = origDatagram->peekAtFront<Ipv6Header>();
    if (ipv6Header->getSrcAddress().isUnspecified()) {
        // pretend it came from the IP layer
        errorMsg->addTag<PacketProtocolTag>()->setProtocol(&Protocol::icmpv6);
        errorMsg->addTag<L3AddressInd>()->setSrcAddress(Ipv6Address::LOOPBACK_ADDRESS); // FIXME maybe use configured loopback address
 
        // then process it locally
        processICMPv6Message(errorMsg);
    }
    else {
        sendToIP(errorMsg, ipv6Header->getSrcAddress());
    }
}

Referenced by inet::Ipv6FragBuf::addFragment(), and inet::Ipv6FragBuf::purgeStaleFragments().

sendToIP() [1/2]

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

protectedvirtual

{
    msg->addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv6);
    msg->addTagIfAbsent<PacketProtocolTag>()->setProtocol(&Protocol::icmpv6);
    send(msg, "ipv6Out");
}

sendToIP() [2/2]

void inet::Icmpv6::sendToIP ( Packet *  msg, const Ipv6Address &  dest  )

protectedvirtual

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

Referenced by processEchoRequest(), and sendErrorMessage().

validateDatagramPromptingError()

bool inet::Icmpv6::validateDatagramPromptingError ( Packet *  packet )

protectedvirtual

Validate the received Ipv6 datagram before responding with error message.

{
    auto ipv6Header = packet->peekAtFront<Ipv6Header>();
    // don't send ICMP error messages for multicast messages
    if (ipv6Header->getDestAddress().isMulticast()) {
        EV_INFO << "won't send ICMP error messages for multicast message " << ipv6Header << endl;
        return false;
    }
 
    // do not reply with error message to error message
    if (ipv6Header->getProtocolId() == IP_PROT_IPv6_ICMP) {
        auto recICMPMsg = packet->peekDataAt<Icmpv6Header>(ipv6Header->getChunkLength());
        if (recICMPMsg->getType() < 128) {
            EV_INFO << "ICMP error received -- do not reply to it" << endl;
            return false;
        }
    }
    return true;
}

Referenced by sendErrorMessage().

verifyCrc()

bool inet::Icmpv6::verifyCrc ( const Packet *  packet )

static

{
    const auto& icmpHeader = packet->peekAtFront<Icmpv6Header>(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 inet::Icmpv6ProtocolDissector::dissect(), and processICMPv6Message().

Member Data Documentation

crcMode

CrcMode inet::Icmpv6::crcMode = CRC_MODE_UNDEFINED

protected

Referenced by initialize(), and insertCrc().

pingMap

PingMap inet::Icmpv6::pingMap

protected

transportProtocols

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

protected

Referenced by handleRegisterProtocol().

---

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

• Icmpv6.h
• Icmpv6.cc