CiscoHdlcLayer.h

#pragma once
 
#include "Layer.h"
 
namespace pcpp
{
    class CiscoHdlcLayer : public Layer
    {
    public:
        enum class AddressType
        {
            Unicast = 0x0f,
            Multicast = 0x8f,
            Unknown
        };
 
        CiscoHdlcLayer(uint8_t* data, size_t dataLen, Packet* packet) : Layer(data, dataLen, nullptr, packet, CiscoHDLC)
        {}
 
        explicit CiscoHdlcLayer(AddressType address);
 
        ~CiscoHdlcLayer() override = default;
 
        AddressType getAddress() const;
 
        uint8_t getAddressValue() const;
 
        void setAddress(AddressType address);
 
        void setAddressValue(uint8_t address);
 
        uint16_t getNextProtocol() const;
 
        static bool isDataValid(const uint8_t* data, size_t dataLen)
        {
            return data && dataLen >= sizeof(cisco_hdlc_header);
        }
 
        // Overridden methods
 
        size_t getHeaderLen() const override
        {
            return sizeof(cisco_hdlc_header);
        }
 
        void computeCalculateFields() override;
 
        void parseNextLayer() override;
 
        std::string toString() const 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{ Address, NextProtocol };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor Address;
 
            static const FieldDescriptor NextProtocol;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
 
    private:
#pragma pack(push, 1)
        struct cisco_hdlc_header
        {
            uint8_t address;
            uint8_t control;
            uint16_t protocol;
        };
#pragma pack(pop)
        static_assert(sizeof(cisco_hdlc_header) == 4, "cisco_hdlc_header size is not 4 bytes");
 
        cisco_hdlc_header* getCiscoHdlcHeader() const
        {
            return reinterpret_cast<cisco_hdlc_header*>(m_Data);
        }
 
        void setNextProtocol(uint16_t protocol);
    };
 
}  // namespace pcpp