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 */