PPPoELayer.h

Go to the documentation of this file.

#pragma once
 
#include "Layer.h"
#include "TLVData.h"
 
#include <Layer.h>
#include <vector>
#include <string.h>
 
 
namespace pcpp
{
#pragma pack(push, 1)
    struct pppoe_header
    {
#if (BYTE_ORDER == LITTLE_ENDIAN)
        uint8_t version : 4;
        uint8_t type : 4;
        uint8_t code;
#else
        uint16_t version : 4;
        uint16_t type : 4;
        uint16_t code : 8;
#endif
        uint16_t sessionId;
        uint16_t payloadLength;
    };
#pragma pack(pop)
    static_assert(sizeof(pppoe_header) == 6, "pppoe_header size is not 6 bytes");
 
    class PPPoELayer : public Layer
    {
    public:
        enum PPPoECode
        {
            PPPOE_CODE_SESSION = 0x00,
            PPPOE_CODE_PADO = 0x07,
            PPPOE_CODE_PADI = 0x09,
            PPPOE_CODE_PADG = 0x0a,
            PPPOE_CODE_PADC = 0x0b,
            PPPOE_CODE_PADQ = 0x0c,
            PPPOE_CODE_PADR = 0x19,
            PPPOE_CODE_PADS = 0x65,
            PPPOE_CODE_PADT = 0xa7,
            PPPOE_CODE_PADM = 0xd3,
            PPPOE_CODE_PADN = 0xd4
        };
 
        ~PPPoELayer() override = default;
 
        pppoe_header* getPPPoEHeader() const
        {
            return reinterpret_cast<pppoe_header*>(m_Data);
        }
 
        // abstract methods implementation
 
