BER.h

Go to the documentation of this file.

#ifndef BER_H_
#define BER_H_
 
#include <Arduino.h>
#include <IPAddress.h>
 
#ifdef __has_include
#if __has_include("SNMPcfg.h")
#include "SNMPcfg.h"
#else
#define SNMP_STREAM 1
 
#define SNMP_VECTOR 0
 
#define SNMP_CAPACITY 6
#endif
#endif
 
#if SNMP_STREAM
#include <Stream.h>
#endif
 
#if SNMP_VECTOR
#include <vector>
#endif
 
namespace SNMP {
 
struct Version {
    enum : uint8_t {
        V1,     
        V2C,    
    };
};
 
struct Error {
    enum : uint8_t {
        // Version 1
        NoError,                
        TooBig,                 
        NoSuchName,             
        BadValue,               
        ReadOnly,               
        GenErr,                 
        // Version 2C
        NoAccess,               
        WrongType,              
        WrongLength,            
        WrongEncoding,          
        WrongValue,             
        NoCreation,             
        InconsistentValue,      
        ResourceUnavailable,    
        CommitFailed,           
        UndoFailed,             
        AuthorizationError,     
        NotWritable,            
        InconsistentName,       
    };
 
    Error() {
        _status = NoError;
        _index = 0;
    }
 
    uint8_t _status;
    uint8_t _index;
};
 
struct Trap {
    enum : uint8_t {
        ColdStart,              
        WarmStart,              
        LinkDown,               
        LinkUp,                 
        AuthenticationFailure,  
        EGPNeighborLoss,        
        EnterpriseSpecific,     
    };
 
    Trap() {
        _enterprise = nullptr;
        _genericTrap = ColdStart;
        _specificTrap = 0;
        _timeStamp = 0;
    }
 
    const char *_enterprise;
    IPAddress _agentAddr;
    uint8_t _genericTrap;
    uint8_t _specificTrap;
    uint32_t _timeStamp;
};
 
struct Class {
    enum : uint8_t {
        Universal = 0x00,   
        Application = 0x40, 
        Context = 0x80,     
        Private = 0xC0,     
    };
};
 
struct Form {
    enum : uint8_t {
        Primitive = 0x00,   
        Constructed = 0x20, 
    };
};
 
class Flag {
public:
    enum : uint8_t {
        None = 0,           
        Typed = (1 << 0),   
    };
};
 
class Base {
public:
#if SNMP_STREAM
    static void encode7bits(uint32_t value, Stream &stream, const uint8_t size) {
        for (uint8_t index = 0; index < size; ++index) {
            stream.write((value >> (7 * (size - index - 1)) & 0x7F) | ((size - index - 1) ? 0x80 : 0x00));
        }
    }
#else
    void encode7bits(uint32_t value, uint8_t *buffer, const uint8_t size) {
        buffer += size;
        for (uint8_t index = 0; index < size; ++index) {
            *buffer-- = (value & 0x7F) | (index ? 0x80 : 0x00);
            value >>= 7;
        }
    }
#endif
 
protected:
    unsigned int _size = 0;
 
    friend class BER;
};
 
class Type: public Base {
public:
    enum : uint16_t {
        // Universal
        Boolean = Class::Universal | Form::Primitive | 0x01,    
        Integer,                                                
        BitString,                                              
        OctetString,                                            
        Null,                                                   
        ObjectIdentifier,                                       
        Sequence = Class::Universal | Form::Constructed | 0x10, 
        // Application
        IPAddress = Class::Application | 0x00,                  
        Counter32,                                              
        Gauge32,                                                
        TimeTicks,                                              
        Opaque,                                                 
        Counter64 = Class::Application | 0x06,                  
        Float = Class::Application | 0x08,                      
        // Context
        NoSuchObject = Class::Context | 0x00,                   
        NoSuchInstance,                                         
        EndOfMIBView,                                           
        // Version 1
        GetRequest = Class::Context | Form::Constructed | 0x00, 
        GetNextRequest,                                         
        GetResponse,                                            
        SetRequest,                                             
        Trap,                                                   
        // Version 2C
        GetBulkRequest,                                         
        InformRequest,                                          
        SNMPv2Trap,                                             
        // Version 3
        Report,                                                 
        // Opaque type
        OpaqueFloat = 0x9F78                                    
    };
 
