GreLayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct gre_basic_header
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t recursionControl : 3,
            strictSourceRouteBit : 1,
            sequenceNumBit : 1,
            keyBit : 1,
            routingBit : 1,
            checksumBit : 1;
#else
        uint8_t checksumBit : 1,
            routingBit : 1,
            keyBit : 1,
            sequenceNumBit : 1,
            strictSourceRouteBit : 1,
            recursionControl : 3;
#endif
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t version : 3,
            flags : 4,
            ackSequenceNumBit : 1;
#else
        uint8_t ackSequenceNumBit : 1,
            flags : 4,
            version : 3;
#endif
 
        uint16_t protocol;
    };
#pragma pack(pop)
    static_assert(sizeof(gre_basic_header) == 4, "gre_basic_header size is not 4 bytes");
 
#pragma pack(push, 1)
    struct gre1_header : gre_basic_header
    {
        uint16_t payloadLength;
        uint16_t callID;
    };
#pragma pack(pop)
    static_assert(sizeof(gre1_header) == 8, "gre1_header size is not 8 bytes");
 
#pragma pack(push, 1)
    struct ppp_pptp_header
    {
        uint8_t address;
        uint8_t control;
        uint16_t protocol;
    };
#pragma pack(pop)
    static_assert(sizeof(ppp_pptp_header) == 4, "ppp_pptp_header size is not 4 bytes");
 
    class GreLayer : public Layer
    {
    public:
        ~GreLayer() override = default;
 
        static ProtocolType getGREVersion(uint8_t* greData, size_t greDataLen);
 
        bool getSequenceNumber(uint32_t& seqNumber) const;
 
        bool setSequenceNumber(uint32_t seqNumber);
 
        bool unsetSequenceNumber();
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() 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{
                    StrictSourceRouteBit, SequenceNumBit, KeyBit,  RoutingBit, ChecksumBit,
                    RecursionControl,     Flags,          Version, Protocol,   SequenceNumber
                };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor StrictSourceRouteBit;
 
            static const FieldDescriptor SequenceNumBit;
 
            static const FieldDescriptor KeyBit;
 
            static const FieldDescriptor RoutingBit;
 
            static const FieldDescriptor ChecksumBit;
 
            static const FieldDescriptor RecursionControl;
 
            static const FieldDescriptor Flags;
 
            static const FieldDescriptor Version;
 
            static const FieldDescriptor Protocol;
 
            static const FieldDescriptor SequenceNumber;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 10;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
        GreLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol)
            : Layer(data, dataLen, prevLayer, packet, protocol)
        {}
 
        GreLayer()
        {}
 
        enum GreField
        {
            GreChecksumOrRouting = 0,
            GreKey = 1,
            GreSeq = 2,
            GreAck = 3
        };
 
        uint8_t* getFieldValue(GreField field, bool returnOffsetEvenIfFieldMissing) const;
 
        void computeCalculateFieldsInner();
    };
 
    class GREv0Layer : public GreLayer
    {
    public:
        GREv0Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GreLayer(data, dataLen, prevLayer, packet, GREv0)
        {}
 
        GREv0Layer();
 
        ~GREv0Layer() override = default;
 
        gre_basic_header* getGreHeader() const
        {
            return reinterpret_cast<gre_basic_header*>(m_Data);
        }
 
        bool getChecksum(uint16_t& checksum) const;
 
        bool setChecksum(uint16_t checksum);
 
        bool unsetChecksum();
 
        bool getOffset(uint16_t& offset) const;
 
        bool getKey(uint32_t& key) const;
 
        bool setKey(uint32_t key);
 
        bool unsetKey();
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(gre_basic_header);
        }
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        struct SerializedFields : GreLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GreLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Checksum, Offset, Key };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Checksum;
 
            static const FieldDescriptor Offset;
 
            static const FieldDescriptor Key;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GreLayer::SerializedFields::MaxID + 3;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class GREv1Layer : public GreLayer
    {
    public:
        GREv1Layer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : GreLayer(data, dataLen, prevLayer, packet, GREv1)
        {}
 
        explicit GREv1Layer(uint16_t callID);
 
        ~GREv1Layer() override = default;
 
        gre1_header* getGreHeader() const
        {
            return reinterpret_cast<gre1_header*>(m_Data);
        }
 
        bool getAcknowledgmentNum(uint32_t& ackNum) const;
 
        bool setAcknowledgmentNum(uint32_t ackNum);
 
        bool unsetAcknowledgmentNum();
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(gre1_header);
        }
 
        // implement abstract methods
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        struct SerializedFields : GreLayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = GreLayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ AckSequenceNumBit, PayloadLength, CallID,
                                                              AcknowledgmentNumber };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor AckSequenceNumBit;
 
            static const FieldDescriptor PayloadLength;
 
            static const FieldDescriptor CallID;
 
            static const FieldDescriptor AcknowledgmentNumber;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = GreLayer::SerializedFields::MaxID + 4;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class PPP_PPTPLayer : public Layer
    {
    public:
        PPP_PPTPLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, PPP_PPTP)
        {}
 
        PPP_PPTPLayer(uint8_t address, uint8_t control);
 
        ~PPP_PPTPLayer() override = default;
 
        ppp_pptp_header* getPPP_PPTPHeader() const
        {
            return reinterpret_cast<ppp_pptp_header*>(m_Data);
        }
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // implement abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(ppp_pptp_header);
        }
 
        void computeCalculateFields() override;
 
        std::string toString() const override
        {
            return "PPP for PPTP Layer";
        }
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelSessionLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Address, Control, Protocol };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Address;
 
            static const FieldDescriptor Control;
 
            static const FieldDescriptor Protocol;
 
            // cppcheck-suppress duplInheritedMember
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 3;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    bool PPP_PPTPLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(ppp_pptp_header);
    }
 
}  // namespace pcpp