        void computeCalculateFields() override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelDataLinkLayer;
        }
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Code, Version, Type, SessionID };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Code;
 
            static const FieldDescriptor Version;
 
            static const FieldDescriptor Type;
 
            static const FieldDescriptor SessionID;
 
            static constexpr uint16_t MaxID = Layer::SerializedFields::MaxID + 4;
        };
 
    protected:
        // protected c'tor as this class shouldn't be instantiated
        PPPoELayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet, ProtocolType protocol)
            : Layer(data, dataLen, prevLayer, packet, protocol)
        {}
 
        // protected c'tor as this class shouldn't be instantiated
        PPPoELayer(uint8_t version, uint8_t type, PPPoELayer::PPPoECode code, uint16_t sessionId,
                   size_t additionalBytesToAllocate = 0);
 
        void serializeLayer(ObjectScope& serializer) const override;
    };
 
    class PPPoESessionLayer : public PPPoELayer
    {
    public:
        PPPoESessionLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : PPPoELayer(data, dataLen, prevLayer, packet, PPPoESession)
        {}
 
        PPPoESessionLayer(uint8_t version, uint8_t type, uint16_t sessionId, uint16_t pppNextProtocol)
            : PPPoELayer(version, type, PPPoELayer::PPPOE_CODE_SESSION, sessionId, sizeof(uint16_t))
        {
            setPPPNextProtocol(pppNextProtocol);
        }
 
        ~PPPoESessionLayer() override = default;
 
        uint16_t getPPPNextProtocol() const;
 
        void setPPPNextProtocol(uint16_t nextProtocol);
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // abstract methods implementation
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override
        {
            return sizeof(pppoe_header) + sizeof(uint16_t);
        }
 
        std::string toString() const override;
    };
 
    class PPPoEDiscoveryLayer : public PPPoELayer
    {
    public:
        enum PPPoETagTypes
        {
            PPPOE_TAG_EOL = 0x0000,
            PPPOE_TAG_SVC_NAME = 0x0101,
            PPPOE_TAG_AC_NAME = 0x0102,
            PPPOE_TAG_HOST_UNIQ = 0x0103,
            PPPOE_TAG_AC_COOKIE = 0x0104,
            PPPOE_TAG_VENDOR = 0x0105,
            PPPOE_TAG_CREDITS = 0x0106,
            PPPOE_TAG_METRICS = 0x0107,
            PPPOE_TAG_SEQ_NUM = 0x0108,
            PPPOE_TAG_CRED_SCALE = 0x0109,
            PPPOE_TAG_RELAY_ID = 0x0110,
            PPPOE_TAG_HURL = 0x0111,
            PPPOE_TAG_MOTM = 0x0112,
            PPPOE_TAG_MAX_PAYLD = 0x0120,
            PPPOE_TAG_IP_RT_ADD = 0x0121,
            PPPOE_TAG_SVC_ERR = 0x0201,
            PPPOE_TAG_AC_ERR = 0x0202,
            PPPOE_TAG_GENERIC_ERR = 0x0203
        };
 
        class PPPoETag : public TLVRecord<uint16_t, uint16_t>
        {
        public:
            explicit PPPoETag(uint8_t* tagRawData) : TLVRecord(tagRawData)
            {}
 
            ~PPPoETag() override = default;
 
            PPPoEDiscoveryLayer::PPPoETagTypes getType() const;
 
            std::string getValueAsString() const
            {
                size_t dataSize = getDataSize();
                if (dataSize < 1)
                    return "";
 
                return std::string(reinterpret_cast<const char*>(m_Data->recordValue), dataSize);
            }
 
            // implement abstract methods
 
            size_t getTotalSize() const override;
 
            size_t getDataSize() const override;
        };
 
        class PPPoETagBuilder : public TLVRecordBuilder
        {
        public:
            explicit PPPoETagBuilder(PPPoETagTypes tagType)
                : TLVRecordBuilder(static_cast<uint16_t>(tagType), nullptr, 0)
            {}
 
            PPPoETagBuilder(PPPoETagTypes tagType, uint32_t tagValue)
                : TLVRecordBuilder(static_cast<uint16_t>(tagType), tagValue)
            {}
 
            PPPoETagBuilder(PPPoETagTypes tagType, uint8_t* tagValue, uint8_t tagValueLen)
                : TLVRecordBuilder(static_cast<uint16_t>(tagType), tagValue, tagValueLen)
            {}
 
            PPPoETag build() const;
        };
 
        PPPoEDiscoveryLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : PPPoELayer(data, dataLen, prevLayer, packet, PPPoEDiscovery)
        {
            m_DataLen = getHeaderLen();
        }
 
        PPPoEDiscoveryLayer(uint8_t version, uint8_t type, PPPoELayer::PPPoECode code, uint16_t sessionId)
            : PPPoELayer(version, type, code, sessionId)
        {
            m_Protocol = PPPoEDiscovery;
        }
 
        PPPoETag getTag(PPPoEDiscoveryLayer::PPPoETagTypes tagType) const;
 
        PPPoETag getFirstTag() const;
 
        PPPoETag getNextTag(const PPPoETag& tag) const;
 
        int getTagCount() const;
 
        PPPoETag addTag(const PPPoETagBuilder& tagBuilder);
 
        PPPoETag addTagAfter(const PPPoETagBuilder& tagBuilder, PPPoETagTypes prevTagType);
 
        bool removeTag(PPPoEDiscoveryLayer::PPPoETagTypes tagType);
 
        bool removeAllTags();
 
        static inline bool isDataValid(const uint8_t* data, size_t dataLen);
 
        // abstract methods implementation
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override;
 
        std::string toString() const override
        {
            return "PPP-over-Ethernet Discovery (" + codeToString((PPPoELayer::PPPoECode)getPPPoEHeader()->code) + ")";
        }
 
        struct SerializedFields : PPPoELayer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = PPPoELayer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ Tags };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Tags;
 
            static const FieldDescriptor Tag;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
        TLVRecordReader<PPPoETag> m_TagReader;
 
        PPPoETag addTagAt(const PPPoETagBuilder& tagBuilder, int offset);
 
        uint8_t* getTagBasePtr() const
        {
            return m_Data + sizeof(pppoe_header);
        }
 
        std::string codeToString(PPPoECode code) const;
    };
 
    // implementation of inline methods
 
    bool PPPoESessionLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(pppoe_header) + sizeof(uint16_t);
    }
 
    bool PPPoEDiscoveryLayer::isDataValid(const uint8_t* data, size_t dataLen)
    {
        return data && dataLen >= sizeof(pppoe_header);
    }
 
    // Copied from Wireshark: ppptypes.h
 