    Type(const unsigned int type = 0) :
            Base() {
        setType(type);
    }
 
    Type(const uint8_t flag, const unsigned int tag) :
            Base() {
        setFlagTag(flag, tag);
    }
 
#if SNMP_STREAM
    void encode(Stream &stream) {
        if (_size == 1) {
            stream.write(_class | _form | _tag);
        } else {
            stream.write(_class | _form | 0x1F);
            Base::encode7bits(_tag, stream, _size - 1);
        }
    }
 
    void decode(Stream &stream) {
        _size = 1;
        _type = stream.read();
        _class = _type & 0xC0;
        _form = _type & 0x20;
        _tag = _type & 0x1F;
        if (_tag == 0x1F) {
            _tag = 0;
            do {
                _size++;
                _type <<= 8;
                _type |= stream.read();
                _tag <<= 7;
                _tag |= _type & 0x7F;
            } while (_type & 0x80);
        }
    }
#else
    uint8_t* encode(uint8_t *buffer) {
        if (_size == 1) {
            *buffer = _class | _form | _tag;
        } else {
            *buffer = _class | _form | 0x1F;
            Base::encode7bits(_tag, buffer, _size - 1);
        }
        return buffer + _size;
    }
 
    uint8_t* decode(uint8_t *buffer) {
        _type = *buffer++;
        _class = _type & 0xC0;
        _form = _type & 0x20;
        _tag = _type & 0x1F;
        if ((_tag & 0x1F) == 0x1F) {
            _tag = 0;
            do {
                _type <<= 8;
                _type |= *buffer++;
                _tag <<= 7;
                _tag |= _type & 0x7F;
            } while (_type & 0x80);
        }
        return buffer;
    }
#endif
 
    operator unsigned int() const {
        return _type;
    }
 
    const uint8_t getClass() const {
        return _class;
    }
 
    const uint8_t getForm() const {
        return _form;
    }
 
    const unsigned int getTag() const {
        return _tag;
    }
 
private:
    uint8_t _class;
    uint8_t _form;
    unsigned int _tag;
    unsigned int _type;
 
    void setType(unsigned int type) {
        _size = 1;
        _type = type;
        while (type >>= 8) {
            ++_size;
        }
        type = _type;
        if (_size == 1) {
            _tag = type & 0x1F;
        } else {
            _tag = 0;
            for (uint8_t index = 0; index < _size - 1; ++index) {
                _tag <<= 7;
                _tag |= type & 0x7F;
                type >>= 8;
            }
        }
        _class = type & 0xC0;
        _form = type & 0x20;
    }
 
    void setFlagTag(uint8_t flag, unsigned int tag) {
        _size = 1;
        _class = flag & 0xC0;
        _form = flag & 0x20;
        _tag = tag;
        if (tag < 0x1F) {
            _type = _class | _form | _tag;
        } else {
            _type = _class | _form | 0x1F;
            do {
                ++_size;
            } while (tag >>= 7);
            tag = _tag;
            for (int32_t index = _size - 2; index > -1; --index) {
                _type <<= 8;
                _type |= tag >> (index << 3) & 0x7F;
                _type |= index ? 0x80 : 0x00;
            }
        }
    }
};
 
class Length: public Base {
public:
    Length(unsigned int length = 0) :
            Base() {
        setLength(length);
    }
 
#if SNMP_STREAM
    void encode(Stream &stream) {
        if (_length > 0x7F) {
            stream.write(0x80 | _size);
            unsigned int length = _length;
            for (uint8_t index = 0; index < _size; ++index) {
                stream.write(length >> ((_size - index - 1) << 3));
            }
        } else {
            stream.write(_length);
        }
    }
 
