IcmpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_ICMP_LAYER
#define PACKETPP_ICMP_LAYER

#include "Layer.h"
#include "IPv4Layer.h"
#ifdef _MSC_VER
#include <Winsock2.h>
#else
#include <sys/time.h>
#endif
#include <vector>



namespace pcpp
{

#pragma pack(push, 1)
    typedef struct icmphdr
    {
        uint8_t  type;
        uint8_t  code;
        uint16_t checksum;
    } icmphdr;
#pragma pack(pop)

    enum IcmpMessageType
    {
        ICMP_ECHO_REPLY           = 0,
        ICMP_DEST_UNREACHABLE     = 3,
        ICMP_SOURCE_QUENCH        = 4,
        ICMP_REDIRECT             = 5,
        ICMP_ECHO_REQUEST         = 8,
        ICMP_ROUTER_ADV           = 9,
        ICMP_ROUTER_SOL           = 10,
        ICMP_TIME_EXCEEDED        = 11,
        ICMP_PARAM_PROBLEM        = 12,
        ICMP_TIMESTAMP_REQUEST    = 13,
        ICMP_TIMESTAMP_REPLY      = 14,
        ICMP_INFO_REQUEST         = 15,
        ICMP_INFO_REPLY           = 16,
        ICMP_ADDRESS_MASK_REQUEST = 17,
        ICMP_ADDRESS_MASK_REPLY   = 18,
        ICMP_UNSUPPORTED          = 255
    };

    enum IcmpDestUnreachableCodes
    {
        IcmpNetworkUnreachable = 0,
        IcmpHostUnreachable = 1,
        IcmpProtocolUnreachable = 2,
        IcmpPortUnreachable = 3,
        IcmpDatagramTooBig = 4,
        IcmpSourceRouteFailed = 5,
        IcmpDestinationNetworkUnknown = 6,
        IcmpDestinationHostUnknown = 7,
        IcmpSourceHostIsolated = 8,
        IcmpDestinationNetworkProhibited = 9,
        IcmpDestinationHostProhibited = 10,
        IcmpNetworkUnreachableForTypeOfService = 11,
        IcmpHostUnreachableForTypeOfService = 12,
        IcmpCommunicationProhibited = 13,
        IcmpHostPrecedenceViolation = 14,
        IcmpPrecedenceCutoff = 15
    };


#pragma pack(push, 1)
    typedef struct icmp_echo_hdr : icmphdr
    {
        uint16_t id;
        uint16_t sequence;
        uint64_t timestamp;
    } icmp_echo_hdr;
#pragma pack(pop)


    typedef struct icmp_echo_request
    {
        icmp_echo_hdr* header;
        size_t dataLength;
        uint8_t* data;
    } icmp_echo_request;


    typedef icmp_echo_request icmp_echo_reply;


#pragma pack(push, 1)
    typedef struct icmp_timestamp_request : icmphdr
    {
        uint16_t id;
        uint16_t sequence;
        uint32_t originateTimestamp;
        uint32_t receiveTimestamp;
        uint32_t transmitTimestamp;
    } icmp_timestamp_request;
#pragma pack(pop)


    typedef icmp_timestamp_request icmp_timestamp_reply;


#pragma pack(push, 1)
    typedef struct icmp_destination_unreachable : icmphdr
    {
        uint16_t unused;
        uint16_t nextHopMTU;
    } icmp_destination_unreachable;
#pragma pack(pop)


#pragma pack(push, 1)
    typedef struct icmp_time_exceeded : icmphdr
    {
        uint32_t unused;
    } icmp_time_exceeded;
#pragma pack(pop)


    typedef icmp_time_exceeded icmp_source_quench;


#pragma pack(push, 1)
    typedef struct icmp_param_problem : icmphdr
    {
        uint8_t  pointer;
        uint8_t  unused1;
        uint16_t unused2;
    } icmp_param_problem;
#pragma pack(pop)


    typedef icmphdr icmp_router_solicitation;

#pragma pack(push, 1)
    typedef struct icmp_redirect : icmphdr
    {
        uint32_t gatewayAddress;
    } icmp_redirect;
#pragma pack(pop)


#pragma pack(push, 1)
    struct icmp_router_address_structure
    {
        uint32_t routerAddress;
        uint32_t preferenceLevel;

        void setRouterAddress(IPv4Address addr, uint32_t preference);

        IPv4Address getAddress() const { return routerAddress; }
    };
#pragma pack(pop)


#pragma pack(push, 1)
    typedef struct icmp_router_advertisement_hdr : icmphdr
    {
        uint8_t  advertisementCount;
        uint8_t  addressEntrySize;
        uint16_t lifetime;
    } icmp_router_advertisement_hdr;
#pragma pack(pop)


    struct icmp_router_advertisement
    {
        icmp_router_advertisement_hdr* header;

        icmp_router_address_structure* getRouterAddress(int index) const;
    };


#pragma pack(push, 1)
    typedef struct icmp_address_mask_request : icmphdr
    {
        uint16_t id;
        uint16_t sequence;
        uint32_t addressMask;
    } icmp_address_mask_request;
#pragma pack(pop)


    typedef icmp_address_mask_request icmp_address_mask_reply;


#pragma pack(push, 1)
    typedef struct icmp_info_request : icmphdr
    {
        uint16_t id;
        uint16_t sequence;
    } icmp_info_request;
#pragma pack(pop)


    typedef icmp_info_request icmp_info_reply;


    class IcmpLayer : public Layer
    {
    private:
        icmp_echo_request m_EchoData;
        mutable icmp_router_advertisement m_RouterAdvData;

