NdpLayer.h

Go to the documentation of this file.

#pragma once
 
#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() override = default;
 
        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 override
        {
            if (m_Data == nullptr)
                return 0;
 
            return static_cast<size_t>(m_Data->recordLen) * 8;
        }
 
        size_t getDataSize() const override
        {
            if (m_Data == nullptr)
            {
                return 0;
            }
 
            // length value is stored in units of 8 octets
            return static_cast<size_t>(m_Data->recordLen) * 8 - (2 * sizeof(uint8_t));
        }
    };
 
    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:
        ~NDPLayerBase() override = default;
 
        size_t getNdpOptionCount() const;
 
        NdpOption getNdpOption(NDPNeighborOptionTypes option) const;
 
        NdpOption getFirstNdpOption() const;
 
        NdpOption getNextNdpOption(NdpOption& option) const;
 
        NdpOption addNdpOption(const NdpOptionBuilder& optionBuilder);
 
        bool removeAllNdpOptions();
 
        struct SerializedFields : IcmpV6Layer::SerializedFields
        {
            static constexpr uint16_t MaxID = IcmpV6Layer::SerializedFields::MaxID + 1;
 
            static std::vector<FieldDescriptor> all()
            {
                auto result = IcmpV6Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Options };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Options;
 
            static const FieldDescriptor Option;
        };
 
    protected:
        NDPLayerBase() = default;
 
        NDPLayerBase(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : IcmpV6Layer(data, dataLen, prevLayer, packet)
        {}
 
        void serializeOptions(ObjectScope& serializer) const;
 
    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)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(ndpneighborsolicitationhdr);
        }
 
        NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address& targetIP);
 
        NDPNeighborSolicitationLayer(uint8_t code, const IPv6Address& targetIP, const MacAddress& srcMac);
 
        ~NDPNeighborSolicitationLayer() override = default;
 
        IPv6Address getTargetIP() const
        {
            return IPv6Address(getNdpHeader()->targetIP);
        };
 
        bool hasLinkLayerAddress() const;
 
        MacAddress getLinkLayerAddress() const;
 
        std::string toString() const override;
 
        struct SerializedFields : NDPLayerBase::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = NDPLayerBase::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ TargetIP, LinkLayerAddress };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor TargetIP;
 
            static const FieldDescriptor LinkLayerAddress;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        void initLayer(uint8_t code, const IPv6Address& targetIP);
        ndpneighborsolicitationhdr* getNdpHeader() const
        {
            return reinterpret_cast<ndpneighborsolicitationhdr*>(m_Data);
        }
        size_t getNdpHeaderLen() const override
        {
            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)
        {}
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data != nullptr && dataLen >= sizeof(ndpneighboradvertisementhdr);
        }
 
        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);
 
        ~NDPNeighborAdvertisementLayer() override = default;
 
        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 override;
 
        struct SerializedFields : NDPLayerBase::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = NDPLayerBase::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ TargetIP, RouterFlag, UnicastFlag, OverrideFlag,
                                                              TargetMac };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor TargetIP;
 
            static const FieldDescriptor RouterFlag;
 
            static const FieldDescriptor UnicastFlag;
 
            static const FieldDescriptor OverrideFlag;
 
            static const FieldDescriptor TargetMac;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        void initLayer(uint8_t code, const IPv6Address& targetIP, bool routerFlag, bool unicastFlag, bool overrideFlag);
        ndpneighboradvertisementhdr* getNdpHeader() const
        {
            return reinterpret_cast<ndpneighboradvertisementhdr*>(m_Data);
        }
        size_t getNdpHeaderLen() const override
        {
            return sizeof(ndpneighboradvertisementhdr);
        };
    };
 
}  // namespace pcpp