    void decode(Stream &stream) {
        _length = stream.read();
        if (_length & 0x80) {
            _size = _length & 0x7F;
            _length = 0;
            for (uint8_t index = 0; index < _size; ++index) {
                _length <<= 8;
                _length += stream.read();
            }
            _size++;
        } else {
            _size = 1;
        }
    }
#else
    uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = buffer;
        if (_length > 0x7F) {
            *pointer = 0x80 | _size;
            pointer += _size;
            unsigned int value = _length;
            for (uint8_t index = 0; index < _size; ++index) {
                *pointer-- = value;
                value >>= 8;
            }
        } else {
            *pointer++ = _length;
        }
        return buffer + _size;
    }
 
    uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = buffer;
        _length = *pointer++;
        if (_length & 0x80) {
            _size = _length & 0x7F;
            _length = 0;
            for (uint8_t index = 0; index < _size; ++index) {
                _length <<= 8;
                _length += *pointer++;
            }
        }
        return pointer;
    }
#endif
 
    operator unsigned int() const {
        return _length;
    }
 
    Length& operator=(const unsigned int length) {
        setLength(length);
        return *this;
    }
 
    Length& operator+=(const unsigned int length) {
        setLength(_length + length);
        return *this;
    }
 
    Length& operator-=(const unsigned int length) {
        setLength(_length - length);
        return *this;
    }
 
    Length& operator ++() {
        setLength(++_length);
        return *this;
    }
 
    Length operator ++(int) {
        Length length = *this;
        operator++();
        return length;
    }
 
private:
    unsigned int _length;
 
    void setLength(unsigned int length) {
        _size = 1;
        _length = length;
        if (length > 0x7F) {
            do {
                length >>= 8;
                _size++;
            } while (length);
        }
    }
};
 
class BER: public Base {
public:
    BER(const unsigned int type) :
            Base() {
        _type = Type(type);
        _length = Length(0);
    }
 
    virtual ~BER() {
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        _type.encode(stream);
        _length.encode(stream);
    }
 
    template<typename T>
    void encodeNumeric(T value, Stream &stream) {
        BER::encode(stream);
        for (uint8_t index = 0; index < _length; ++index) {
            stream.write(value >> ((_length - index - 1) << 3));
        }
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        if ((flag & Flag::Typed) == Flag::None) {
            _type.decode(stream);
        }
        _length.decode(stream);
    }
 
    template<typename T>
    void decodeNumeric(T *value, Stream &stream, const uint8_t flag = Flag::None) {
        BER::decode(stream, flag);
        if (T() - 1 < 0) {
            *value = stream.peek() & 0x80 ? 0xFFFFFFFF : 0;
        } else {
            *value = 0;
        }
        for (uint8_t index = 0; index < _length; ++index) {
            *value <<= 8;
            *value |= static_cast<uint8_t>(stream.read());
        }
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = _type.encode(buffer);
        pointer = _length.encode(pointer);
        return pointer;
    }
 
    template<typename T>
    uint8_t* encodeNumeric(T value, uint8_t *buffer) {
        uint8_t *pointer = BER::encode(buffer);
        for (uint8_t index = 0; index < _length; ++index) {
            *pointer++ = value >> ((_length - index - 1) << 3);
        }
        return pointer;
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = _type.decode(buffer);
        pointer = _length.decode(pointer);
        return pointer;
    }
 
    template<typename T>
    uint8_t* decodeNumeric(T *value, uint8_t *buffer, const uint8_t flag =
            Flag::None) {
        uint8_t *pointer = BER::decode(buffer);
        if (T() - 1 < 0) {
            *value = *pointer & 0x80 ? 0xFFFFFFFF : 0;
        } else {
            *value = 0;
        }
        for (unsigned int index = 0; index < _length; ++index) {
            *value <<= 8;
            *value |= static_cast<uint8_t>(*pointer++);
        }
        return pointer;
    }
#endif
 
