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;
        }
 
    protected:
        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);
 
        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;
    };
 
    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;
    };
 
    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 OsiModelSesionLayer;
        }
    };
 
    bool PPP_PPTPLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(ppp_pptp_header);
    }
 
}  // namespace pcpp