RadiusLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_RADIUS_LAYER
#define PACKETPP_RADIUS_LAYER

#include "Layer.h"
#include "TLVData.h"


namespace pcpp
{

#pragma pack(push, 1)
    struct radius_header
    {
        uint8_t code;
        uint8_t id;
        uint16_t length;
        uint8_t authenticator[16];
    };
#pragma pack(pop)


    class RadiusAttribute : public TLVRecord
    {
    public:

        RadiusAttribute(uint8_t* attrRawData) : TLVRecord(attrRawData) { }

        virtual ~RadiusAttribute() { }

        // implement abstract methods

        size_t getTotalSize() const
        {
            return (size_t)m_Data->recordLen;
        }

        size_t getDataSize()
        {
            return (size_t)m_Data->recordLen - 2*sizeof(uint8_t);
        }
    };


    class RadiusAttributeBuilder : public TLVRecordBuilder
    {
    public:

        RadiusAttributeBuilder(uint8_t attrType, const uint8_t* attrValue, uint8_t attrValueLen) :
            TLVRecordBuilder(attrType, attrValue, attrValueLen) { }

        RadiusAttributeBuilder(uint8_t attrType, uint8_t attrValue) :
            TLVRecordBuilder(attrType, attrValue) { }

        RadiusAttributeBuilder(uint8_t attrType, uint16_t attrValue) :
            TLVRecordBuilder(attrType, attrValue) { }

        RadiusAttributeBuilder(uint8_t attrType, uint32_t attrValue) :
            TLVRecordBuilder(attrType, attrValue) { }

        RadiusAttributeBuilder(uint8_t attrType, const IPv4Address& attrValue) :
            TLVRecordBuilder(attrType, attrValue) { }

        RadiusAttributeBuilder(uint8_t attrType, const std::string& attrValue) :
            TLVRecordBuilder(attrType, attrValue) { }

        RadiusAttributeBuilder(const RadiusAttributeBuilder& other) :
            TLVRecordBuilder(other) { }

        RadiusAttribute build() const;
    };


    class RadiusLayer : public Layer
    {
    private:

        TLVRecordReader<RadiusAttribute> m_AttributeReader;

        inline uint8_t* getAttributesBasePtr() { return m_Data + sizeof(radius_header); }

        RadiusAttribute addAttrAt(const RadiusAttributeBuilder& attrBuilder, int offset);

    public:

        RadiusLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet) :
            Layer(data, dataLen, prevLayer, packet)
            { m_Protocol = Radius; }

        RadiusLayer(uint8_t code, uint8_t id, const uint8_t* authenticator, uint8_t authenticatorArrSize);

        RadiusLayer(uint8_t code, uint8_t id, const std::string authenticator);

        ~RadiusLayer() {}

        inline radius_header* getRadiusHeader() { return (radius_header*)m_Data; }

        std::string getAuthenticatorValue();

        void setAuthenticatorValue(const std::string& authValue);

        static std::string getRadiusMessageString(uint8_t radiusMessageCode);

        RadiusAttribute getFirstAttribute();

        RadiusAttribute getNextAttribute(RadiusAttribute& attr);

        RadiusAttribute getAttribute(uint8_t attrType);

        size_t getAttributeCount();

        RadiusAttribute addAttribute(const RadiusAttributeBuilder& attrBuilder);

        RadiusAttribute addAttributeAfter(const RadiusAttributeBuilder& attrBuilder, uint8_t prevAttrType);

        bool removeAttribute(uint8_t attrType);

        bool removeAllAttributes();


        // implement abstract methods

        size_t getHeaderLen();

        void parseNextLayer() {}

        void computeCalculateFields();

        std::string toString();

        OsiModelLayer getOsiModelLayer() { return OsiModelSesionLayer; }

    };
}

#endif // PACKETPP_RADIUS_LAYER