/src/PcapPlusPlus/Packet++/header/IcmpLayer.h

Source (jump to first uncovered line)
#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>


/// @file

/**
 * \namespace pcpp
 * \brief The main namespace for the PcapPlusPlus lib
 */
namespace pcpp
{

  /**
   * @struct icmphdr
   * Represents ICMP basic protocol header (common for all ICMP message types)
   */
#pragma pack(push, 1)
  typedef struct icmphdr
  {
    /** message type */
    uint8_t  type;
    /** message code */
    uint8_t  code;
    /** message checksum */
    uint16_t checksum;
  } icmphdr;
#pragma pack(pop)

  /**
   * An enum of all supported ICMP message types
   */
  enum IcmpMessageType
  {
    /** ICMP echo (ping) reply message */
    ICMP_ECHO_REPLY           = 0,
    /** ICMP destination unreachable message */
    ICMP_DEST_UNREACHABLE     = 3,
    /** ICMP source quench message */
    ICMP_SOURCE_QUENCH        = 4,
    /** ICMP redirect message */
    ICMP_REDIRECT             = 5,
    /** ICMP echo (ping) request message */
    ICMP_ECHO_REQUEST         = 8,
    /** ICMP router advertisement message */
    ICMP_ROUTER_ADV           = 9,
    /** ICMP router soliciatation message */
    ICMP_ROUTER_SOL           = 10,
    /** ICMP time-to-live excceded message */
    ICMP_TIME_EXCEEDED        = 11,
    /** ICMP parameter problem message */
    ICMP_PARAM_PROBLEM        = 12,
    /** ICMP timestamp request message */
    ICMP_TIMESTAMP_REQUEST    = 13,
    /** ICMP timestamp reply message */
    ICMP_TIMESTAMP_REPLY      = 14,
    /** ICMP information request message */
    ICMP_INFO_REQUEST         = 15,
    /** ICMP information reply message */
    ICMP_INFO_REPLY           = 16,
    /** ICMP address mask request message */
    ICMP_ADDRESS_MASK_REQUEST = 17,
    /** ICMP address mask reply message */
    ICMP_ADDRESS_MASK_REPLY   = 18,
    /** ICMP message type unsupported by PcapPlusPlus */
    ICMP_UNSUPPORTED          = 255
  };

  /**
   * An enum for all possible codes for a destination unreachable message type
   * Documentation is taken from Wikipedia: https://en.wikipedia.org/wiki/Internet_Control_Message_Protocol
   */
  enum IcmpDestUnreachableCodes
  {
    /** Network unreachable error */
    IcmpNetworkUnreachable = 0,
    /** Host unreachable error */
    IcmpHostUnreachable = 1,
    /** Protocol unreachable error (the designated transport protocol is not supported) */
    IcmpProtocolUnreachable = 2,
    /** Port unreachable error (the designated protocol is unable to inform the host of the incoming message) */
    IcmpPortUnreachable = 3,
    /** The datagram is too big. Packet fragmentation is required but the 'don't fragment' (DF) flag is on */
    IcmpDatagramTooBig = 4,
    /** Source route failed error */
    IcmpSourceRouteFailed = 5,
    /** Destination network unknown error */
    IcmpDestinationNetworkUnknown = 6,
    /** Destination host unknown error */
    IcmpDestinationHostUnknown = 7,
    /** Source host isolated error */
    IcmpSourceHostIsolated = 8,
    /** The destination network is administratively prohibited */
    IcmpDestinationNetworkProhibited = 9,
    /** The destination host is administratively prohibited */
    IcmpDestinationHostProhibited = 10,
    /** The network is unreachable for Type Of Service */
    IcmpNetworkUnreachableForTypeOfService = 11,
    /** The host is unreachable for Type Of Service */
    IcmpHostUnreachableForTypeOfService = 12,
    /** Communication administratively prohibited (administrative filtering prevents
     * packet from being forwarded)
     */
    IcmpCommunicationProhibited = 13,
    /** Host precedence violation (indicates the requested precedence is not permitted for
     * the combination of host or network and port)
     */
    IcmpHostPrecedenceViolation = 14,
    /** Precedence cutoff in effect (precedence of datagram is below the level set by
     * the network administrators)
     */
    IcmpPrecedenceCutoff = 15
  };


