VxlanLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct vxlan_header
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint16_t reserved6_8 : 3;
        uint16_t vniPresentFlag : 1;
        uint16_t reserved2_4 : 3;
        uint16_t gbpFlag : 1;
        uint16_t reserved14_16 : 3;
        uint16_t policyAppliedFlag : 1;
        uint16_t reserved11_12 : 2;
        uint16_t dontLearnFlag : 1;
        uint16_t reserved9 : 1;
#else
        uint16_t reserved9 : 1;
        uint16_t dontLearnFlag : 1;
        uint16_t reserved11_12 : 2;
        uint16_t policyAppliedFlag : 1;
        uint16_t reserved14_16 : 3;
        uint16_t gbpFlag : 1;
        uint16_t reserved2_4 : 3;
        uint16_t vniPresentFlag : 1;
        uint16_t reserved6_8 : 3;
#endif
 
        uint16_t groupPolicyID;
 
        uint32_t vni : 24;
        uint32_t pad : 8;
    };
#pragma pack(pop)
    static_assert(sizeof(vxlan_header) == 8, "vxlan_header size is not 8 bytes");
 
    class VxlanLayer : public Layer
    {
    public:
        VxlanLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, VXLAN)
        {}
 
        explicit VxlanLayer(uint32_t vni = 0, uint16_t groupPolicyID = 0, bool setGbpFlag = false,
                            bool setPolicyAppliedFlag = false, bool setDontLearnFlag = false);
 
        ~VxlanLayer() override = default;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<vxlan_header>(data, dataLen);
        }
 
        vxlan_header* getVxlanHeader() const
        {
            return reinterpret_cast<vxlan_header*>(m_Data);
        }
 
        uint32_t getVNI() const;
 
        void setVNI(uint32_t vni);
 
        static bool isVxlanPort(uint16_t port)
        {
            return port == 4789;
        }
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(vxlan_header);
        }
 
        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{ ValidVNI, GroupPolicyID, VNI };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor ValidVNI;
 
            static const FieldDescriptor GroupPolicyID;
 
            static const FieldDescriptor VNI;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
}  // namespace pcpp