GeneveLayer.h

Go to the documentation of this file.

#pragma once
 
#include "EthLayer.h"
#include "Layer.h"
 
 
namespace pcpp
{
    class GeneveLayer;
 
    class GeneveOption
    {
        friend class GeneveLayer;
 
    private:
#pragma pack(push, 1)
        struct geneve_option_header
        {
            uint16_t optionClass;
            uint8_t type;
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t length : 5;
            uint8_t reserved : 3;
#else
            uint8_t reserved : 3;
            uint8_t length : 5;
#endif
        };
#pragma pack(pop)
        static_assert(sizeof(geneve_option_header) == 4, "geneve_option_header size is not 4 bytes");
 
        static constexpr size_t HeaderLength = sizeof(geneve_option_header);
        static constexpr size_t DataLengthUnit = 4;
        static constexpr size_t MaxDataLength = ((1 << 5) - 1) * DataLengthUnit;
        static constexpr uint8_t TypeMask = 0x7f;
        static constexpr uint8_t CriticalBitMask = 0x80;
 
        geneve_option_header* m_Data;
 
        explicit GeneveOption(uint8_t* optionData) : m_Data(reinterpret_cast<geneve_option_header*>(optionData))
        {}
 
        static bool canAssign(const uint8_t* optionRawData, size_t optionDataLen);
        void setOptionClass(uint16_t value);
        void setType(uint8_t value, bool critical);
        void setDataSize(size_t value);
 
        static uint8_t extractType(uint8_t value)
        {
            return static_cast<uint8_t>(value & TypeMask);
        }
 
        static size_t alignDataSize(size_t value)
        {
            constexpr size_t AlignmentMask = DataLengthUnit - 1;
            return (value + AlignmentMask) & ~AlignmentMask;
        }
 
        uint8_t* getRecordBasePtr() const
        {
            return reinterpret_cast<uint8_t*>(m_Data);
        }
 
    public:
        GeneveOption() : m_Data(nullptr)
        {}
 
        bool isNull() const
        {
            return m_Data == nullptr;
        }
 
        uint16_t getOptionClass() const;
 
        uint8_t getType() const;
 
        bool isCritical() const;
 
        size_t getDataSize() const;
 
        size_t getTotalSize() const;
 
        uint8_t* getData() const;
 
        bool operator==(const GeneveOption& other) const;
 
        bool operator!=(const GeneveOption& other) const
        {
            return !(*this == other);
        }
    };
    class GeneveLayer : public Layer
    {
    public:
        static constexpr uint16_t DefaultPort = 6081;
 
        GeneveLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, Geneve)
        {}
 
        explicit GeneveLayer(uint32_t vni = 0, uint16_t protocolType = PCPP_ETHERTYPE_ETHBRIDGE, bool oamFlag = false);
 
        ~GeneveLayer() override = default;
 
        static bool isDataValid(const uint8_t* data, size_t dataLen);
 
        static bool isGenevePort(uint16_t port)
        {
            return port == DefaultPort;
        }
 
        uint32_t getVNI() const;
 
        void setVNI(uint32_t vni);
 
        uint16_t getProtocolType() const;
 
        void setProtocolType(uint16_t protocolType);
 
        bool getOamFlag() const;
 
        void setOamFlag(bool value);
 
        bool getCriticalFlag() const;
 
        size_t getOptionsLength() const;
 
        size_t getOptionCount() const;
 
        GeneveOption getFirstOption() const;
 
        GeneveOption getNextOption(const GeneveOption& option) const;
 
        GeneveOption getOption(uint16_t optionClass, uint8_t optionType) const;
 
        bool addOption(uint16_t optionClass, uint8_t optionType, const uint8_t* optionData, size_t optionDataLen,
                       bool critical = false);
 
        bool removeOption(uint16_t optionClass, uint8_t optionType);
 
        bool removeAllOptions();
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override;
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelDataLinkLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ OptionsLength, ProtocolType, VNI,
                                                              OamFlag,       CriticalFlag, Options };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            struct OptionObject : ObjectFieldDescriptor<OptionObject>
            {
                using ObjectFieldDescriptor::ObjectFieldDescriptor;
 
                static std::vector<FieldDescriptor> all()
                {
                    return { OptionClass, Type, Critical, DataSize };
                }
 
                static const FieldDescriptor OptionClass;
 
                static const FieldDescriptor Type;
 
                static const FieldDescriptor Critical;
 
                static const FieldDescriptor DataSize;
            };
 
            static const FieldDescriptor OptionsLength;
 
            static const FieldDescriptor ProtocolType;
 
            static const FieldDescriptor VNI;
 
            static const FieldDescriptor OamFlag;
 
            static const FieldDescriptor CriticalFlag;
 
            static const FieldDescriptor Options;
 
            static const OptionObject Option;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
#pragma pack(push, 1)
        struct geneve_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t optionsLength : 6;
            uint8_t version : 2;
            uint8_t reserved1 : 6;
            uint8_t criticalFlag : 1;
            uint8_t oamFlag : 1;
#else
            uint8_t version : 2;
            uint8_t optionsLength : 6;
            uint8_t oamFlag : 1;
            uint8_t criticalFlag : 1;
            uint8_t reserved1 : 6;
#endif
            uint16_t protocolType;
            uint8_t vni[3];
            uint8_t reserved2;
        };
#pragma pack(pop)
        static_assert(sizeof(geneve_header) == 8, "geneve_header size is not 8 bytes");
 
        static constexpr size_t HeaderLength = sizeof(geneve_header);
        static constexpr size_t OptionsLengthUnit = 4;
        static constexpr size_t MaxOptionsLength = ((1 << 6) - 1) * OptionsLengthUnit;
 
        geneve_header* getGeneveHeader() const
        {
            return reinterpret_cast<geneve_header*>(m_Data);
        }
 
        void setOptionsLength(size_t value);
 
        void updateCriticalFlag();
    };
}  // namespace pcpp