IcmpLayer.h

Go to the documentation of this file.

#pragma once
 
#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)
    static_assert(sizeof(icmphdr) == 4, "icmphdr size is not 4 bytes");
 
    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)
    static_assert(sizeof(icmp_echo_hdr) == 16, "icmp_echo_hdr size is not 16 bytes");
 
    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)
    static_assert(sizeof(icmp_timestamp_request) == 20, "icmp_timestamp_request size is not 20 bytes");
 
    typedef icmp_timestamp_request icmp_timestamp_reply;
    static_assert(sizeof(icmp_timestamp_reply) == 20, "icmp_timestamp_reply size is not 20 bytes");
 
#pragma pack(push, 1)
    typedef struct icmp_destination_unreachable : icmphdr
    {
        uint16_t unused;
        uint16_t nextHopMTU;
    } icmp_destination_unreachable;
#pragma pack(pop)
    static_assert(sizeof(icmp_destination_unreachable) == 8, "icmp_destination_unreachable size is not 8 bytes");
 
#pragma pack(push, 1)
    typedef struct icmp_time_exceeded : icmphdr
    {
        uint32_t unused;
    } icmp_time_exceeded;
#pragma pack(pop)
    static_assert(sizeof(icmp_time_exceeded) == 8, "icmp_time_exceeded size is not 8 bytes");
 
    typedef icmp_time_exceeded icmp_source_quench;
    static_assert(sizeof(icmp_source_quench) == 8, "icmp_source_quench size is not 8 bytes");
 
#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)
    static_assert(sizeof(icmp_param_problem) == 8, "icmp_param_problem size is not 8 bytes");
 
    typedef icmphdr icmp_router_solicitation;
    static_assert(sizeof(icmp_router_solicitation) == 4, "icmp_router_solicitation size is not 4 bytes");
 
#pragma pack(push, 1)
    typedef struct icmp_redirect : icmphdr
    {
        uint32_t gatewayAddress;
    } icmp_redirect;
#pragma pack(pop)
    static_assert(sizeof(icmp_redirect) == 8, "icmp_redirect size is not 8 bytes");
 
#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)
    static_assert(sizeof(icmp_router_address_structure) == 8, "icmp_router_address_structure size is not 8 bytes");
 
#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)
    static_assert(sizeof(icmp_router_advertisement_hdr) == 8, "icmp_router_advertisement_hdr size is not 8 bytes");
 
    struct icmp_router_advertisement
    {
        icmp_router_advertisement_hdr* header = nullptr;
 
        size_t dataLen = 0;
 
        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)
    static_assert(sizeof(icmp_address_mask_request) == 12, "icmp_address_mask_request size is not 12 bytes");
 
    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)
    static_assert(sizeof(icmp_info_request) == 8, "icmp_info_request size is not 8 bytes");
 
    typedef icmp_info_request icmp_info_reply;
    static_assert(sizeof(icmp_info_reply) == 8, "icmp_info_reply size is not 8 bytes");
 
    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, ICMP)
        {}
 
        IcmpLayer();
 
        ~IcmpLayer() override = default;
 
        icmphdr* getIcmpHeader() const
        {
            return reinterpret_cast<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() override;
 
        size_t getHeaderLen() const override;
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Type,
                                                              TypeName,
                                                              Code,
                                                              Checksum,
                                                              Id,
                                                              Sequence,
                                                              Timestamp,
                                                              OriginateTimestamp,
                                                              ReceiveTimestamp,
                                                              TransmitTimestamp,
                                                              NextHopMTU,
                                                              GatewayAddress,
                                                              AddressMask,
                                                              Pointer,
                                                              AddressEntrySize,
                                                              Lifetime,
                                                              RouterAddresses };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Type;
 
            static const FieldDescriptor TypeName;
 
            static const FieldDescriptor Code;
 
            static const FieldDescriptor Checksum;
 
            static const FieldDescriptor Id;
 
            static const FieldDescriptor Sequence;
 
            static const FieldDescriptor Timestamp;
 
            static const FieldDescriptor OriginateTimestamp;
 
            static const FieldDescriptor ReceiveTimestamp;
 
            static const FieldDescriptor TransmitTimestamp;
 
            static const FieldDescriptor NextHopMTU;
 
            static const FieldDescriptor GatewayAddress;
 
            static const FieldDescriptor AddressMask;
 
            static const FieldDescriptor Pointer;
 
            static const FieldDescriptor AddressEntrySize;
 
            static const FieldDescriptor Lifetime;
 
            static const FieldDescriptor RouterAddresses;
 
            static const FieldDescriptor RouterAddressEntry;
 
            static const FieldDescriptor RouterAddress;
 
            static const FieldDescriptor PreferenceLevel;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    // 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
        if (type == 8 || type == 0 || type == 10)
            return true;
 
        // ICMP_INFO_REQUEST, ICMP_INFO_REPLY
        if (type == 15 || type == 16)
            return dataLen >= sizeof(icmp_info_request);
 
        // 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)
        {
            if (dataLen < sizeof(icmp_router_advertisement_hdr))
                return false;
 
            const auto* routerAdv = reinterpret_cast<const icmp_router_advertisement_hdr*>(data);
            return routerAdv->advertisementCount <=
                   (dataLen - sizeof(icmp_router_advertisement_hdr)) / sizeof(icmp_router_address_structure);
        }
 
        return false;
    }
 
}  // namespace pcpp