RadiusLayer.h

Go to the documentation of this file.

#pragma once
 
#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)
    static_assert(sizeof(radius_header) == 20, "radius_header size is not 20 bytes");
 
    class RadiusAttribute : public TLVRecord<uint8_t, uint8_t>
    {
    public:
        explicit RadiusAttribute(uint8_t* attrRawData) : TLVRecord(attrRawData)
        {}
 
        ~RadiusAttribute() override = default;
 
        // implement abstract methods
 
        size_t getTotalSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            return static_cast<size_t>(m_Data->recordLen);
        }
 
        size_t getDataSize() const override
        {
            if (m_Data == nullptr)
                return 0;
 
            return static_cast<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, 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() override = default;
 
        radius_header* getRadiusHeader() const
        {
            return reinterpret_cast<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 override;
 
        void parseNextLayer() override
        {}
 
        void computeCalculateFields() override;
 
        std::string toString() const override;
 
        OsiModelLayer getOsiModelLayer() const override
        {
            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