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
    {
        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 : icmphdr
    {
        uint16_t id;
        uint16_t sequence;
        uint64_t timestamp;
    } icmp_echo_hdr;
#pragma pack(pop)
 
 
    typedef struct
    {
        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 : 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 : icmphdr
    {
        uint16_t unused;
        uint16_t nextHopMTU;
    } icmp_destination_unreachable;
#pragma pack(pop)
 
 
#pragma pack(push, 1)
    typedef struct : icmphdr
    {
        uint32_t unused;
    } icmp_time_exceeded;
#pragma pack(pop)
 
 
    typedef icmp_time_exceeded icmp_source_quench;
 
 
#pragma pack(push, 1)
    typedef struct : 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 : 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 : 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 : 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 : 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:
        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);
 
 
        // implement abstract methods
 
        void parseNextLayer();
 
        size_t getHeaderLen() const;
 
        void computeCalculateFields();
 
        std::string toString() const;
 
        OsiModelLayer getOsiModelLayer() const { return OsiModelNetworkLayer; }
    };
 
} // namespace pcpp
 
#endif /* PACKETPP_ICMP_LAYER */