snmp_textual_conventions.h

Go to the documentation of this file.

/*_############################################################################
  _## 
  _##  AGENT++ 4.0 - snmp_textual_conventions.h  
  _## 
  _##  Copyright (C) 2000-2013  Frank Fock and Jochen Katz (agentpp.com)
  _##  
  _##  Licensed under the Apache License, Version 2.0 (the "License");
  _##  you may not use this file except in compliance with the License.
  _##  You may obtain a copy of the License at
  _##  
  _##      http://www.apache.org/licenses/LICENSE-2.0
  _##  
  _##  Unless required by applicable law or agreed to in writing, software
  _##  distributed under the License is distributed on an "AS IS" BASIS,
  _##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  _##  See the License for the specific language governing permissions and
  _##  limitations under the License.
  _##  
  _##########################################################################*/


#ifndef _snmp_textual_convention_h_
#define _snmp_textual_convention_h_

#include <agent_pp/agent++.h>
#include <agent_pp/mib.h>

#define oidSnmpSetSerialNo "1.3.6.1.6.3.1.1.6.1.0"

#ifdef AGENTPP_NAMESPACE
namespace Agentpp {
#endif


const index_info iSnmpAdminString[1] = 
{ { sNMP_SYNTAX_OCTETS, TRUE, 1, 32 } };


/*---------------------- class snmpDisplayString ---------------------*/

class AGENTPP_DECL SnmpDisplayString: public MibLeaf {

 public:
        SnmpDisplayString(const Oidx&, mib_access, NS_SNMP OctetStr*);
        SnmpDisplayString(const Oidx&, mib_access, NS_SNMP OctetStr*, bool);
        SnmpDisplayString(const Oidx&, mib_access, NS_SNMP OctetStr*, bool, 
                          int, int);
        virtual ~SnmpDisplayString();

        virtual MibEntryPtr     clone();
        virtual bool            value_ok(const Vbx&);
        virtual int             prepare_set_request(Request*, int&);
 protected:
        unsigned int max_size;
        unsigned int min_size;
};


/*---------------------- class snmpEngineID ---------------------*/

class AGENTPP_DECL SnmpEngineID: public MibLeaf {

 public:
        SnmpEngineID(const Oidx&, mib_access, NS_SNMP OctetStr*);

        SnmpEngineID(const Oidx&, mib_access, NS_SNMP OctetStr*, int);

        virtual ~SnmpEngineID();

        virtual MibEntryPtr     clone();
        virtual int             prepare_set_request(Request*, int&);

        static NS_SNMP OctetStr create_engine_id(const NS_SNMP OctetStr& userText);

        static NS_SNMP OctetStr create_engine_id(unsigned short port);

};


/*------------------------ class SnmpTagValue -----------------------*/

class AGENTPP_DECL SnmpTagValue: public MibLeaf {

 public:
        SnmpTagValue(const Oidx&, mib_access, NS_SNMP OctetStr*, int);

        SnmpTagValue(const Oidx&);
        virtual ~SnmpTagValue();

        virtual MibEntryPtr     clone();
        virtual bool            value_ok(const Vbx&);
        virtual int             prepare_set_request(Request*, int&);
        static bool             is_delimiter(char); 
};


/*---------------------- class snmpTargetAddrTagList ---------------------*/

class AGENTPP_DECL SnmpTagList: public MibLeaf {

 public:
        SnmpTagList(const Oidx&, mib_access, NS_SNMP OctetStr*, int);

        SnmpTagList(const Oidx&);
        virtual ~SnmpTagList();

        virtual MibEntryPtr     clone();
        virtual bool            value_ok(const Vbx&);
        virtual bool            contains(const char*); 
};


/*--------------------------- class TestAndIncr -------------------------*/

class AGENTPP_DECL TestAndIncr: public MibLeaf {

 public:
        TestAndIncr(const Oidx&);
        virtual ~TestAndIncr();

        virtual long            get_state();
        virtual void            set_state(long);
        virtual int             set(const Vbx&);
        virtual bool            value_ok(const Vbx&);
        virtual int             prepare_set_request(Request*, int&);

        virtual bool            is_volatile() { return TRUE; }
};


/*--------------------------- class StorageType -------------------------*/

class AGENTPP_DECL StorageType: public MibLeaf {

public:
        StorageType(const Oidx&, int);

        virtual bool    row_is_volatile();

        virtual long get_state();

        virtual void set_state(long); 

        virtual MibEntryPtr     clone();
        virtual bool            value_ok(const Vbx&);
};


/*--------------------------- class StorageTable ------------------------*/

class AGENTPP_DECL StorageTable: public MibTable {
  friend class Mib;             // needs access to find_next() and get()
  friend class snmpRowStatus;   // needs access to _ready_for_service()
public:

