message-v3.hpp

#pragma once

#include <string>
#include <vector>

namespace dangerous { namespace snmp { namespace encoding {

class SNMPv3MessageFlags {
public:
    static constexpr const char AUTHENTICATION = (char)0b00000001;
    static constexpr const char ENCRYPTION = (char)0b00000010;
    static constexpr const char REPORTABLE = (char)0b00000100;
};

class SNMPv3Message {
public:
    int msgVersion;

    class HeaderData {
    public:
        int msgID;
        int msgMaxSize;
        std::string msgFlags;
        int msgSecurityModel;
    } msgHeaderData;

    std::string msgSecurityParameters;

    std::vector<char> pduBytes;
};

class SNMPV3MESSAGE_HEADERDATA {
public:
    static constexpr const char* NAME = "SNMPv3Message.HeaderData";
    static const int TYPE = asn1::helper::SEQUENCE::TYPE;
    typedef typename SNMPv3Message::HeaderData value_type;

    static unsigned int length( const value_type& headerData ) {
        unsigned int size = 0;
        
        size += asn1::encodedSize<encoding::INTEGER>( headerData.msgID );
        
        size += asn1::encodedSize<encoding::INTEGER>( headerData.msgMaxSize );

        size += asn1::encodedSize<encoding::OCTET_STRING>( headerData.msgFlags );
        
        size += asn1::encodedSize<encoding::INTEGER>( headerData.msgSecurityModel );
        
        return size;
    }

    static bool write( const value_type& headerData, char* buffer, unsigned int bufferSize ) {
        ByteStream byteStream;
        byteStream.linkFrom( buffer, bufferSize, ByteStream::READ_WRITE );

        BerStream berStream( &byteStream );

        bool success = true;

        success = berStream.write<encoding::INTEGER>( headerData.msgID );
        if( ! success ) {
            return false;
        }

        success = berStream.write<encoding::INTEGER>( headerData.msgMaxSize );
        if( ! success ) {
            return false;
        }

        success = berStream.write<encoding::OCTET_STRING>( headerData.msgFlags );
        if( ! success ) {
            return false;
        }

        success = berStream.write<encoding::INTEGER>( headerData.msgSecurityModel );
        if( ! success ) {
            return false;
        }

        return true;
    }

    static bool read( value_type& headerData, char* buffer, unsigned int bufferSize ) {
        ByteStream byteStream;
        byteStream.linkFrom( buffer, bufferSize, ByteStream::READ_ONLY );
        
        BerStream berStream( &byteStream );

        bool success = true;

        success = berStream.read<encoding::INTEGER>( headerData.msgID );
        if( ! success ) {
            return false;
        }

        success = berStream.read<encoding::INTEGER>( headerData.msgMaxSize );
        if( ! success ) {
            return false;
        }

        success = berStream.read<encoding::OCTET_STRING>( headerData.msgFlags );
        if( ! success ) {
            return false;
        }

        success = berStream.read<encoding::INTEGER>( headerData.msgSecurityModel );
        if( ! success ) {
            return false;
        }

        return true;
    }
};

class SNMPV3MESSAGE {
public:
    static constexpr const char* NAME = "SNMPv3Message";
    static const int TYPE = asn1::helper::SEQUENCE::TYPE;
    typedef SNMPv3Message value_type;

    static unsigned int length( const value_type& message ) {
        unsigned int size = 0;
        // The header will require any space necessary to store the version.
        size += asn1::encodedSize<encoding::INTEGER>( message.msgVersion );

        size += asn1::encodedSize<SNMPV3MESSAGE_HEADERDATA>( message.msgHeaderData );

        // The header will require any space necessary to store the community string.
        size += asn1::encodedSize<encoding::OCTET_STRING>( message.msgSecurityParameters );
        
        // Then, we're just going to dump our PDU data in.
        size += message.pduBytes.size();

        return size;
    }

    static bool write( const value_type& message, char* buffer, unsigned int bufferSize ) {
        ByteStream byteStream;
        byteStream.linkFrom( buffer, bufferSize, ByteStream::READ_WRITE );
        
        BerStream berStream( &byteStream );

        bool success = true;

        success = berStream.write<encoding::INTEGER>( message.msgVersion );
        if( ! success ) {
            return false;
        }

        success = berStream.write<SNMPV3MESSAGE_HEADERDATA>( message.msgHeaderData );
        if( ! success ) {
            return false;
        }

        success = berStream.write<encoding::OCTET_STRING>( message.msgSecurityParameters );
        if( ! success ) {
            return false;
        }

        unsigned int bytesWritten = 0;
        success = berStream.writeBytes( message.pduBytes.data(), message.pduBytes.size(), bytesWritten );
        if( ! success ) {
            return false;
        }

        return true;
    }

    static bool read( value_type& message, char* buffer, unsigned int bufferSize ) {
        ByteStream byteStream;
        byteStream.linkFrom( buffer, bufferSize, ByteStream::READ_ONLY );
        
        BerStream berStream( &byteStream );

        bool success = true;

        success = berStream.read<encoding::INTEGER>( message.msgVersion );
        if( ! success ) {
            return false;
        }

        success = berStream.read<SNMPV3MESSAGE_HEADERDATA>( message.msgHeaderData );
        if( ! success ) {
            return false;
        }

        success = berStream.read<encoding::OCTET_STRING>( message.msgSecurityParameters );
        if( ! success ) {
            return false;
        }

        berStream.copyTo( message.pduBytes );
        
        return true;
    }
};

} } }