SNMPMessage.h

Go to the documentation of this file.

#ifndef SNMPMESSAGE_H_
#define SNMPMESSAGE_H_
 
#include "BER.h"
 
namespace SNMP {
 
class PDU {
private:
    struct Generic {
        struct Bulk {
            uint8_t _nonRepeaters;
            uint8_t _maxRepetitions;
        };
 
        Generic() :
                _error() {
            _requestID = rand();
        }
 
        uint32_t _requestID;
 
        union {
            Error _error;
            Bulk _bulk;
        };
    };
public:
    PDU() :
            _generic() {
    }
 
    ~PDU() {
    }
 
    union {
        Generic _generic;
        Trap _trap;
    };
};
 
class Message: public SequenceBER, private PDU {
public:
    class OID {
    public:
        static constexpr char *COLDSTART = "1.3.6.1.6.3.1.1.5.1";
        static constexpr char *WARMSTART = "1.3.6.1.6.3.1.1.5.2";
        static constexpr char *LINKDOWN = "1.3.6.1.6.3.1.1.5.3";
        static constexpr char *LINKUP = "1.3.6.1.6.3.1.1.5.4";
        static constexpr char *AUTHENTICATIONFAILURE = "1.3.6.1.6.3.1.1.5.5";
 
    private:
        static constexpr char *SYSUPTIME = "1.3.6.1.2.1.1.3.0";
        static constexpr char *SNMPTRAPOID = "1.3.6.1.6.3.1.1.4.1.0";
        static constexpr char *SNMPTRAPENTERPRISE = "1.3.6.1.6.3.1.1.4.3.0";
 
        friend class Message;
    };
 
    Message(const uint8_t version = Version::V1, const char *community = nullptr,
            const uint8_t type = Type::GetRequest) :
            SequenceBER(), PDU() {
        _version = version;
        _community = community;
        _type = type;
        _varBindList = new VarBindList();
    }
 
    virtual ~Message() {
        delete _varBindList;
    }
 
    virtual const unsigned int getSize(const bool refresh = false) {
        build();
        return ArrayBER::getSize(refresh);
    }
 
    VarBind* add(const char *oid, BER *value = nullptr) {
        return static_cast<VarBind*>(_varBindList->add(new VarBind(oid, value)));
    }
 
    const uint8_t getVersion() const {
        return _version;
    }
 
    const char* getCommunity() const {
        return _community;
    }
 
    const uint8_t getType() const {
        return _type;
    }
 
    const int32_t getRequestID() const {
        return _generic._requestID;
    }
 
    void setRequestID(const int32_t requestId) {
        _generic._requestID = requestId;
    }
 
    const uint8_t getErrorStatus() const {
        return _generic._error._status;
    }
 
    const uint8_t getErrorIndex() const {
        return _generic._error._index;
    }
 
    void setError(const uint8_t status, const uint8_t index) {
        _generic._error._status = mapErrorStatus(status);
        _generic._error._index = index;
    }
 
    const uint8_t getNonRepeaters() const {
        return _generic._bulk._nonRepeaters;
    }
 
    void setNonRepeaters(const uint8_t nonRepeaters) {
        _generic._bulk._nonRepeaters = nonRepeaters;
    }
 
    const uint8_t getMaxRepetition() const {
        return _generic._bulk._maxRepetitions;
    }
 
    void setMaxRepetitions(const uint8_t maxRepetitions) {
        _generic._bulk._maxRepetitions = maxRepetitions;
    }
 
    void setEnterprise(const char *enterprise) {
        _trap._enterprise = enterprise;
    }
 
    void setAgentAddress(IPAddress agentAddr) {
        _trap._agentAddr = agentAddr;
    }
 
    void setTrap(const uint8_t generic, const uint8_t specific = 0) {
        _trap._genericTrap = generic;
        _trap._specificTrap = specific;
    }
 
    void setSNMPTrapOID(const char *name) {
//        add(OID::SYSUPTIME, new TimeTicksBER(0));
        add(OID::SYSUPTIME, new TimeTicksBER(millis() / 10));
        add(OID::SNMPTRAPOID, new ObjectIdentifierBER(name));
    }
 