    template<typename T>
    void setNegative(T value) {
        unsigned int length = sizeof(T);
        for (; length > 1; --length) {
            uint16_t word = value >> ((length - 2) << 3);
            if ((word & 0xFF80) != 0xFF80) {
                break;
            }
        }
        _length = length;
    }
 
    template<typename T>
    void setPositive(T value) {
        unsigned int length = 0;
        uint8_t carry = 0;
        do {
            carry = value & 0x80;
            value >>= 8;
            length++;
        } while (value | carry);
        _length = length;
    }
 
    const unsigned int getType() const {
        return _type;
    }
 
    const unsigned int getLength() const {
        return _length;
    }
 
    virtual const unsigned int getSize(const bool refresh = false) {
        _size = _type._size + _length._size + _length;
        return _size;
    }
 
protected:
    Length _length;
    Type _type;
 
    BER* create(const Type &type);
};
 
class BooleanBER: public BER {
public:
    BooleanBER(const bool value) :
            BER(Type::Boolean) {
        _length = LENGTH;
        _value = value;
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encode(stream);
        stream.write(_value ? 0xFF : 0x00);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decode(stream, flag);
        _value = stream.read();
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = BER::encode(buffer);
        *pointer = _value ? 0xFF : 0x00;
        return buffer + SIZE;
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = BER::decode(buffer);
        _value = *pointer++;
        return buffer + SIZE;
    }
#endif
 
    const bool getValue() const {
        return _value;
    }
 
    void setValue(const bool value) {
        _value = value;
    }
 
private:
    static constexpr uint8_t LENGTH = 1;
    static constexpr uint8_t SIZE = 3;
    bool _value;
};
 
class IntegerBER: public BER {
public:
    IntegerBER(const int32_t value) :
            BER(Type::Integer) {
        setValue(value);
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encodeNumeric<int32_t>(_value, stream);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decodeNumeric<int32_t>(&_value, stream, flag);
    }
 
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        return BER::encodeNumeric<int32_t>(_value, buffer);
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        return BER::decodeNumeric<int32_t>(&_value, buffer);
    }
#endif
 
    const int32_t getValue() const {
        return _value;
    }
 
    void setValue(const int32_t value) {
        _value = value;
        if (_value < 0) {
            BER::setNegative(value);
        } else {
            BER::setPositive(value);
        }
    }
 
private:
    int32_t _value;
};
 
class OctetStringBER: public BER {
public:
    OctetStringBER(const char *value) :
            OctetStringBER(value, strlen(value)) {
    }
 
    OctetStringBER(const char *value, const uint32_t length);
 
    virtual ~OctetStringBER() {
        free(_value);
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encode(stream);
        stream.write(_value, _length);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decode(stream, flag);
        allocate();
        stream.readBytes(_value, _length);
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = BER::encode(buffer);
        memcpy(pointer, _value, _length);
        return pointer + _length;
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = BER::decode(buffer);
        setValue(reinterpret_cast<const char*>(pointer), _length);
        return pointer + _length;
    }
#endif
 
    const char* getValue() const {
        return _value;
    }
 
    void setValue(const char *value, const unsigned int length) {
        _length = length;
        allocate();
        memcpy(_value, value, length);
    }
 
    const bool getBit(const unsigned int index) const {
        const unsigned int byte = index / 8;
        const uint8_t bit = index % 8;
        return _value[byte] & (0x80 >> bit);
    }
 
protected:
    char *_value;
 
    OctetStringBER(const uint8_t type = Type::OctetString) :
            BER(type) {
        _value = nullptr;
    }
 
    void allocate() {
        free(_value);
        _value = static_cast<char*>(malloc(_length + 1));
        _value[_length] = 0;
    }
};
 
class NullBER: public BER {
public:
    NullBER(const uint8_t type = Type::Null) :
            BER(type) {
    }
};
 
