client.hpp

#pragma once

#include <chrono>
#include <list>
#include <memory>
#include <string>
#include <stdexcept>

#include "context.hpp"
#include "exception.hpp"
#include "rawresponse.hpp"
#include "response.hpp"

#include "securitymodel.hpp"
#include "securitymodel/usm.hpp"
#include "types.hpp"

namespace dangerous { namespace snmp {

class ByteStream;
class MessageProcessor;
class Transport;


class Client {
public:
    Client( const Context& context );

    virtual ~Client();

    std::string uri() const;
    void uri( const std::string& uri ) throw( ParseErrorException, UnknownTransportException, Exception );

    std::chrono::milliseconds timeout() const { return _timeout; }
    void timeout( const std::chrono::milliseconds& timeout ) { _timeout = timeout; }

    void useVersion1( const std::string& communityString );
    
    void useVersion2c( const std::string& communityString );

    void useVersion3( const securitymodel::USM& securityModel );

    bool isAuthenticated();

    void authenticate();

    /*
     * Raw protocol operations.
     *
     * These can be used to speak strict SNMP without the extra "magic" that we
     * would otherwise do (such as retrying requests).
     *
     * All of these functions begin with "raw_".
     */
    
    std::unique_ptr<RawResponse> raw_get( PDU& requestPdu ) throw( Exception );

    std::unique_ptr<RawResponse> raw_getnext( PDU& requestPdu ) throw( Exception );

    std::unique_ptr<RawResponse> raw_getbulk( PDU& requestPdu ) throw( Exception );

    std::unique_ptr<RawResponse> raw_set( PDU& requestPdu ) throw( Exception );

    /*
     * Logical operations.
     *
     * These operations do what is usually _expected_ of SNMP; they may re-issue
     * a request, or they may break a PDU into multiple parts (for example), in
     * order to get the best results.
     */

    std::unique_ptr<Response> get( const std::list<NumericOid>& oidList ) throw( Exception );
    
    std::unique_ptr<Response> getNext( const std::list<NumericOid>& oidList );

    std::unique_ptr<Response> getBulk( const std::list<NumericOid>& singleRequestOids, unsigned int multipleRequestLimit, const std::list<NumericOid>& multipleRequestOids );
    
    std::unique_ptr<Response> set( const VarBindList& varbinds ) throw( Exception );

    std::unique_ptr<Response> walk( const NumericOid& oid, unsigned int limit = 0, const NumericOid& startingOid = NumericOid() );

protected:
    template<typename PduEncoder>
    void lowLevelSend( SecurityModel* outgoingSecurityModel, PDU& request ) throw( Exception );

    std::unique_ptr<ByteStream> lowLevelReceive( std::unique_ptr<SecurityModel>& incomingSecurityModel ) throw( Exception );

    template<typename PduEncoder>
    std::unique_ptr<RawResponse> basicRequest( PDU& request, SecurityModel* desiredSecurityModel = nullptr ) throw( Exception );

protected:
    std::weak_ptr<Context::PrivateData> context;

    std::unique_ptr<Transport> transport;

    std::unique_ptr<MessageProcessor> messageProcessor;

    std::unique_ptr<SecurityModel> securityModel;

    int32_t requestId;

    std::chrono::milliseconds _timeout;

    std::string _uri;
};

} }