        StorageTable(const StorageTable&);

        StorageTable(const Oidx&);

        StorageTable(const Oidx&, unsigned int);

        StorageTable(const Oidx&, unsigned int, bool);

        StorageTable(const Oidx&, const index_info*, unsigned int);

        virtual         ~StorageTable();

        virtual void    add_storage_col(StorageType*);

        void            set_storage_type(MibTableRow*, int); 

        virtual void    reset();

 protected:
        virtual bool            is_persistent(MibTableRow*);

private:
        int     storage_type;
};
        
/*---------------------- class SnmpInt32MinMax ---------------------*/

class AGENTPP_DECL SnmpInt32MinMax : public MibLeaf
{
 public:

        SnmpInt32MinMax(const Oidx&, mib_access, const int, int, int, int);
        SnmpInt32MinMax(const Oidx&, mib_access,                 int, int);
        
        virtual bool value_ok(const Vbx&);
        MibEntryPtr     clone();

        int             get_state();
        void            set_state(int);
 private:
        int min, max;
};

/*---------------------- class OctetStrMinMax ---------------------*/

class AGENTPP_DECL OctetStrMinMax : public MibLeaf
{
 public:

        OctetStrMinMax(const Oidx&, mib_access, NS_SNMP OctetStr*, int, u_int, u_int);
        OctetStrMinMax(const Oidx&, mib_access,                 u_int, u_int);
        
        virtual int             prepare_set_request(Request*, int&);
        MibEntryPtr     clone();

        int             get();
        
 protected:
        unsigned int min, max;
};

/*------------------------ class SnmpSecurityModel -----------------------*/

class AGENTPP_DECL SnmpSecurityModel: public SnmpInt32MinMax {

 public:
        SnmpSecurityModel(const Oidx&, mib_access, int, int);
        virtual ~SnmpSecurityModel();

        virtual MibEntryPtr     clone();
};


/*------------------------ class SnmpSecurityLevel -----------------------*/

class AGENTPP_DECL SnmpSecurityLevel: public SnmpInt32MinMax {

 public:
        SnmpSecurityLevel(const Oidx&, mib_access, int, int);
        virtual ~SnmpSecurityLevel();

        virtual MibEntryPtr     clone();
};


/*------------------ class SnmpMessageProcessingModel -------------------*/

class AGENTPP_DECL SnmpMessageProcessingModel: public SnmpInt32MinMax {

 public:
        SnmpMessageProcessingModel(const Oidx&, mib_access, int, int);
        virtual ~SnmpMessageProcessingModel();

        virtual MibEntryPtr     clone();
};

/*---------------------- class SnmpAdminString ---------------------*/

class AGENTPP_DECL SnmpAdminString: public OctetStrMinMax {

 public:
        SnmpAdminString(const Oidx&, mib_access, NS_SNMP OctetStr*);
        SnmpAdminString(const Oidx&, mib_access, NS_SNMP OctetStr*, int);
        SnmpAdminString(const Oidx&, mib_access, NS_SNMP OctetStr*, int, int, int);
        virtual ~SnmpAdminString();

        virtual MibEntryPtr     clone();
        
        NS_SNMP OctetStr                get();
};

/*---------------------- class TimeStamp ---------------------*/

class AGENTPP_DECL TimeStamp: public MibLeaf 
{
 public:
        TimeStamp(const Oidx&, mib_access, int);
        virtual ~TimeStamp();

        virtual bool            is_volatile() { return TRUE; }

        virtual MibEntryPtr     clone();

        void                    update();       
};

/*---------------------- class TimeStampTable ---------------------*/

class AGENTPP_DECL TimeStampTable: public MibTable 
{
 public:
        TimeStampTable(const Oidx&, const index_info*, unsigned int,
                       TimeStamp*);

        virtual ~TimeStampTable();

        virtual void            row_added(MibTableRow*, 
                                          const Oidx&, MibTable*);
        virtual void            row_delete(MibTableRow*, 
                                           const Oidx&, MibTable*);
        virtual void            updated();      

 protected:
        TimeStamp*              lastChange;
};

/*---------------------- class DateAndTime ---------------------*/

class AGENTPP_DECL DateAndTime: public MibLeaf 
{
 public:
        DateAndTime(const Oidx&, mib_access, int);

        virtual ~DateAndTime();

        virtual MibEntryPtr     clone();
        virtual NS_SNMP OctetStr        get_state();
        virtual void            set_state(const NS_SNMP OctetStr&);

        virtual bool    is_volatile() { return TRUE; }

        void            update();
};

#ifdef AGENTPP_NAMESPACE
}
#endif

#endif