        bool cleanIcmpLayer();

        bool setEchoData(IcmpMessageType echoType, uint16_t id, uint16_t sequence, uint64_t timestamp, const uint8_t* data, size_t dataLen);

        bool setIpAndL4Layers(IPv4Layer* ipLayer, Layer* l4Layer);

    public:
        // cppcheck-suppress uninitMemberVar
        IcmpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet) { m_Protocol = ICMP; }

        IcmpLayer();

        virtual ~IcmpLayer() {}

        icmphdr* getIcmpHeader() const { return (icmphdr*)m_Data; }

        IcmpMessageType getMessageType() const;

        bool isMessageOfType(IcmpMessageType type) const { return getMessageType() == type; }

        icmp_echo_request* getEchoRequestData();

        icmp_echo_request* setEchoRequestData(uint16_t id, uint16_t sequence, uint64_t timestamp, const uint8_t* data, size_t dataLen);

        icmp_echo_reply* getEchoReplyData();

        icmp_echo_reply* setEchoReplyData(uint16_t id, uint16_t sequence, uint64_t timestamp, const uint8_t* data, size_t dataLen);

        icmp_timestamp_request* getTimestampRequestData();

        icmp_timestamp_request* setTimestampRequestData(uint16_t id, uint16_t sequence, timeval originateTimestamp);

        icmp_timestamp_reply* getTimestampReplyData();

        icmp_timestamp_reply* setTimestampReplyData(uint16_t id, uint16_t sequence,
                timeval originateTimestamp, timeval receiveTimestamp, timeval transmitTimestamp);

        icmp_destination_unreachable* getDestUnreachableData();

        icmp_destination_unreachable* setDestUnreachableData(IcmpDestUnreachableCodes code, uint16_t nextHopMTU, IPv4Layer* ipHeader, Layer* l4Header);

        icmp_source_quench* getSourceQuenchdata();

        icmp_source_quench* setSourceQuenchdata(IPv4Layer* ipHeader, Layer* l4Header);

        icmp_redirect* getRedirectData();

        icmp_redirect* setRedirectData(uint8_t code, IPv4Address gatewayAddress, IPv4Layer* ipHeader, Layer* l4Header);

        icmp_router_advertisement* getRouterAdvertisementData() const;

        icmp_router_advertisement* setRouterAdvertisementData(uint8_t code, uint16_t lifetimeInSeconds, const std::vector<icmp_router_address_structure>& routerAddresses);

        icmp_router_solicitation* getRouterSolicitationData();

        icmp_router_solicitation* setRouterSolicitationData();

        icmp_time_exceeded* getTimeExceededData();

        icmp_time_exceeded* setTimeExceededData(uint8_t code, IPv4Layer* ipHeader, Layer* l4Header);

        icmp_param_problem* getParamProblemData();

        icmp_param_problem* setParamProblemData(uint8_t code, uint8_t errorOctetPointer, IPv4Layer* ipHeader, Layer* l4Header);

        icmp_address_mask_request* getAddressMaskRequestData();

        icmp_address_mask_request* setAddressMaskRequestData(uint16_t id, uint16_t sequence, IPv4Address mask);

        icmp_address_mask_reply* getAddressMaskReplyData();

        icmp_address_mask_reply* setAddressMaskReplyData(uint16_t id, uint16_t sequence, IPv4Address mask);

        icmp_info_request* getInfoRequestData();

        icmp_info_request* setInfoRequestData(uint16_t id, uint16_t sequence);

        icmp_info_reply* getInfoReplyData();

        icmp_info_reply* setInfoReplyData(uint16_t id, uint16_t sequence);

        static inline bool isDataValid(const uint8_t* data, size_t dataLen);

        // implement abstract methods

        void parseNextLayer();

        size_t getHeaderLen() const;

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelNetworkLayer; }
    };

    // implementation of inline methods

    bool IcmpLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        if (dataLen < sizeof(icmphdr))
            return false;

        uint8_t type = data[0];

        // ICMP_ECHO_REQUEST, ICMP_ECHO_REPLY, ICMP_ROUTER_SOL, ICMP_INFO_REQUEST, ICMP_INFO_REPLY
        if (type == 8 || type == 0 || type == 10 || type == 15 || type == 16)
            return true;

        // ICMP_TIMESTAMP_REQUEST, ICMP_TIMESTAMP_REPLY
        if (type == 13 || type == 14)
            return dataLen >= sizeof(icmp_timestamp_request);

        // ICMP_ADDRESS_MASK_REPLY, ICMP_ADDRESS_MASK_REQUEST
        if (type == 17 || type == 18)
            return dataLen >= sizeof(icmp_address_mask_request);

        // ICMP_DEST_UNREACHABLE
        if (type == 3)
            return dataLen >= sizeof(icmp_destination_unreachable);

        // ICMP_REDIRECT
        if (type == 5)
            return dataLen >= sizeof(icmp_redirect);

        // ICMP_TIME_EXCEEDED, ICMP_SOURCE_QUENCH
        if (type == 4 || type == 11)
            return dataLen >= sizeof(icmp_time_exceeded);

        // ICMP_PARAM_PROBLEM
        if (type == 12)
            return dataLen >= sizeof(icmp_param_problem);

        // ICMP_ROUTER_ADV
        if (type == 9)
            return dataLen >= sizeof(icmp_router_advertisement_hdr);

        return false;
    }

} // namespace pcpp

#endif /* PACKETPP_ICMP_LAYER */