VrrpLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "IpAddress.h"
#include <vector>
 
 
namespace pcpp
{
 
 
 
    struct vrrp_header
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t type : 4;
 
        uint8_t version : 4;
#else
        uint8_t version : 4;
 
        uint8_t type : 4;
#endif
        uint8_t vrId;
 
        uint8_t priority;
 
        uint8_t ipAddrCount;
 
        uint16_t authTypeAdvInt;
 
        uint16_t checksum;
 
        uint8_t* ipAddresses[];
    };
    static_assert(sizeof(vrrp_header) == 8, "vrrp_header size is not 8 bytes");
 
    class VrrpLayer : public Layer
    {
    private:
        bool addIPAddressesAt(const std::vector<IPAddress>& ipAddresses, int offset);
 
        uint8_t getIPAddressLen() const;
 
        bool isIPAddressValid(IPAddress& ipAddress) const;
 
        uint8_t* getFirstIPAddressPtr() const;
 
        uint8_t* getNextIPAddressPtr(uint8_t* ipAddressPtr) const;
 
        IPAddress getIPAddressFromData(uint8_t* data) const;
 
        void copyIPAddressToData(uint8_t* data, const IPAddress& ipAddress) const;
 
        IPAddress::AddressType m_AddressType;
 
    protected:
        VrrpLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType vrrpVer,
                  IPAddress::AddressType addressType)
            : Layer(data, dataLen, prevLayer, packet, vrrpVer), m_AddressType(addressType)
        {}
 
        explicit VrrpLayer(ProtocolType subProtocol, uint8_t virtualRouterId, uint8_t priority);
 
        vrrp_header* getVrrpHeader() const
        {
            return reinterpret_cast<vrrp_header*>(m_Data);
        }
 
        void setAddressType(IPAddress::AddressType addressType);
 
        void serializeLayer(ObjectScope& serializer) const override;
 
        virtual void serializeVrrpLayer(ObjectScope& serializer) const = 0;
 
    public:
        enum VrrpType
        {
            VrrpType_Unknown = 0,
 
            VrrpType_Advertisement = 1
        };
 
        enum VrrpPriority
        {
            Default,
            Stop,
            Owner,
            Other
        };
 
        ~VrrpLayer() override = default;
 
        IPAddress::AddressType getAddressType() const;
 
        static ProtocolType getVersionFromData(uint8_t* data, size_t dataLen);
 
        uint8_t getVersion() const;
 
        VrrpType getType() const;
 
        uint8_t getVirtualRouterID() const;
 
        void setVirtualRouterID(uint8_t virtualRouterID);
 
 
        uint8_t getPriority() const;
 
        VrrpPriority getPriorityAsEnum() const;
 
        void setPriority(uint8_t priority);
 
        uint16_t getChecksum() const;
 
        void calculateAndSetChecksum();
 
        virtual uint16_t calculateChecksum() const = 0;
 
        bool isChecksumCorrect() const;
 
        uint8_t getIPAddressesCount() const;
 
        std::vector<IPAddress> getIPAddresses() const;
 
        bool addIPAddresses(const std::vector<IPAddress>& ipAddresses);
 
        bool addIPAddress(const IPAddress& ipAddress);
 
        bool removeIPAddressAtIndex(int index);
 
        bool removeAllIPAddresses();
 
        // implement abstract methods
 
        void parseNextLayer() override
        {}
 
        void computeCalculateFields() override;
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        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{ Type, VirtualRouterID, Priority, Checksum, IPAddresses };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Type;
 
            static const FieldDescriptor VirtualRouterID;
 
            static const FieldDescriptor Priority;
 
            static const FieldDescriptor PriorityValue;
 
            static const FieldDescriptor Checksum;
 
            static const FieldDescriptor IPAddresses;
 
            static const FieldDescriptor IPAddress;
 
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 5;
        };
    };
 
    class VrrpV2Layer : public VrrpLayer
    {
    private:
        struct vrrpv2_auth_adv
        {
            uint8_t authType;
            uint8_t advInt;
        };
 
    public:
        enum class VrrpAuthType : uint8_t
        {
            NoAuthentication = 0,
            SimpleTextPassword = 1,
            IPAuthenticationHeader = 2,
            MD5 = 3,
            Other = 4
        };
 
        VrrpV2Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : VrrpLayer(data, dataLen, prevLayer, packet, VRRPv2, IPAddress::IPv4AddressType)
        {}
 
        explicit VrrpV2Layer(uint8_t virtualRouterId, uint8_t priority, uint8_t advInt, uint8_t authType = 0);
 
        ~VrrpV2Layer() override = default;
 
        uint8_t getAdvInt() const;
 
        void setAdvInt(uint8_t advInt);
 
        uint8_t getAuthType() const;
 
        VrrpAuthType getAuthTypeAsEnum() const;
 
        void setAuthType(uint8_t authType);
 
        // implement abstract methods
 
        uint16_t calculateChecksum() const override;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<vrrp_header>(data, dataLen);
        }
 
        struct SerializedFields : VrrpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = VrrpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ AdvInt, AuthType };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor AdvInt;
 
            static const FieldDescriptor AuthType;
        };
 
    protected:
        void serializeVrrpLayer(ObjectScope& serializer) const override;
    };
 
    class VrrpV3Layer : public VrrpLayer
    {
    private:
        struct vrrpv3_rsvd_adv
        {
            uint16_t maxAdvInt;
        };
 
    public:
        VrrpV3Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, IPAddress::AddressType addressType)
            : VrrpLayer(data, dataLen, prevLayer, packet, VRRPv3, addressType)
        {}
 
        explicit VrrpV3Layer(IPAddress::AddressType addressType, uint8_t virtualRouterId, uint8_t priority,
                             uint16_t maxAdvInt);
 
        ~VrrpV3Layer() override = default;
 
        uint16_t getMaxAdvInt() const;
 
        void setMaxAdvInt(uint16_t maxAdvInt);
 
        // implement abstract methods
 
        uint16_t calculateChecksum() const override;
 
        static bool isDataValid(uint8_t const* data, size_t dataLen)
        {
            return canReinterpretAs<vrrp_header>(data, dataLen);
        }
 
        struct SerializedFields : VrrpLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = VrrpLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ MaxAdvInt };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor MaxAdvInt;
        };
 
    protected:
        void serializeVrrpLayer(ObjectScope& serializer) const override;
    };
}  // namespace pcpp