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<uint8_t, uint8_t>
    {
    public:

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

        virtual ~RadiusAttribute() { }

        // implement abstract methods

        size_t getTotalSize() const
        {
            if (m_Data == nullptr)
                return 0;

            return (size_t)m_Data->recordLen;
        }

        size_t getDataSize() const
        {
            if (m_Data == nullptr)
                return 0;

            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) { }

        RadiusAttributeBuilder& operator=(const RadiusAttributeBuilder& other)
        {
            TLVRecordBuilder::operator=(other);
            return *this;
        }

        RadiusAttribute build() const;
    };


    class RadiusLayer : public Layer
    {
    private:

        TLVRecordReader<RadiusAttribute> m_AttributeReader;

        uint8_t* getAttributesBasePtr() const { 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() {}

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

        std::string getAuthenticatorValue() const;

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

        static std::string getRadiusMessageString(uint8_t radiusMessageCode);

        RadiusAttribute getFirstAttribute() const;

        RadiusAttribute getNextAttribute(RadiusAttribute& attr) const;

        RadiusAttribute getAttribute(uint8_t attrType) const;

        size_t getAttributeCount() const;

        RadiusAttribute addAttribute(const RadiusAttributeBuilder& attrBuilder);

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

        bool removeAttribute(uint8_t attrType);

        bool removeAllAttributes();

        static bool isDataValid(const uint8_t* udpData, size_t udpDataLen);

        static inline bool isRadiusPort(uint16_t port);

        // implement abstract methods

        size_t getHeaderLen() const;

        void parseNextLayer() {}

        void computeCalculateFields();

        std::string toString() const;

        OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }
    };


    // implementation of inline methods

    bool RadiusLayer::isRadiusPort(uint16_t port)
    {
        switch (port)
        {
        case 1812:
        case 1813:
        case 3799:
            return true;
        default:
            return false;
        }
    } // isRadiusPort

} // namespace pcpp

#endif // PACKETPP_RADIUS_LAYER