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)
 
#pragma pack(push, 1)
    struct gre1_header : gre_basic_header
    {
        uint16_t payloadLength;
        uint16_t callID;
    };
#pragma pack(pop)
 
#pragma pack(push, 1)
    struct ppp_pptp_header
    {
        uint8_t address;
        uint8_t control;
        uint16_t protocol;
    };
#pragma pack(pop)
 
    class GreLayer : public Layer
    {
    public:
        virtual ~GreLayer()
        {}
 
        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();
 
        size_t getHeaderLen() const;
 
        OsiModelLayer getOsiModelLayer() const
        {
            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();
 
        virtual ~GREv0Layer()
        {}
 
        gre_basic_header* getGreHeader() const
        {
            return (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();
 
        std::string toString() const;
    };
 
    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);
 
        virtual ~GREv1Layer()
        {}
 
        gre1_header* getGreHeader() const
        {
            return (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();
 
        std::string toString() const;
    };
 
    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()
        {}
 
        ppp_pptp_header* getPPP_PPTPHeader() const
        {
            return (ppp_pptp_header*)m_Data;
        }
 
        // implement abstract methods
 
        void parseNextLayer();
 
        size_t getHeaderLen() const
        {
            return sizeof(ppp_pptp_header);
        }
 
        void computeCalculateFields();
 
        std::string toString() const
        {
            return "PPP for PPTP Layer";
        }
 
        OsiModelLayer getOsiModelLayer() const
        {
            return OsiModelSesionLayer;
        }
    };
 
}  // namespace pcpp