IPv6Layer.h

Go to the documentation of this file.

#ifndef PACKETPP_IPV6_LAYER
#define PACKETPP_IPV6_LAYER

#include "Layer.h"
#include "IPLayer.h"
#include "IPv6Extensions.h"
#include "IpAddress.h"

#ifndef PCPP_DEPRECATED
#if defined(__GNUC__) || defined(__clang__)
#define PCPP_DEPRECATED __attribute__((deprecated))
#elif defined(_MSC_VER)
#define PCPP_DEPRECATED __declspec(deprecated)
#else
#pragma message("WARNING: DEPRECATED feature is not implemented for this compiler")
#define PCPP_DEPRECATED
#endif
#endif


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)


    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();

        IPv6Layer& operator=(const IPv6Layer& other);

        ip6_hdr* getIPv6Header() const { return (ip6_hdr*)m_Data; }

        IPAddress getSrcIPAddress() const { return getSrcIPv6Address(); }

        PCPP_DEPRECATED IPv6Address getSrcIpAddress() const { 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 { return getDstIPv6Address(); }

        PCPP_DEPRECATED IPv6Address getDstIpAddress() const { 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();

        size_t getHeaderLen() const { return sizeof(ip6_hdr) + m_ExtensionsLen; }

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelNetworkLayer; }

    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 != NULL && dynamic_cast<TIPv6Extension*>(curExt) == NULL)
            curExt = curExt->getNextHeader();

        return (TIPv6Extension*)curExt;
    }

    template<class TIPv6Extension>
    TIPv6Extension* IPv6Layer::addExtension(const TIPv6Extension& extensionHeader)
    {
        int offsetToAddHeader = (int)getHeaderLen();
        if (!extendLayer(offsetToAddHeader, extensionHeader.getExtensionLen()))
        {
            return NULL;
        }

        TIPv6Extension* newHeader = new TIPv6Extension(this, (size_t)offsetToAddHeader);
        (*newHeader) = extensionHeader;

        if (m_FirstExtension != NULL)
        {
            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)
    {
        return dataLen >= sizeof(ip6_hdr);
    }

} // namespace pcpp

#endif /* PACKETPP_IPV6_LAYER */