  /**
   * @struct icmp_echo_hdr
   * ICMP echo (ping) request/reply message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_echo_hdr : icmphdr
  {
    /** the echo (ping) request identifier */
    uint16_t id;
    /** the echo (ping) request sequence number */
    uint16_t sequence;
    /** a timestamp of when the message was sent */
    uint64_t timestamp;
  } icmp_echo_hdr;
#pragma pack(pop)


  /**
   * @struct icmp_echo_request
   * ICMP echo (ping) request/reply message structure
   */
  typedef struct icmp_echo_request
  {
    /** a pointer to the header data */
    icmp_echo_hdr* header;
    /** most echo requests/replies contain some payload data. This is the data length */
    size_t dataLength;
    /** most echo requests/replies contain some payload data. This is a pointer to this data */
    uint8_t* data;
  } icmp_echo_request;


  /**
   * @typedef icmp_echo_reply
   * ICMP echo (ping) reply message structure, same as icmp_echo_request
   */
  typedef icmp_echo_request icmp_echo_reply;


  /**
   * @struct icmp_timestamp_request
   * ICMP timestamp request message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_timestamp_request : icmphdr
  {
    /** the timestamp request identifier */
    uint16_t id;
    /** the timestamp request sequence number */
    uint16_t sequence;
    /** the time (in milliseconds since midnight) the sender last touched the packet */
    uint32_t originateTimestamp;
    /** relevant for timestamp reply only - the time the echoer first touched it on receipt */
    uint32_t receiveTimestamp;
    /** relevant for timestamp reply only - the time the echoer last touched the message on sending it */
    uint32_t transmitTimestamp;
  } icmp_timestamp_request;
#pragma pack(pop)


  /**
   * @typedef icmp_timestamp_reply
   * ICMP timestamp reply message structure, same as icmp_timestamp_request
   */
  typedef icmp_timestamp_request icmp_timestamp_reply;


  /**
   * @struct icmp_destination_unreachable
   * ICMP destination unreachable message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_destination_unreachable : icmphdr
  {
    /** unused 2 bytes */
    uint16_t unused;
    /** contains the MTU of the next-hop network if a code 4 error occurs */
    uint16_t nextHopMTU;
  } icmp_destination_unreachable;
#pragma pack(pop)


  /**
   * @struct icmp_time_exceeded
   * ICMP time-to-live exceeded message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_time_exceeded : icmphdr
  {
    /** unused 4 bytes */
    uint32_t unused;
  } icmp_time_exceeded;
#pragma pack(pop)


  /**
   * @typedef icmp_source_quench
   * ICMP source quence message structure, same as icmp_time_exceeded
   */
  typedef icmp_time_exceeded icmp_source_quench;


  /**
   * @struct icmp_param_problem
   * ICMP parameter problem message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_param_problem : icmphdr
  {
    /** in the case of an invalid IP header (Code 0), this field indicates the byte offset of the error in the header */
    uint8_t  pointer;
    /** unused 1 byte */
    uint8_t  unused1;
    /** unused 2 bytes */
    uint16_t unused2;
  } icmp_param_problem;
#pragma pack(pop)


  /**
   * @typedef icmp_router_solicitation
   * ICMP router solicitation message structure, same as icmphdr
   */
  typedef icmphdr icmp_router_solicitation;

  /**
   * @struct icmp_redirect
   * ICMP redirect message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_redirect : icmphdr
  {
    /** an IPv4 address of the gateway to which the redirection should be sent */
    uint32_t gatewayAddress;
  } icmp_redirect;
#pragma pack(pop)


  /**
   * @struct icmp_router_address_structure
   * Router address structure, relevant for ICMP router advertisement message type (icmp_router_advertisement)
   */
