IPv6Extensions.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
#include "IpAddress.h"
#include "Layer.h"
#include "TLVData.h"
 
 
namespace pcpp
{
 
    class IPv6Extension
    {
        friend class IPv6Layer;
 
    public:
        enum IPv6ExtensionType
        {
            IPv6HopByHop = 0,
            IPv6Routing = 43,
            IPv6Fragmentation = 44,
            IPv6AuthenticationHdr = 51,
            IPv6Destination = 60,
            IPv6ExtensionUnknown = 255
        };
 
        virtual size_t getExtensionLen() const
        {
            return 8 * (getBaseHeader()->headerLen + 1);
        }
 
        IPv6ExtensionType getExtensionType() const
        {
            return m_ExtType;
        }
 
        virtual ~IPv6Extension();
 
        IPv6Extension* getNextHeader() const
        {
            return m_NextHeader;
        }
 
    protected:
        struct ipv6_ext_base_header
        {
            uint8_t nextHeader;
            uint8_t headerLen;
        };
 
        // protected c'tor
        IPv6Extension(IDataContainer* dataContainer, size_t offset)
            : m_NextHeader(nullptr), m_ExtType(IPv6ExtensionUnknown), m_DataContainer(dataContainer), m_Offset(offset),
              m_ShadowData(nullptr)
        {}
 
        // protected empty c'tor
        IPv6Extension()
            : m_NextHeader(nullptr), m_ExtType(IPv6ExtensionUnknown), m_DataContainer(nullptr), m_Offset(0),
              m_ShadowData(nullptr)
        {}
 
        // protected assignment operator
        IPv6Extension& operator=(const IPv6Extension& other);
 
        uint8_t* getDataPtr() const;
 
        void initShadowPtr(size_t size);
 
        ipv6_ext_base_header* getBaseHeader() const
        {
            return (ipv6_ext_base_header*)getDataPtr();
        }
 
        void setNextHeader(IPv6Extension* nextHeader)
        {
            m_NextHeader = nextHeader;
        }
 
        IPv6Extension* m_NextHeader;
        IPv6ExtensionType m_ExtType;
 
    private:
        IDataContainer* m_DataContainer;
        size_t m_Offset;
        uint8_t* m_ShadowData;
    };
 
    class IPv6FragmentationHeader : public IPv6Extension
    {
        friend class IPv6Layer;
 
    public:
        struct ipv6_frag_header
        {
            uint8_t nextHeader;
            uint8_t headerLen;
            uint16_t fragOffsetAndFlags;
            uint32_t id;
        };
 
        IPv6FragmentationHeader(uint32_t fragId, uint16_t fragOffset, bool lastFragment);
 
        ipv6_frag_header* getFragHeader() const
        {
            return (ipv6_frag_header*)getDataPtr();
        }
 
        bool isFirstFragment() const;
 
        bool isLastFragment() const;
 
        bool isMoreFragments() const;
 
        uint16_t getFragmentOffset() const;
 
    private:
        IPv6FragmentationHeader(IDataContainer* dataContainer, size_t offset) : IPv6Extension(dataContainer, offset)
        {
            m_ExtType = IPv6Fragmentation;
        }
    };
 
    class IPv6TLVOptionHeader : public IPv6Extension
    {
        friend class IPv6Layer;
 
    public:
        class IPv6Option : public TLVRecord<uint8_t, uint8_t>
        {
        public:
            static const uint8_t Pad0OptionType = 0;
            static const uint8_t PadNOptionType = 1;
 
            explicit IPv6Option(uint8_t* optionRawData) : TLVRecord(optionRawData)
            {}
 
            ~IPv6Option()
            {}
 
            static bool canAssign(const uint8_t* recordRawData, size_t tlvDataLen)
            {
                auto data = (TLVRawData*)recordRawData;
                if (data == nullptr)
                    return false;
 
                if (tlvDataLen < sizeof(TLVRawData::recordType))
                    return false;
 
                if (data->recordType == Pad0OptionType)
                    return true;
 
                return TLVRecord<uint8_t, uint8_t>::canAssign(recordRawData, tlvDataLen);
            }
 
            // implement abstract methods
 
            size_t getTotalSize() const
            {
                if (m_Data == nullptr)
                    return 0;
 
                if (m_Data->recordType == Pad0OptionType)
                    return sizeof(uint8_t);
 
                return (size_t)(m_Data->recordLen + sizeof(uint16_t));
            }
 
            size_t getDataSize() const
            {
                if (m_Data == nullptr || m_Data->recordType == Pad0OptionType)
                    return 0;
 
                return (size_t)m_Data->recordLen;
            }
        };
 