class ObjectIdentifierBER: public BER {
public:
    ObjectIdentifierBER(const char *value) :
            BER(Type::ObjectIdentifier) {
        setValue(value);
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        unsigned int index = 0;
        uint32_t subidentifier = 0;
        BER::encode(stream);
        char *token = const_cast<char*>(_value.c_str());
        while (token != NULL) {
            switch (index) {
            case 0:
                subidentifier = atoi(token);
                break;
            case 1:
                subidentifier = subidentifier * 40 + atoi(++token);
                stream.write(subidentifier);
                _size++;
                break;
                ;
            default: {
                subidentifier = atol(++token);
                uint32_t value = subidentifier;
                uint32_t length = 0;
                do {
                    value >>= 7;
                    length++;
                } while (value);
                Base::encode7bits(subidentifier, stream, length);
                _size += length;
            }
                break;
            }
            token = strchr(token, '.');
            index++;
        }
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        unsigned int index = 0;
        uint32_t subidentifier = 0;
        BER::decode(stream, flag);
        unsigned int length = _length;
        _size += length;
        while (length) {
            if (index++) {
                subidentifier = 0;
                uint8_t byte;
                do {
                    length--;
                    byte = stream.read();
                    subidentifier <<= 7;
                    subidentifier += byte & 0x7F;
                } while (byte & 0x80);
                _value += "." + String(subidentifier);
            } else {
                length--;
                subidentifier = stream.read();
                _value = String(subidentifier / 40) + "." + String(subidentifier % 40);
            }
        }
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        unsigned int index = 0;
        uint32_t subidentifier = 0;
        uint8_t *pointer = BER::encode(buffer);
        char *token = const_cast<char*>(_value.c_str());
        while (token != NULL) {
            switch (index) {
            case 0:
                subidentifier = atoi(token);
                break;
            case 1:
                subidentifier = subidentifier * 40 + atoi(++token);
                *pointer = subidentifier;
                break;
                ;
            default: {
                subidentifier = atol(++token);
                uint32_t value = subidentifier;
                uint32_t length = 0;
                do {
                    value >>= 7;
                    length++;
                } while (value);
                Base::encode7bits(subidentifier, pointer, length);
                pointer += length;
            }
                break;
            }
            token = strchr(token, '.');
            index++;
        }
        return ++pointer;
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        unsigned int index = 0;
        uint32_t subidentifier = 0;
        uint8_t *pointer = BER::decode(buffer);
        uint8_t *end = pointer + _length;
        do {
            if (index++) {
                subidentifier = 0;
                do {
                    subidentifier <<= 7;
                    subidentifier += *pointer & 0x7F;
                } while (*pointer++ & 0x80);
                _value += "." + String(subidentifier);
            } else {
                subidentifier = *pointer++;
                _value = String(subidentifier / 40) + "."
                        + String(subidentifier % 40);
            }
        } while (pointer < end);
        return pointer;
    }
#endif
 
    const char* getValue() const {
        return _value.c_str();
    }
 
    void setValue(const char *value) {
        _value = value;
        unsigned int index = 0;
        uint32_t subidentifier = 0;
        char *token = const_cast<char*>(_value.c_str());
        while (token != NULL) {
            switch (index) {
            case 0:
                subidentifier = atoi(token);
                break;
            case 1:
                subidentifier = subidentifier * 40 + atoi(++token);
                _length++;
                break;
            default: {
                subidentifier = atol(++token);
                do {
                    subidentifier >>= 7;
                    _length++;
                } while (subidentifier);
            }
                break;
            }
            token = strchr(token, '.');
            index++;
        }
    }
 
private:
    String _value;
};
 
template<const uint8_t U>
class ArrayBER: public BER {
public:
    ArrayBER(const uint8_t type) :
            BER(type) {
    }
 