#pragma pack(push, 1)
  struct icmp_router_address_structure
  {
    /** the IPv4 address of the advertised router */
    uint32_t routerAddress;
    /** The preferability of the router address as a default router address, relative to other router addresses
     * on the same subnet. This is a twos-complement value where higher values indicate that the route is
     * more preferable */
    uint32_t preferenceLevel;

    /**
     * Set router address structure from a given IPv4 address and preference level
     * @param[in] addr IPv4 address to set
     * @param[in] preference Preference level to set
     */
    void setRouterAddress(IPv4Address addr, uint32_t preference);

    /**
     * @return The IPv4 address extracted from icmp_router_address_structure#routerAddress field
     */
    IPv4Address getAddress() const { return routerAddress; }
  };
#pragma pack(pop)


  /**
   * @struct icmp_router_advertisement_hdr
   * ICMP router advertisement message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_router_advertisement_hdr : icmphdr
  {
    /** the number of router advertisements in this message. Each advertisement contains one router address/preference level pair */
    uint8_t  advertisementCount;
    /** the number of 32-bit words of information for each router address entry in the list. The value is normally set to 2
     * (router address + preference level) */
    uint8_t  addressEntrySize;
    /** the maximum number of seconds that the router addresses in this list may be considered valid */
    uint16_t lifetime;
  } icmp_router_advertisement_hdr;
#pragma pack(pop)


  /**
   * @struct icmp_router_advertisement
   * ICMP router advertisement message structure
   */
  struct icmp_router_advertisement
  {
    /** a pointer to the header data on the packet */
    icmp_router_advertisement_hdr* header;

    /**
     * Extract router advertisement at a given index
     * @param[in] index The index of the router advertisement
     * @return A pointer to the router advertisement on the packet or null if index is out of range (less than zero or
     * greater than the number of router advertisement records on this message, determined by advertisementCount field)
     */
    icmp_router_address_structure* getRouterAddress(int index) const;
  };


  /**
   * @struct icmp_address_mask_request
   * ICMP address mask request message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_address_mask_request : icmphdr
  {
    /** the address mask request identifier */
    uint16_t id;
    /** the address mask request sequence */
    uint16_t sequence;
    /** the subnet mask of the requesting host */
    uint32_t addressMask;
  } icmp_address_mask_request;
#pragma pack(pop)


  /**
   * @typedef icmp_address_mask_reply
   * ICMP address mask reply message structure, same as icmp_address_mask_request
   */
  typedef icmp_address_mask_request icmp_address_mask_reply;


  /**
   * @struct icmp_info_request
   * ICMP information request message structure
   */
#pragma pack(push, 1)
  typedef struct icmp_info_request : icmphdr
  {
    /** the information request identifier */
    uint16_t id;
    /** the information request sequence */
    uint16_t sequence;
  } icmp_info_request;