        class IPv6TLVOptionBuilder : public TLVRecordBuilder
        {
        public:
            IPv6TLVOptionBuilder(uint8_t optType, const uint8_t* optValue, uint8_t optValueLen)
                : TLVRecordBuilder(optType, optValue, optValueLen)
            {}
 
            IPv6TLVOptionBuilder(uint8_t optType, uint8_t optValue) : TLVRecordBuilder(optType, optValue)
            {}
 
            IPv6TLVOptionBuilder(uint8_t optType, uint16_t optValue) : TLVRecordBuilder(optType, optValue)
            {}
 
            IPv6TLVOptionBuilder(const IPv6TLVOptionBuilder& other) : TLVRecordBuilder(other)
            {}
 
            IPv6TLVOptionBuilder& operator=(const IPv6TLVOptionBuilder& other)
            {
                TLVRecordBuilder::operator=(other);
                return *this;
            }
 
            IPv6Option build() const;
        };
 
        IPv6Option getOption(uint8_t optionType) const;
 
        IPv6Option getFirstOption() const;
 
        IPv6Option getNextOption(IPv6Option& option) const;
 
        size_t getOptionCount() const;
 
    protected:
        explicit IPv6TLVOptionHeader(const std::vector<IPv6TLVOptionBuilder>& options);
 
        IPv6TLVOptionHeader(IDataContainer* dataContainer, size_t offset);
 
    private:
        TLVRecordReader<IPv6Option> m_OptionReader;
    };
 
    class IPv6HopByHopHeader : public IPv6TLVOptionHeader
    {
        friend class IPv6Layer;
 
    public:
        explicit IPv6HopByHopHeader(const std::vector<IPv6TLVOptionBuilder>& options) : IPv6TLVOptionHeader(options)
        {
            m_ExtType = IPv6HopByHop;
        }
 
    private:
        IPv6HopByHopHeader(IDataContainer* dataContainer, size_t offset) : IPv6TLVOptionHeader(dataContainer, offset)
        {
            m_ExtType = IPv6HopByHop;
        }
    };
 
    class IPv6DestinationHeader : public IPv6TLVOptionHeader
    {
        friend class IPv6Layer;
 
    public:
        explicit IPv6DestinationHeader(const std::vector<IPv6TLVOptionBuilder>& options) : IPv6TLVOptionHeader(options)
        {
            m_ExtType = IPv6Destination;
        }
 
    private:
        IPv6DestinationHeader(IDataContainer* dataContainer, size_t offset) : IPv6TLVOptionHeader(dataContainer, offset)
        {
            m_ExtType = IPv6Destination;
        }
    };
 
    class IPv6RoutingHeader : public IPv6Extension
    {
        friend class IPv6Layer;
 
    public:
        struct ipv6_routing_header
        {
            uint8_t nextHeader;
            uint8_t headerLen;
            uint8_t routingType;
            uint8_t segmentsLeft;
        };
 
        IPv6RoutingHeader(uint8_t routingType, uint8_t segmentsLeft, const uint8_t* additionalRoutingData,
                          size_t additionalRoutingDataLen);
 
        ipv6_routing_header* getRoutingHeader() const
        {
            return (ipv6_routing_header*)getDataPtr();
        }
 
        uint8_t* getRoutingAdditionalData() const;
 
        size_t getRoutingAdditionalDataLength() const;
 
        IPv6Address getRoutingAdditionalDataAsIPv6Address(size_t offset = 0) const;
 
    private:
        IPv6RoutingHeader(IDataContainer* dataContainer, size_t offset) : IPv6Extension(dataContainer, offset)
        {
            m_ExtType = IPv6Routing;
        }
    };
 
    class IPv6AuthenticationHeader : public IPv6Extension
    {
        friend class IPv6Layer;
 
    public:
        struct ipv6_authentication_header
        {
            uint8_t nextHeader;
            uint8_t headerLen;
            uint16_t reserved;
            uint32_t securityParametersIndex;
            uint32_t sequenceNumber;
        };
 
        IPv6AuthenticationHeader(uint32_t securityParametersIndex, uint32_t sequenceNumber,
                                 const uint8_t* integrityCheckValue, size_t integrityCheckValueLen);
 
        ipv6_authentication_header* getAuthHeader() const
        {
            return (ipv6_authentication_header*)getDataPtr();
        }
 
        uint8_t* getIntegrityCheckValue() const;
 
        size_t getIntegrityCheckValueLength() const;
 
        // overridden methods
 
        size_t getExtensionLen() const override
        {
            return 4 * (getBaseHeader()->headerLen + 2);
        }
 
    private:
        IPv6AuthenticationHeader(IDataContainer* dataContainer, size_t offset) : IPv6Extension(dataContainer, offset)
        {
            m_ExtType = IPv6AuthenticationHdr;
        }
    };
 
}  // namespace pcpp