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() const
        {
            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;
 
        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();
 
 
        // implement abstract methods
 
        size_t getHeaderLen() const;
 
        void parseNextLayer() {}
 
        void computeCalculateFields();
 
        std::string toString() const;
 
        OsiModelLayer getOsiModelLayer() const { return OsiModelSesionLayer; }
 
        static bool isDataValid(const uint8_t* udpData, size_t udpDataLen);
 
    };
}
 
#endif // PACKETPP_RADIUS_LAYER