#pragma pack(pop)


  /**
   * @typedef icmp_info_reply
   * ICMP information reply message structure, same as icmp_info_request
   */
  typedef icmp_info_request icmp_info_reply;


  /**
   * @class IcmpLayer
   * Represents an ICMP protocol layer (for IPv4 only)
   */
  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:
    /**
     * A constructor that creates the layer from an existing packet raw data
     * @param[in] data A pointer to the raw data (will be casted to @ref arphdr)
     * @param[in] dataLen Size of the data in bytes
     * @param[in] prevLayer A pointer to the previous layer
     * @param[in] packet A pointer to the Packet instance where layer will be stored in
     */
    // cppcheck-suppress uninitMemberVar
    IcmpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) : Layer(data, dataLen, prevLayer, packet) { m_Protocol = ICMP; }

    /**
     * An empty constructor that creates a new layer with an empty ICMP header without setting the ICMP type or ICMP data.
     * Call the set*Data() methods to set ICMP type and data
     */
    IcmpLayer();

    virtual ~IcmpLayer() {}

    /**
     * Get a pointer to the basic ICMP header. Notice this points directly to the data, so every change will change the actual packet data
     * @return A pointer to the @ref icmphdr
     */
    icmphdr* getIcmpHeader() const { return (icmphdr*)m_Data; }

    /**
     * @return The ICMP message type
     */
    IcmpMessageType getMessageType() const;

    /**
     * @param[in] type Type to check
     * @return True if the layer if of the given type, false otherwise
     */
    bool isMessageOfType(IcmpMessageType type) const { return getMessageType() == type; }

    /**
     * @return ICMP echo (ping) request data. If the layer isn't of type ICMP echo request NULL is returned
     */
    icmp_echo_request* getEchoRequestData();

    /**
     * Set echo (ping) request message data
     * @param[in] id Echo (ping) request identifier
     * @param[in] sequence Echo (ping) request sequence
     * @param[in] timestamp Echo (ping) request timestamp
     * @param[in] data A pointer to echo (ping) request payload to set
     * @param[in] dataLen The length of the echo (ping) request payload
     * @return A pointer to the echo (ping) request data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_echo_request* setEchoRequestData(uint16_t id, uint16_t sequence, uint64_t timestamp, const uint8_t* data, size_t dataLen);

    /**
     * @return ICMP echo reply data. If the layer isn't of type ICMP echo reply NULL is returned
     */
    icmp_echo_reply* getEchoReplyData();

    /**
     * Set echo (ping) reply message data
     * @param[in] id Echo (ping) reply identifier
     * @param[in] sequence Echo (ping) reply sequence
     * @param[in] timestamp Echo (ping) reply timestamp
     * @param[in] data A pointer to echo (ping) reply payload to set
     * @param[in] dataLen The length of the echo (ping) reply payload
     * @return A pointer to the echo (ping) reply data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_echo_reply* setEchoReplyData(uint16_t id, uint16_t sequence, uint64_t timestamp, const uint8_t* data, size_t dataLen);

    /**
     * @return ICMP timestamp request data. If the layer isn't of type ICMP timestamp request NULL is returned
     */
    icmp_timestamp_request* getTimestampRequestData();

    /**
     * Set timestamp request message data
     * @param[in] id Timestamp request identifier
     * @param[in] sequence Timestamp request sequence
     * @param[in] originateTimestamp Time (in milliseconds since midnight) the sender last touched the packet
     * @return A pointer to the timestamp request data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_timestamp_request* setTimestampRequestData(uint16_t id, uint16_t sequence, timeval originateTimestamp);

    /**
     * @return ICMP timestamp reply data. If the layer isn't of type ICMP timestamp reply NULL is returned
     */
    icmp_timestamp_reply* getTimestampReplyData();

    /**
     * Set timestamp reply message data
     * @param[in] id Timestamp reply identifier
     * @param[in] sequence Timestamp reply sequence
     * @param[in] originateTimestamp Time (in milliseconds since midnight) the sender last touched the packet
     * @param[in] receiveTimestamp The time the echoer first touched it on receipt
     * @param[in] transmitTimestamp The time the echoer last touched the message on sending it
     * @return A pointer to the timestamp reply data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_timestamp_reply* setTimestampReplyData(uint16_t id, uint16_t sequence,
        timeval originateTimestamp, timeval receiveTimestamp, timeval transmitTimestamp);

    /**
     * @return ICMP destination unreachable data. If the layer isn't of type ICMP destination unreachable NULL is returned.
     * The IP and L4 (ICMP/TCP/UDP) headers of the destination unreachable data are parsed as separate layers and can be
     * retrieved via this->getNextLayer()
     */
    icmp_destination_unreachable* getDestUnreachableData();

    /**
     * Set destination unreachable message data. This method only works if IcmpLayer is already part of a packet (not
     * a standalone layer). The reason is the Internet and L4 headers given as parameters are added as separate layers
     * and need a packet to be added to
     * @param[in] code Destination unreachable code
     * @param[in] nextHopMTU The MTU of the next-hop network if a code 4 error occurs
     * @param[in] ipHeader The Internet header of the original data. This layer is added as a separate layer on the packet
     * @param[in] l4Header The L4 header of the original data. This layer is added as a separate layer on the packet
     * @return A pointer to the destination unreachable data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_destination_unreachable* setDestUnreachableData(IcmpDestUnreachableCodes code, uint16_t nextHopMTU, IPv4Layer* ipHeader, Layer* l4Header);

    /**
     * @return ICMP source quench data. If the layer isn't of type ICMP source quench NULL is returned.
     * The IP and L4 (ICMP/TCP/UDP) headers of the source quench data are parsed as separate layers and can be
     * retrieved via this->getNextLayer()
     */
    icmp_source_quench* getSourceQuenchdata();

    /**
     * Set source quench message data. This method only works if IcmpLayer is already part of a packet (not
     * a standalone layer). The reason is the Internet and L4 headers given as parameters are added as separate layers
     * and need a packet to be added to
     * @param[in] ipHeader The Internet header of the original data. This layer is added as a separate layer on the packet
     * @param[in] l4Header The L4 header of the original data. This layer is added as a separate layer on the packet
     * @return A pointer to the source quench data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_source_quench* setSourceQuenchdata(IPv4Layer* ipHeader, Layer* l4Header);

    /**
     * @return ICMP redirect data. If the layer isn't of type ICMP redirect NULL is returned.
     * The IP and L4 (ICMP/TCP/UDP) headers of the redirect data are parsed as separate layers and can be
     * retrieved via this->getNextLayer()
     */
    icmp_redirect* getRedirectData();

    /**
     * Set redirect message data. This method only works if IcmpLayer is already part of a packet (not
     * a standalone layer). The reason is the Internet and L4 headers given as parameters are added as separate layers
     * and need a packet to be added to
     * @param[in] code The redirect message code. Only values between 0 and 3 are legal, the rest will cause the method to fail
     * @param[in] gatewayAddress An IPv4 address of the gateway to which the redirection should be sent
     * @param[in] ipHeader The Internet header of the original data. This layer is added as a separate layer on the packet
     * @param[in] l4Header The L4 header of the original data. This layer is added as a separate layer on the packet
     * @return A pointer to the redirect data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_redirect* setRedirectData(uint8_t code, IPv4Address gatewayAddress, IPv4Layer* ipHeader, Layer* l4Header);

    /**
     * @return ICMP router advertisement data. If the layer isn't of type ICMP router advertisement NULL is returned
     */
    icmp_router_advertisement* getRouterAdvertisementData() const;

    /**
     * Set router advertisement message data
     * @param[in] code The router advertisement message code. Only codes 0 or 16 are legal, the rest will fail the method
     * @param[in] lifetimeInSeconds The maximum number of seconds that the router addresses in this list may be considered valid
     * @param[in] routerAddresses A vector of router advertisements to set
     * @return A pointer to the router advertisement data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_router_advertisement* setRouterAdvertisementData(uint8_t code, uint16_t lifetimeInSeconds, const std::vector<icmp_router_address_structure>& routerAddresses);

    /**
     * @return ICMP router solicitation data. If the layer isn't of type ICMP router solicitation NULL is returned
     */
    icmp_router_solicitation* getRouterSolicitationData();

    /**
     * Set router solicitation message data. This message accepts no parameters as there are no parameters to this
     * type of message (code is always zero)
     * @return A pointer to the router solicitation data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_router_solicitation* setRouterSolicitationData();

    /**
     * @return ICMP time-to-live exceeded data. If the layer isn't of type ICMP time-to-live exceeded NULL is returned.
     * The IP and L4 (ICMP/TCP/UDP) headers of the time exceeded data are parsed as separate layers and can be
     * retrieved via this->getNextLayer()
     */
    icmp_time_exceeded* getTimeExceededData();

    /**
     * Set time-to-live exceeded message data. This method only works if IcmpLayer is already part of a packet (not
     * a standalone layer). The reason is the Internet and L4 headers given as parameters are added as separate layers
     * and need a packet to be added to
     * @param[in] code Time-to-live exceeded message code. Only codes 0 or 1 are legal, the rest will fail the method
     * @param[in] ipHeader The Internet header of the original data. This layer is added as a separate layer on the packet
     * @param[in] l4Header The L4 header of the original data. This layer is added as a separate layer on the packet
     * @return A pointer to the time-to-live exceeded data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_time_exceeded* setTimeExceededData(uint8_t code, IPv4Layer* ipHeader, Layer* l4Header);

    /**
     * @return ICMP parameter problem data. If the layer isn't of type ICMP parameter problem NULL is returned
     */
    icmp_param_problem* getParamProblemData();

    /**
     * Set parameter problem message data. This method only works if IcmpLayer is already part of a packet (not
     * a standalone layer). The reason is the Internet and L4 headers given as parameters are added as separate layers
     * and need a packet to be added to
     * @param[in] code Parameter problem message code. Only code between 0 and 2 are legal, the rest will fail the method
     * @param[in] errorOctetPointer In the case of an invalid IP header (Code 0), indicate the byte offset of the error in the header
     * @param[in] ipHeader The Internet header of the original data. This layer is added as a separate layer on the packet
     * @param[in] l4Header The L4 header of the original data. This layer is added as a separate layer on the packet
     * @return A pointer to the parameter problem data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_param_problem* setParamProblemData(uint8_t code, uint8_t errorOctetPointer, IPv4Layer* ipHeader, Layer* l4Header);

    /**
     * @return ICMP address mask request data. If the layer isn't of type ICMP address mask request NULL is returned
     */
    icmp_address_mask_request* getAddressMaskRequestData();

    /**
     * Set address mask request message data
     * @param[in] id Address mask request identifier
     * @param[in] sequence Address mask request sequence
     * @param[in] mask The subnet mask of the requesting host
     * @return A pointer to the address mask request data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_address_mask_request* setAddressMaskRequestData(uint16_t id, uint16_t sequence, IPv4Address mask);

    /**
     * @return ICMP address mask reply data. If the layer isn't of type ICMP address mask reply NULL is returned
     */
    icmp_address_mask_reply* getAddressMaskReplyData();

    /**
     * Set address mask reply message data
     * @param[in] id Address mask reply identifier
     * @param[in] sequence Address mask reply sequence
     * @param[in] mask The subnet mask of the requesting host
     * @return A pointer to the address mask reply data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_address_mask_reply* setAddressMaskReplyData(uint16_t id, uint16_t sequence, IPv4Address mask);

    /**
     * @return ICMP address information request data. If the layer isn't of type ICMP information request NULL is returned
     */
    icmp_info_request* getInfoRequestData();

    /**
     * Set information request message data
     * @param[in] id Information request identifier
     * @param[in] sequence Information request sequence
     * @return A pointer to the information request data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_info_request* setInfoRequestData(uint16_t id, uint16_t sequence);

    /**
     * @return ICMP address information reply data. If the layer isn't of type ICMP information reply NULL is returned
     */
    icmp_info_reply* getInfoReplyData();

    /**
     * Set information reply message data
     * @param[in] id Information reply identifier
     * @param[in] sequence Information reply sequence
     * @return A pointer to the information reply data that have been set or NULL if something went wrong
     * (an appropriate error log is printed in such cases)
     */
    icmp_info_reply* setInfoReplyData(uint16_t id, uint16_t sequence);

    /**
     * The static method makes validation of input data
     * @param[in] data The pointer to the beginning of byte stream of ICMP packet
     * @param[in] dataLen The length of byte stream
     * @return True if the data is valid and can represent an ICMP packet
     */
    static inline bool isDataValid(const uint8_t* data, size_t dataLen);

    // implement abstract methods

    /**
     * ICMP messages of types: ICMP_DEST_UNREACHABLE, ICMP_SOURCE_QUENCH, ICMP_TIME_EXCEEDED, ICMP_REDIRECT, ICMP_PARAM_PROBLEM
     * have data that contains IPv4 header and some L4 header (TCP/UDP/ICMP). This method parses these headers as separate
     * layers on top of the ICMP layer
     */
    void parseNextLayer();

    /**
     * @return The ICMP header length. This length varies according to the ICMP message type. This length doesn't include
     * IPv4 and L4 headers in case ICMP message type are: ICMP_DEST_UNREACHABLE, ICMP_SOURCE_QUENCH, ICMP_TIME_EXCEEDED,
     * ICMP_REDIRECT, ICMP_PARAM_PROBLEM
     */
    size_t getHeaderLen() const;

    /**
     * Calculate ICMP checksum field
     */
    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 */

Coverage Report

Created: 2023-01-17 06:15