usm.hpp

#pragma once

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

#include <string>
#include <chrono>

namespace dangerous { namespace snmp { namespace securitymodel {

class USM : public SecurityModel {
public:
    USM();

    USM( const std::string& username, Authentication::Type authentication, const std::string& authenticationPassword, Encryption::Type encryption, const std::string& encryptionPassword ) throw( Exception );
    
    USM( const USM& usm );

public:
    std::string authoritativeEngineID() const { return _authoritativeEngineID; }

    void authoritativeEngineID( const std::string& authoritativeEngineID );

    uint32_t authoritativeEngineBoots() const { return _authoritativeEngineBoots; }

    void authoritativeEngineBoots( uint32_t authoritativeEngineBoots ) { _authoritativeEngineBoots = authoritativeEngineBoots; }
    
    std::chrono::seconds authoritativeEngineTime() const { return _authoritativeEngineTime; }

    void authoritativeEngineTime( std::chrono::seconds authoritativeEngineTime ) {
        _authoritativeEngineTime = authoritativeEngineTime;
        lastUpdateTime = std::chrono::system_clock::now();
    }

    bool isAuthenticated() const;

public:
    void updateTimeFromClock() {
        std::chrono::seconds changeInTime = std::chrono::duration_cast<std::chrono::seconds>( std::chrono::system_clock::now() - lastUpdateTime );
        // TODO: Check for negative result?

        // Update the engine time.
        authoritativeEngineTime( _authoritativeEngineTime + changeInTime );
    }

public:
    std::string username() const { return _username; };
    
    Authentication::Type authentication() const { return _authentication; };
    
    std::string authenticationPassword() const { return _authenticationPassword; };
    
    std::string authenticationKey() const { return _authenticationKey; };
    
    Encryption::Type encryption() const { return _encryption; };
    
    std::string encryptionPassword() const { return _encryptionPassword; }
    
    std::string encryptionKey() const { return _encryptionKey; }

protected:
    /*
     * These parameters are generally given as input; they must
     * be known in advance.
     */

    std::string _username;
    
    Authentication::Type _authentication;
    
    std::string _authenticationPassword;

    std::string _authenticationKey;

    Encryption::Type _encryption;
    
    std::string _encryptionPassword;

    std::string _encryptionKey;

protected:
    /*
     * These parameters are "discoverable"; they pertain to the target
     * and do not need to be known in advance.  However, they can be.
     */

    std::string _authoritativeEngineID;

    uint32_t _authoritativeEngineBoots;

    std::chrono::seconds _authoritativeEngineTime;

protected:
    /*
     * This is for internal use only.
     */

    std::chrono::system_clock::time_point lastUpdateTime;
};

} } }