NdpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_NDP_LAYER
#define PACKETPP_NDP_LAYER

#include "IcmpV6Layer.h"
#include "IpAddress.h"
#include "Layer.h"
#include "MacAddress.h"
#include "TLVData.h"

#include <vector>


namespace pcpp
{

enum class NDPNeighborOptionTypes : int
{
    NDP_OPTION_SOURCE_LINK_LAYER = 1,
    NDP_OPTION_TARGET_LINK_LAYER = 2,
    NDP_OPTION_PREFIX_INFORMATION = 3,
    NDP_OPTION_REDIRECTED_HEADER = 4,
    NDP_OPTION_MTU = 5,
    NDP_OPTION_UNKNOWN = 255
};

class NdpOption : public TLVRecord<uint8_t, uint8_t>
{
public:
    explicit NdpOption(uint8_t *optionRawData) : TLVRecord(optionRawData) {}

    ~NdpOption() {}

    NDPNeighborOptionTypes getNdpOptionType() const
    {
        if (m_Data == nullptr)
            return NDPNeighborOptionTypes::NDP_OPTION_UNKNOWN;

        return static_cast<NDPNeighborOptionTypes>(m_Data->recordType);
    }

    // implement abstract methods

    size_t getTotalSize() const
    {
        if (m_Data == nullptr)
            return (size_t)0;

        return (size_t)m_Data->recordLen * 8;
    }

    size_t getDataSize() const
    {
        if (m_Data == nullptr)
            return 0;

        return (size_t)m_Data->recordLen * 8 - (2 * sizeof(uint8_t)); // length value is stored in units of 8 octets
    }
};

class NdpOptionBuilder : public TLVRecordBuilder
{
public:
    NdpOptionBuilder(NDPNeighborOptionTypes optionType, const uint8_t *optionValue, uint8_t optionValueLen)
        : TLVRecordBuilder((uint8_t)optionType, optionValue, optionValueLen) {}

    NdpOption build() const;
};

class NDPLayerBase : public IcmpV6Layer
{
public:
    virtual ~NDPLayerBase() {}

    size_t getNdpOptionCount() const;

    NdpOption getNdpOption(NDPNeighborOptionTypes option) const;

    NdpOption getFirstNdpOption() const;

    NdpOption getNextNdpOption(NdpOption &option) const;

    NdpOption addNdpOption(const NdpOptionBuilder &optionBuilder);

    bool removeAllNdpOptions();

protected:
    NDPLayerBase() = default;

    NDPLayerBase(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
        : IcmpV6Layer(data, dataLen, prevLayer, packet) {}

private:
    TLVRecordReader<NdpOption> m_OptionReader;

    virtual size_t getNdpHeaderLen() const = 0;
    virtual uint8_t *getNdpOptionsBasePtr() const { return m_Data + getNdpHeaderLen(); };
    NdpOption addNdpOptionAt(const NdpOptionBuilder &optionBuilder, int offset);
};

class NDPNeighborSolicitationLayer : public NDPLayerBase
{
public:
#pragma pack(push, 1)
    struct ndpneighborsolicitationhdr : icmpv6hdr
    {
        uint32_t reserved;
        uint8_t targetIP[16];
    };
#pragma pack(pop)

    NDPNeighborSolicitationLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
        : NDPLayerBase(data, dataLen, prevLayer, packet) {}

    NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address &targetIP);

    NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address &targetIP, const MacAddress &srcMac);

    virtual ~NDPNeighborSolicitationLayer() {}

    IPv6Address getTargetIP() const { return IPv6Address(getNdpHeader()->targetIP); };

    bool hasLinkLayerAddress() const;

    MacAddress getLinkLayerAddress() const;

    std::string toString() const;

private:
    void initLayer(uint8_t code, const IPv6Address &targetIP);
    ndpneighborsolicitationhdr *getNdpHeader() const { return (ndpneighborsolicitationhdr *)m_Data; }
    size_t getNdpHeaderLen() const { return sizeof(ndpneighborsolicitationhdr); };
};

class NDPNeighborAdvertisementLayer : public NDPLayerBase
{
public:
#pragma pack(push, 1)
    struct ndpneighboradvertisementhdr : icmpv6hdr
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint32_t
            reserved : 5,
            override : 1,
            solicited : 1,
            router : 1,
            reserved2 : 24;
#else
        uint32_t
            router : 1,
            solicited : 1,
            override : 1,
            reserved : 29;
#endif

        uint8_t targetIP[16];
    };
#pragma pack(pop)

    NDPNeighborAdvertisementLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet)
        : NDPLayerBase(data, dataLen, prevLayer, packet) {}

    NDPNeighborAdvertisementLayer(uint8_t code, const IPv6Address &targetIP, const MacAddress &targetMac,
                                  bool routerFlag, bool unicastFlag, bool overrideFlag);

    NDPNeighborAdvertisementLayer(uint8_t code, const IPv6Address &targetIP, bool routerFlag, bool unicastFlag,
                                  bool overrideFlag);

    virtual ~NDPNeighborAdvertisementLayer() {}

    MacAddress getTargetMac() const;

    IPv6Address getTargetIP() const { return IPv6Address(getNdpHeader()->targetIP); }

    bool hasTargetMacInfo() const;

    bool getRouterFlag() const { return getNdpHeader()->router; }

    bool getUnicastFlag() const { return getNdpHeader()->solicited; }

    bool getOverrideFlag() const { return getNdpHeader()->override; }

    std::string toString() const;

private:
    void initLayer(uint8_t code, const IPv6Address &targetIP, bool routerFlag, bool unicastFlag, bool overrideFlag);
    ndpneighboradvertisementhdr *getNdpHeader() const { return (ndpneighboradvertisementhdr *)m_Data; }
    size_t getNdpHeaderLen() const { return sizeof(ndpneighboradvertisementhdr); };
};

} // namespace pcpp
#endif /* PACKETPP_NDP_LAYER */