GreLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_GRE_LAYER
#define PACKETPP_GRE_LAYER

#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) : Layer(data, dataLen, prevLayer, packet) { }

        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) { m_Protocol = 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();


        // 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) { m_Protocol = GREv1; }

        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();


        // 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) { m_Protocol = 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

#endif /* PACKETPP_GRE_LAYER */