    ~ArrayBER() {
#if SNMP_VECTOR
        for (auto ber : _bers) {
            delete ber;
        }
        _bers.clear();
#else
        for (uint8_t index = 0; index < _count; ++index) {
            delete _bers[index];
        }
#endif
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encode(stream);
        for (uint8_t index = 0; index < _count; ++index) {
            _bers[index]->encode(stream);
        }
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decode(stream, flag);
        unsigned int length = _length;
        if (length) {
            Type type;
            _length = 0;
            do {
                type.decode(stream);
                BER *ber = create(type);
                if (ber) {
                    ber->decode(stream, Flag::Typed);
                    length -= ber->getSize();
                    add(ber);
                }
            } while (length);
        }
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = BER::encode(buffer);
#if SNMP_VECTOR
        for (auto ber : _bers) {
            pointer = ber->encode(pointer);
        }
#else
        for (uint8_t index = 0; index < _count; ++index) {
            pointer = _bers[index]->encode(pointer);
        }
#endif
        return pointer;
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = BER::decode(buffer);
        if (_length) {
            uint8_t *end = pointer + _length;
            _length = 0;
            Type type;
            do {
                type.decode(pointer);
                BER *ber = create(type);
                if (ber) {
                    pointer = ber->decode(pointer);
                    add(ber);
                }
            } while (pointer < end);
        }
        return pointer;
    }
#endif
 
    virtual const unsigned int getSize(const bool refresh = false) {
        if (refresh) {
            _length = 0;
            for (uint8_t index = 0; index < _count; ++index) {
                _length += _bers[index]->getSize(true);
            }
        }
        return BER::getSize();
    }
 
    BER* operator [](const unsigned int index) {
        return _bers[index];
    }
 
    const uint8_t count() const {
        return _count;
    }
 
protected:
    BER* add(BER *ber) {
#if SNMP_VECTOR
        _bers.push_back(ber);
        _length += ber->getSize();
        _count++;
#else
        if (_count < U) {
            _bers[_count++] = ber;
            _length += ber->getSize();
        }
#endif
        return ber;
    }
 
    void remove() {
#if SNMP_VECTOR
        if (_bers.size()) {
            _length -= _bers.back()->getSize();
            _bers.pop_back();
            --_count;
        }
#else
        if (_count) {
            _length -= _bers[--_count]->getSize();
        }
#endif
    }
 
private:
    uint8_t _count = 0;
#if SNMP_VECTOR
    std::vector<BER*> _bers;
#else
    BER *_bers[U];
#endif
 
    friend class Message;
    friend class VarBind;
    friend class VarBindList;
};
 
class SequenceBER: public ArrayBER<SNMP_CAPACITY> {
public:
    SequenceBER(const uint8_t type = Type::Sequence) :
            ArrayBER(type) {
    }
};
 
class VarBind: public ArrayBER<2> {
public:
    VarBind(const char *oid, BER *value = nullptr) :
            ArrayBER(Type::Sequence) {
        add(new ObjectIdentifierBER(oid));
        if (value) {
            add(value);
        } else {
            add(new NullBER);
        }
    }
 
    const char* getName() const {
        return static_cast<ObjectIdentifierBER*>(_bers[0])->getValue();
    }
 
    BER* getValue() const {
        return _bers[1];
    }
};
 
class VarBindList: public SequenceBER {
public:
    VarBind* operator [](const uint32_t index) {
        return static_cast<VarBind*>(_bers[index]);
    }
};
 
class IPAddressBER: public OctetStringBER {
public:
    IPAddressBER(IPAddress value) :
            OctetStringBER(Type::IPAddress) {
        _length = LENGTH;
        allocate();
        for (uint8_t index = 0; index < LENGTH; ++index) {
            _value[index] = value[index];
        }
    }
 
    const uint8_t* getValue() {
        return reinterpret_cast<uint8_t*>(_value);
    }
 
private:
    static constexpr uint8_t LENGTH = 4;
};
 
template<class T>
class UIntegerBER: public BER {
protected:
    UIntegerBER(const T value, const uint8_t type) :
            BER(type) {
        setValue(value);
    }
 
public:
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encodeNumeric<T>(_value, stream);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decodeNumeric<T>(&_value, stream, flag);
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        return BER::encodeNumeric<T>(_value, buffer);
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        return BER::decodeNumeric<T>(&_value, buffer);
    }
#endif
 
    const T getValue() const {
        return _value;
    }
 
    void setValue(const T value) {
        _value = value;
        BER::setPositive<T>(value);
    }
 