#define PCPP_PPP_PADDING 0x1
#define PCPP_PPP_ROHC_SCID 0x3
#define PCPP_PPP_ROHC_LCID 0x5
#define PCPP_PPP_IP 0x21
#define PCPP_PPP_OSI 0x23
#define PCPP_PPP_XNSIDP 0x25
#define PCPP_PPP_DEC4 0x27
#define PCPP_PPP_AT 0x29
#define PCPP_PPP_IPX 0x2b
#define PCPP_PPP_VJC_COMP 0x2d
#define PCPP_PPP_VJC_UNCOMP 0x2f
#define PCPP_PPP_BCP 0x31
#define PCPP_PPP_ST 0x33
#define PCPP_PPP_VINES 0x35
#define PCPP_PPP_AT_EDDP 0x39
#define PCPP_PPP_AT_SB 0x3b
#define PCPP_PPP_MP 0x3d
#define PCPP_PPP_NB 0x3f
#define PCPP_PPP_CISCO 0x41
#define PCPP_PPP_ASCOM 0x43
#define PCPP_PPP_LBLB 0x45
#define PCPP_PPP_RL 0x47
#define PCPP_PPP_SDTP 0x49
#define PCPP_PPP_LLC 0x4b
#define PCPP_PPP_SNA 0x4d
#define PCPP_PPP_IPV6HC 0x4f
#define PCPP_PPP_KNX 0x51
#define PCPP_PPP_ENCRYPT 0x53
#define PCPP_PPP_ILE 0x55
#define PCPP_PPP_IPV6 0x57
#define PCPP_PPP_MUX 0x59
#define PCPP_PPP_VSNP 0x5b
#define PCPP_PPP_TNP 0x5d
#define PCPP_PPP_RTP_FH 0x61
#define PCPP_PPP_RTP_CTCP 0x63
#define PCPP_PPP_RTP_CNTCP 0x65
#define PCPP_PPP_RTP_CUDP8 0x67
#define PCPP_PPP_RTP_CRTP8 0x69
#define PCPP_PPP_STAMPEDE 0x6f
#define PCPP_PPP_MPPLUS 0x73
#define PCPP_PPP_NTCITS_IPI 0xc1
#define PCPP_PPP_ML_SLCOMP 0xfb
#define PCPP_PPP_COMP 0xfd
#define PCPP_PPP_STP_HELLO 0x0201
#define PCPP_PPP_IBM_SR 0x0203
#define PCPP_PPP_DEC_LB 0x0205
#define PCPP_PPP_CDP 0x0207
#define PCPP_PPP_NETCS 0x0209
#define PCPP_PPP_STP 0x020b
#define PCPP_PPP_EDP 0x020d
#define PCPP_PPP_OSCP 0x0211
#define PCPP_PPP_OSCP2 0x0213
#define PCPP_PPP_LUXCOM 0x0231
#define PCPP_PPP_SIGMA 0x0233
#define PCPP_PPP_ACSP 0x0235
#define PCPP_PPP_MPLS_UNI 0x0281
#define PCPP_PPP_MPLS_MULTI 0x0283
#define PCPP_PPP_P12844 0x0285
#define PCPP_PPP_TETRA 0x0287
#define PCPP_PPP_MFTP 0x0289
#define PCPP_PPP_RTP_CTCPND 0x2063
#define PCPP_PPP_RTP_CS 0x2065
#define PCPP_PPP_RTP_CUDP16 0x2067
#define PCPP_PPP_RTP_CRDP16 0x2069
#define PCPP_PPP_CCCP 0x4001
#define PCPP_PPP_CDPD_MNRP 0x4003
#define PCPP_PPP_EXPANDAP 0x4005
#define PCPP_PPP_ODSICP 0x4007
#define PCPP_PPP_DOCSIS 0x4009
#define PCPP_PPP_CETACEANNDP 0x400b
#define PCPP_PPP_LZS 0x4021
#define PCPP_PPP_REFTEK 0x4023
#define PCPP_PPP_FC 0x4025
#define PCPP_PPP_EMIT 0x4027
#define PCPP_PPP_VSP 0x405b
#define PCPP_PPP_TLSP 0x405d
#define PCPP_PPP_IPCP 0x8021
#define PCPP_PPP_OSINLCP 0x8023
#define PCPP_PPP_XNSIDPCP 0x8025
#define PCPP_PPP_DECNETCP 0x8027
#define PCPP_PPP_ATCP 0x8029
#define PCPP_PPP_IPXCP 0x802b
#define PCPP_PPP_BRIDGENCP 0x8031
#define PCPP_PPP_SPCP 0x8033
#define PCPP_PPP_BVCP 0x8035
#define PCPP_PPP_MLCP 0x803d
#define PCPP_PPP_NBCP 0x803f
#define PCPP_PPP_CISCOCP 0x8041
#define PCPP_PPP_ASCOMCP 0x8043
#define PCPP_PPP_LBLBCP 0x8045
#define PCPP_PPP_RLNCP 0x8047
#define PCPP_PPP_SDCP 0x8049
#define PCPP_PPP_LLCCP 0x804b
#define PCPP_PPP_SNACP 0x804d
#define PCPP_PPP_IP6HCCP 0x804f
#define PCPP_PPP_KNXCP 0x8051
#define PCPP_PPP_ECP 0x8053
#define PCPP_PPP_ILECP 0x8055
#define PCPP_PPP_IPV6CP 0x8057
#define PCPP_PPP_MUXCP 0x8059
#define PCPP_PPP_VSNCP 0x805b
#define PCPP_PPP_TNCP 0x805d
#define PCPP_PPP_STAMPEDECP 0x806f
#define PCPP_PPP_MPPCP 0x8073
#define PCPP_PPP_IPICP 0x80c1
#define PCPP_PPP_SLCC 0x80fb
#define PCPP_PPP_CCP 0x80fd
#define PCPP_PPP_CDPCP 0x8207
#define PCPP_PPP_NETCSCP 0x8209
#define PCPP_PPP_STPCP 0x820b
#define PCPP_PPP_EDPCP 0x820d
#define PCPP_PPP_ACSPC 0x8235
#define PCPP_PPP_MPLSCP 0x8281
#define PCPP_PPP_P12844CP 0x8285
#define PCPP_PPP_TETRACP 0x8287
#define PCPP_PPP_MFTPCP 0x8289
#define PCPP_PPP_LCP 0xc021
#define PCPP_PPP_PAP 0xc023
#define PCPP_PPP_LQR 0xc025
#define PCPP_PPP_SPAP 0xc027
#define PCPP_PPP_CBCP 0xc029
#define PCPP_PPP_BACP 0xc02b
#define PCPP_PPP_BAP 0xc02d
#define PCPP_PPP_VSAP 0xc05b
#define PCPP_PPP_CONTCP 0xc081
#define PCPP_PPP_CHAP 0xc223
#define PCPP_PPP_RSAAP 0xc225
#define PCPP_PPP_EAP 0xc227
#define PCPP_PPP_SIEP 0xc229
#define PCPP_PPP_SBAP 0xc26f
#define PCPP_PPP_PRPAP 0xc281
#define PCPP_PPP_PRPAP2 0xc283
#define PCPP_PPP_PRPNIAP 0xc481
 
}  // namespace pcpp