IPv6Layer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IPLayer.h"
#include "IPv6Extensions.h"
#include "IpAddress.h"
#include <algorithm>
#include <iterator>
 
 
namespace pcpp
{
 
#pragma pack(push, 1)
    struct ip6_hdr
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t trafficClass : 4,
            ipVersion : 4;
#else
        uint8_t ipVersion : 4,
            trafficClass : 4;
#endif
        uint8_t flowLabel[3];
        uint16_t payloadLength;
        uint8_t nextHeader;
        uint8_t hopLimit;
        uint8_t ipSrc[16];
        uint8_t ipDst[16];
    };
#pragma pack(pop)
    static_assert(sizeof(ip6_hdr) == 40, "ip6_hdr size is not 40 bytes");
 
    class IPv6Layer : public Layer, public IPLayer
    {
    public:
        IPv6Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
 
        IPv6Layer();
 
        IPv6Layer(const IPv6Address& srcIP, const IPv6Address& dstIP);
 
        IPv6Layer(const IPv6Layer& other);
 
        ~IPv6Layer() override;
 
        IPv6Layer& operator=(const IPv6Layer& other);
 
        ip6_hdr* getIPv6Header() const
        {
            return reinterpret_cast<ip6_hdr*>(m_Data);
        }
 
        IPAddress getSrcIPAddress() const override
        {
            return getSrcIPv6Address();
        }
 
        IPv6Address getSrcIPv6Address() const
        {
            return getIPv6Header()->ipSrc;
        }
 
        void setSrcIPv6Address(const IPv6Address& ipAddr)
        {
            ipAddr.copyTo(getIPv6Header()->ipSrc);
        }
 
        void setDstIPv6Address(const IPv6Address& ipAddr)
        {
            ipAddr.copyTo(getIPv6Header()->ipDst);
        }
 
        IPAddress getDstIPAddress() const override
        {
            return getDstIPv6Address();
        }
 
        IPv6Address getDstIPv6Address() const
        {
            return getIPv6Header()->ipDst;
        }
 
        size_t getExtensionCount() const;
 
        template <class TIPv6Extension> TIPv6Extension* getExtensionOfType() const;
 
        template <class TIPv6Extension> TIPv6Extension* addExtension(const TIPv6Extension& extensionHeader);
 
        void removeAllExtensions();
 
        bool isFragment() const;
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(ip6_hdr) + m_ExtensionsLen;
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelNetworkLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ SrcIp,      DstIp,      PayloadLength,
                                                              IsFragment, NextHeader, Extensions };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            struct IPv6ExtensionObject : ObjectFieldDescriptor<IPv6ExtensionObject>
            {
                using ObjectFieldDescriptor::ObjectFieldDescriptor;
 
                static std::vector<FieldDescriptor> all()
                {
                    return { Name, Type };
                }
 
                static const FieldDescriptor Name;
 
                static const FieldDescriptor Type;
            };
 
            static const FieldDescriptor SrcIp;
 
            static const FieldDescriptor DstIp;
 
            static const FieldDescriptor PayloadLength;
 
            static const FieldDescriptor IsFragment;
 
            static const FieldDescriptor NextHeader;
 
            static const FieldDescriptor Extensions;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        void initLayer();
        void parseExtensions();
        void deleteExtensions();
 
        IPv6Extension* m_FirstExtension;
        IPv6Extension* m_LastExtension;
        size_t m_ExtensionsLen;
    };
 
    template <class TIPv6Extension> TIPv6Extension* IPv6Layer::getExtensionOfType() const
    {
        IPv6Extension* curExt = m_FirstExtension;
        while (curExt != nullptr && dynamic_cast<TIPv6Extension*>(curExt) == nullptr)
            curExt = curExt->getNextHeader();
 
        return static_cast<TIPv6Extension*>(curExt);
    }
 
    template <class TIPv6Extension> TIPv6Extension* IPv6Layer::addExtension(const TIPv6Extension& extensionHeader)
    {
        int offsetToAddHeader = static_cast<int>(getHeaderLen());
        if (!extendLayer(offsetToAddHeader, extensionHeader.getExtensionLen()))
        {
            return nullptr;
        }
 
        TIPv6Extension* newHeader = new TIPv6Extension(this, static_cast<size_t>(offsetToAddHeader));
        (*newHeader) = extensionHeader;
 
        if (m_FirstExtension != nullptr)
        {
            newHeader->getBaseHeader()->nextHeader = m_LastExtension->getBaseHeader()->nextHeader;
            m_LastExtension->getBaseHeader()->nextHeader = newHeader->getExtensionType();
            m_LastExtension->setNextHeader(newHeader);
            m_LastExtension = newHeader;
        }
        else
        {
            m_FirstExtension = newHeader;
            m_LastExtension = newHeader;
            newHeader->getBaseHeader()->nextHeader = getIPv6Header()->nextHeader;
            getIPv6Header()->nextHeader = newHeader->getExtensionType();
        }
 
        m_ExtensionsLen += newHeader->getExtensionLen();
 
        return newHeader;
    }
 
    // implementation of inline methods
 
    bool IPv6Layer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        auto ip6Header = reinterpret_cast<const ip6_hdr*>(data);
        return canReinterpretAs<ip6_hdr>(data, dataLen) && ip6Header->ipVersion == 6;
    }
 
}  // namespace pcpp