private:
    T _value;
};
 
class Counter32BER: public UIntegerBER<uint32_t> {
public:
    Counter32BER(const uint32_t value) :
            UIntegerBER(value, Type::Counter32) {
    }
};
 
class Counter64BER: public UIntegerBER<uint64_t> {
public:
    Counter64BER(const uint64_t value) :
            UIntegerBER(value, Type::Counter64) {
    }
};
 
class Gauge32BER: public UIntegerBER<uint32_t> {
public:
    Gauge32BER(const uint32_t value) :
            UIntegerBER(value, Type::Gauge32) {
    }
};
 
class TimeTicksBER: public UIntegerBER<uint32_t> {
public:
    TimeTicksBER(const uint32_t value) :
            UIntegerBER(value, Type::TimeTicks) {
    }
};
 
class OpaqueBER: public BER {
public:
    OpaqueBER(BER *ber);
 
    virtual ~OpaqueBER() {
        delete _ber;
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encode(stream);
        _ber->encode(stream);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decode(stream, flag);
        uint32_t length = _length;
        if (length) {
            Type type;
            do {
                type.decode(stream);
                _ber = create(type);
                if (_ber) {
                    _ber->decode(stream, Flag::Typed);
                    length -= _ber->getSize();
                }
            } while (length);
        }
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        uint8_t *pointer = BER::encode(buffer);
        return _ber->encode(pointer);
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        uint8_t *pointer = BER::decode(buffer);
        uint8_t *end = pointer + _length;
        if (_length) {
            Type type;
            do {
                type.decode(pointer);
                _ber = create(type);
                if (_ber) {
                    pointer = _ber->decode(pointer);
                }
            } while (pointer < end);
        }
        return pointer;
    }
#endif
 
    virtual const unsigned int getSize(const bool refresh = false) {
        if (refresh) {
            _length = _ber->getSize(true);
        }
        return BER::getSize();
    }
 
    BER* getBER() {
        return _ber;
    }
 
private:
    BER *_ber;
};
 
class FloatBER: public BER {
public:
    FloatBER(const float value, const unsigned int type = Type::Float) :
            BER(type) {
        _length = LENGTH;
        setValue(value);
    }
 
#if SNMP_STREAM
    virtual void encode(Stream &stream) {
        BER::encodeNumeric<uint32_t>(*(reinterpret_cast<uint32_t*>(&_value)), stream);
    }
 
    virtual void decode(Stream &stream, const uint8_t flag = Flag::None) {
        BER::decodeNumeric<uint32_t>(reinterpret_cast<uint32_t*>(&_value), stream, flag);
    }
#else
    virtual uint8_t* encode(uint8_t *buffer) {
        return BER::encodeNumeric<uint32_t>(
                *(reinterpret_cast<uint32_t*>(&_value)), buffer);
    }
 
    virtual uint8_t* decode(uint8_t *buffer) {
        return BER::decodeNumeric<uint32_t>(
                reinterpret_cast<uint32_t*>(&_value), buffer);
    }
#endif
 
    const float getValue() const {
        return _value;
    }
 
    void setValue(const float value) {
        _value = value;
    }
 
protected:
    static constexpr uint8_t LENGTH = 4;
    float _value;
};
 
class NoSuchObjectBER: public NullBER {
public:
    NoSuchObjectBER() :
            NullBER(Type::NoSuchObject) {
    }
};
 
class NoSuchInstanceBER: public NullBER {
public:
    NoSuchInstanceBER() :
            NullBER(Type::NoSuchInstance) {
    }
};
 
class EndOfMIBViewBER: public NullBER {
public:
    EndOfMIBViewBER() :
            NullBER(Type::EndOfMIBView) {
    }
};
 
class OpaqueFloatBER: public FloatBER {
public:
    OpaqueFloatBER(const float value) :
            FloatBER(value, Type::OpaqueFloat) {
    }
};
 
}  // namespace SNMP
 
#endif /* BER_H_ */