agentx.hpp

#pragma once

#include "context.hpp"
#include "exception.hpp"
#include "numericoid.hpp"
#include "variant.hpp"

#include <condition_variable>
#include <map>
#include <mutex>
#include <string>
#include <thread>

namespace dangerous { namespace snmp {

class AgentxPacket;
class Transport;


class AgentX {
public:
    static const uint8_t DEFAULT_PRIORITY;

    class OidRegistrationEntry {
    public:
        typedef std::function<bool(const NumericOid& oid, Variant& value)> GetFunction;
        
        typedef std::function<bool(const NumericOid& oid, NumericOid& nextOid, Variant& value)> GetNextFunction;

        enum Type {
            OBJECT,
            INSTANCE,
            TREE
        };
    public:
        OidRegistrationEntry() : priority(0), type(OBJECT) {};

    public:
        uint8_t priority;

        Type type;

        GetFunction getFunction;
        
        GetNextFunction getNextFunction;
    };

public:
    AgentX( const Context& context );

    virtual ~AgentX();

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

    void identifier( const NumericOid& oid ) { _identifier = oid; }

    NumericOid identifier() const { return _identifier; }

    void description( const std::string& text ) { _description = text; }
    
    std::string description() const { return _description; }

    /*
     * Raw protocol operations.
     */

    void raw_addAgentCapabilities( const NumericOid& oid, const std::string& description );

    void raw_removeAgentCapabilities( const NumericOid& oid );
    
    void raw_registerTree( const NumericOid& oid, uint8_t priority = DEFAULT_PRIORITY );

    void raw_registerOid( const NumericOid& oid, uint8_t priority = DEFAULT_PRIORITY );


    /*
     * Logical protocol operations.
     */

    void addAgentCapabilities( const NumericOid& oid, const std::string& description ) throw( Exception );
    
    void removeAgentCapabilities( const NumericOid& oid ) throw( Exception );

    void registerOid( const NumericOid& oid, const OidRegistrationEntry& entry ) throw ( Exception );

    // TODO: registerSimpleOid( const NumericOid& oid, const Variant& value );
    // TODO: registerSimpleTree( const NumericOid& oid, OidRegistrationEntry::BeforeGetFunction beforeGetFunction );

protected:
    class ValueEntry {
    public:
        Variant value;

        uint32_t id;
    };


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

    NumericOid _identifier;
    std::string _description;

    std::unique_ptr<Transport> transport;

    uint32_t packetNumber;

    uint32_t sessionId;

    /*
     * Mailbox variables.
     */

    std::mutex readMutex;
    std::condition_variable readConditionVariable;

    std::mutex writeMutex;

    std::map< uint32_t, std::unique_ptr<AgentxPacket> > inbox;

    bool isStopped;
    std::thread mailboxThread;

    /*
     * Capabilities.
     */

    typedef std::map< NumericOid, std::string > CapabilityMap;

    CapabilityMap capabilityMap;

    /*
     * OID registration.
     */
    
    typedef std::map< NumericOid, OidRegistrationEntry > OidRegistrationMap;

    OidRegistrationMap oidRegistrationMap;

    OidRegistrationMap::const_iterator registrationThatCovers( const NumericOid& oid );
    
    void rawRead( AgentxPacket& packet );
    
    void rawWrite( AgentxPacket& packet );

    void open();
    
    void close();


    /*
     * Mailbox functions.
     */

    void startMailboxThread();

    void stopMailboxThread();

    void mailboxRead( AgentxPacket& packet, uint32_t packetId ) throw( Exception );

    void mailboxMain();
};

} }