    VarBindList* getVarBindList() const {
        return _varBindList;
    }
 
private:
    void build() {
        SequenceBER *pdu = new SequenceBER(_type);
        switch (_type) {
        case Type::Trap:
            pdu->add(new ObjectIdentifierBER(_trap._enterprise));
            pdu->add(new IPAddressBER(_trap._agentAddr));
            pdu->add(new IntegerBER(_trap._genericTrap));
            pdu->add(new IntegerBER(_trap._specificTrap));
            pdu->add(new TimeTicksBER(millis() / 10));
            break;
        case Type::GetBulkRequest:
            pdu->add(new IntegerBER(_generic._requestID));
            pdu->add(new IntegerBER(_generic._bulk._nonRepeaters));
            pdu->add(new IntegerBER(_generic._bulk._maxRepetitions));
            break;
        default:
            pdu->add(new IntegerBER(_generic._requestID));
            pdu->add(new IntegerBER(_generic._error._status));
            pdu->add(new IntegerBER(_generic._error._index));
//            if ((_type == Type::SNMPv2Trap) || (_type == Type::InformRequest)) {
//                // TODO Is it really useful?
//                static_cast<TimeTicksBER*>((*_varBindList)[0]->getValue())->setValue(
//                        millis() / 10);
//                // Refresh size
//                _varBindList->getSize(true);
//            }
            break;
        }
        pdu->add(_varBindList);
        ArrayBER::add(new IntegerBER(_version));
        ArrayBER::add(new OctetStringBER(_community, strlen(_community)));
        ArrayBER::add(pdu);
        _varBindList = nullptr;
    }
 
    void parse() {
        _version = static_cast<IntegerBER*>(operator [](0))->getValue();
        _community = static_cast<OctetStringBER*>(operator [](1))->getValue();
        SequenceBER *pdu = static_cast<SequenceBER*>(operator [](2));
        _type = pdu->getType();
        switch (_type) {
        case Type::Trap:
            _trap._enterprise = static_cast<ObjectIdentifierBER*>((*pdu)[0])->getValue();
            _trap._agentAddr = static_cast<IPAddressBER*>((*pdu)[1])->getValue();
            _trap._genericTrap = static_cast<IntegerBER*>((*pdu)[2])->getValue();
            _trap._specificTrap = static_cast<IntegerBER*>((*pdu)[3])->getValue();
            _trap._timeStamp = static_cast<TimeTicksBER*>((*pdu)[4])->getValue();
            break;
        case Type::GetBulkRequest:
            _generic._requestID = static_cast<IntegerBER*>((*pdu)[0])->getValue();
            _generic._bulk._nonRepeaters = static_cast<IntegerBER*>((*pdu)[1])->getValue();
            _generic._bulk._maxRepetitions = static_cast<IntegerBER*>((*pdu)[2])->getValue();
            break;
        default:
            _generic._requestID = static_cast<IntegerBER*>((*pdu)[0])->getValue();
            _generic._error._status = static_cast<IntegerBER*>((*pdu)[1])->getValue();
            _generic._error._index = static_cast<IntegerBER*>((*pdu)[2])->getValue();
            break;
        }
        // Branch variable bind list
        delete _varBindList;
        _varBindList = static_cast<VarBindList*>((*pdu)[_type == Type::Trap ? 5 : 3]);
        pdu->remove();
    }
#if SNMP_STREAM
    void build(Stream &stream) {
        build();
        encode(stream);
    }
 
    void parse(Stream &stream) {
        decode(stream);
        parse();
    }
#else
    void build(uint8_t *buffer) {
        encode(buffer);
    }
 
    void parse(uint8_t *buffer) {
        decode(buffer);
        parse();
    }
#endif
 
    const uint8_t mapErrorStatus(const uint8_t status) const {
        if (_version == Version::V1) {
            // RFC 2089 2.1 Mapping SNMPv2 error-status into SNMPv1 error-status
            switch (status) {
            case Error::WrongValue:
            case Error::WrongEncoding:
            case Error::WrongType:
            case Error::WrongLength:
            case Error::InconsistentValue:
                return Error::BadValue;
            case Error::NoAccess:
            case Error::NotWritable:
            case Error::NoCreation:
            case Error::InconsistentName:
            case Error::AuthorizationError:
                return Error::NoSuchName;
            case Error::ResourceUnavailable:
            case Error::CommitFailed:
            case Error::UndoFailed:
                return Error::GenErr;
            }
        }
        return status;
    }
 
    uint8_t _version;
    const char *_community;
    uint8_t _type;
    VarBindList *_varBindList;
 
    friend class SNMP;
};
 
} // namespace SNMP
 
#endif /* SNMPMESSAGE_H_ */