*

a multilingual extensible SNMP agent

*

a SNMP manager

*

a MIB compiler

      {snmp, snmp_components_config()}
    

      [{snmp, 
        [{agent, [{db_dir, "/tmp/snmp/agent/db"},
                  {config, [{dir, "/tmp/snmp/agent/conf"}]}]},
         {manager, [{config, [{dir, "/tmp/snmp/manager/conf"},
                              {db_dir, "/tmp/snmp/manager/db"}]}]}]}
        ]
       }
      ].
    

      snmp_components_config() -> [snmp_component_config()]
      snmp_component_config() -> {agent, agent_options()} | {manager, manager_options()}
      agent_options() = [agent_option()]
      agent_option() = {restart_type,     restart_type()}     | 
                       {agent_type,       agent_type()}       |  
                       {agent_verbosity,  verbosity()}        |  
                       {discovery,        agent_discovery()}  |  
                       {versions,         versions()}         |  
                       {gb_max_vbs,       gb_max_vbs()}       |  
                       {priority,         priority()}         |  
                       {multi_threaded,   multi_threaded()}   |  
                       {db_dir,           db_dir()}           |  
                       {db_init_error,    db_init_error()}    |  
                       {local_db,         local_db()}         |  
                       {net_if,           agent_net_if()}     |  
                       {mibs,             mibs()}             |  
                       {mib_storage,      mib_storage()}      |  
                       {mib_server,       mib_server()}       |  
                       {audit_trail_log,  audit_trail_log()}  |  
                       {error_report_mod, error_report_mod()} |  
                       {note_store,       note_store()}       |  
                       {symbolic_store,   symbolic_store()}   |  
                       {target_cache,     target_cache()}     |  
                       {config,           agent_config()}
      manager_options() = [manager_option()]
      manager_option() = {restart_type,             restart_type()}    | 
                         {net_if,                   manager_net_if()}  |  
                         {server,                   server()}          | 
                         {note_store,               note_store()}      | 
                         {config,                   manager_config()}  |  
                         {inform_request_behaviour, manager_irb()}     | 
                         {mibs,                     manager_mibs()}    | 
                         {priority,                 priority()}        |  
                         {audit_trail_log,          audit_trail_log()} | 
                         {versions,                 versions()}        | 
                         {def_user_mod,             def_user_module()  | 
                         {def_user_data,            def_user_data()}
    

agent_type() = master | sub <optional>:

If master, one master agent is started. Otherwise, no agents are started.

agent_discovery() = [agent_discovery_opt()] <optional>:

agent_discovery_opt() = {terminating, agent_terminating_discovery_opts()} | {originating, agent_originating_discovery_opts()}

agent_terminating_discovery_opts() = [agent_terminating_discovery_opt()] <optional>:

agent_terminating_discovery_opt() = {enable, boolean()} | {stage2, discovery | plain} | {trigger_username, string()}

agent_originating_discovery_opts() = [agent_originating_discovery_opt()] <optional>:

agent_originating_discovery_opt() = {enable, boolean()}

multi_threaded() = bool() | extended <optional>:

If true (or extended), the agent is multi-threaded, with one thread for each get request.

Even with multi-threaded set to extended there is still a risk for 'reorder' when sending inform-requsts, which require a response (and may therefor require resending).

Also, there is of course no way to guarantee order once the package is on the network.

db_dir() = string() <mandatory>:

Defines where the SNMP agent internal db files are stored.

gb_max_vbs() = pos_integer() | infinity <optional>:

Defines the maximum number of varbinds allowed in a Get-BULK response.

local_db() = [local_db_opt()] <optional>:

local_db_opt() = {repair, agent_repair()} | {auto_save, agent_auto_save()} | {verbosity, verbosity()}

agent_repair() = false | true | force <optional>:

When starting snmpa_local_db it always tries to open an existing database. If false, and some errors occur, a new database is created instead. If true, an existing file will be repaired. If force, the table will be repaired even if it was properly closed.

agent_auto_save() = integer() | infinity <optional>:

The auto save interval. The table is flushed to disk whenever not accessed for this amount of time.

agent_net_if() = [agent_net_if_opt()] <optional>:

agent_net_if_opt() = {module, agent_net_if_module()} | {verbosity, verbosity()} | {options, agent_net_if_options()}

agent_net_if_module() = atom() <optional>:

Module which handles the network interface part for the SNMP agent. Must implement the snmpa_network_interface behaviour.

agent_net_if_options() = [agent_net_if_option()] <optional>:

agent_net_if_option() = {bind_to, bind_to()} | {sndbuf, sndbuf()} | {recbuf, recbuf()} | {no_reuse, no_reuse()} | {req_limit, req_limit()} | {filter, agent_net_if_filter_options()} | {extra_sock_opts, extra_socket_options()} | {inet_backend, inet | socket}

If the user has configured transports with options then those will take precedence over these options. See agent information for more info.

req_limit() = integer() | infinity <optional>:

Max number of simultaneous requests handled by the agent.

agent_net_if_filter_options() = [agent_net_if_filter_option()] <optional>:

agent_net_if_filter_option() = {module, agent_net_if_filter_module()}

agent_net_if_filter_module() = atom() <optional>:

Module which handles the network interface filter part for the SNMP agent. Must implement the snmpa_network_interface_filter behaviour.

agent_mibs() = [string()] <optional>:

Specifies a list of MIBs (including path) that defines which MIBs are initially loaded into the SNMP master agent.

mib_storage() = [mib_storage_opt()] <optional>:

mib_storage_opt() = {module, mib_storage_module()} | {options, mib_storage_options()}

mib_storage_module() = snmpa_mib_data_ets | snmpa_mib_data_dets | snmpa_mib_data_mnesia | module():

Defines the mib storage module of the SNMP agent as defined by the snmpa_mib_storage behaviour.

mib_storage_options() = list() <optional>:

This is implementattion depended. That is, it depends on the module. For each module a specific set of options are valid. For the module provided with the app, these options are supported:

mib_server() = [mib_server_opt()] <optional>:

mib_server_opt() = {mibentry_override, mibentry_override()} | {trapentry_override, trapentry_override()} | {verbosity, verbosity()} | {cache, mibs_cache()} | {data_module, mib_server_data_module()}

mibentry_override() = bool() <optional>:

If this value is false, then when loading a mib each mib- entry is checked prior to installation of the mib. The purpose of the check is to prevent that the same symbolic mibentry name is used for different oid's.

trapentry_override() = bool() <optional>:

If this value is false, then when loading a mib each trap is checked prior to installation of the mib. The purpose of the check is to prevent that the same symbolic trap name is used for different trap's.

mib_server_data_module() = snmpa_mib_data_tttn | module() <optional>:

Defines the backend data module of the SNMP agent mib-server as defined by the snmpa_mib_data behaviour.

mibs_cache() = bool() | mibs_cache_opts() <optional>:

Shall the agent utilize the mib server lookup cache or not.

mibs_cache_opts() = [mibs_cache_opt()] <optional>:

mibs_cache_opt() = {autogc, mibs_cache_autogc()} | {gclimit, mibs_cache_gclimit()} | {age, mibs_cache_age()}

mibs_cache_autogc() = bool() <optional>:

Defines if the mib server shall perform cache gc automatically or leave it to the user (see gc_mibs_cache/0,1,2,3).

mibs_cache_age() = integer() > 0 <optional>:

Defines how old the entries in the cache will be allowed to become before they are GC'ed (assuming GC is performed). Each entry in the cache is "touched" whenever it is accessed.

mibs_cache_gclimit() = infinity | integer() > 0 <optional>:

When performing a GC, this is the max number of cache entries that will be deleted from the cache.

error_report_mod() = atom() <optional>:

Defines an error report module, implementing the snmpa_error_report behaviour. Two modules are provided with the toolkit: snmpa_error_logger and snmpa_error_io.

symbolic_store() = [symbolic_store_opt()]:

symbolic_store_opt() = {verbosity, verbosity()}

target_cache() = [target_cache_opt()]:

target_cache_opt() = {verbosity, verbosity()}

agent_config() = [agent_config_opt()] <mandatory>:

agent_config_opt() = {dir, agent_config_dir()} | {force_load, force_load()} | {verbosity, verbosity()}

agent_config_dir = dir() <mandatory>:

Defines where the SNMP agent configuration files are stored.

force_load() = bool() <optional>:

If true the configuration files are re-read during start-up, and the contents of the configuration database ignored. Thus, if true, changes to the configuration database are lost upon reboot of the agent.

server() = [server_opt()] <optional>:

server_opt() = {timeout, server_timeout()} | {verbosity, verbosity()} | {cbproxy, server_cbproxy()} | {netif_sup, server_nis()}

server_timeout() = integer() <optional>:

Asynchronous request cleanup time. For every requests, some info is stored internally, in order to be able to deliver the reply (when it arrives) to the proper destination. If the reply arrives, this info will be deleted. But if there is no reply (in time), the info has to be deleted after the best before time has been passed. This cleanup will be performed at regular intervals, defined by the server_timeout() time. The information will have an best before time, defined by the Expire time given when calling the request function (see async_get, async_get_next and async_set).

server_cbproxy() = temporary (default) | permanent <optional>:

This option specifies how the server will handle callback calls.

server_nis() = none (default) | {PingTO, PongTO} <optional>:

This option specifies if the server should actively supervise the net-if process. Note that this will only work if the used net-if process actually supports the protocol. See snmpm_network_interface behaviour for more info.

manager_config() = [manager_config_opt()] <mandatory>:

manager_config_opt() = {dir, manager_config_dir()} | {db_dir, manager_db_dir()} | {db_init_error, db_init_error()} | {repair, manager_repair()} | {auto_save, manager_auto_save()} | {verbosity, verbosity()}

manager_config_dir = dir() <mandatory>:

Defines where the SNMP manager configuration files are stored.

manager_db_dir = dir() <mandatory>:

Defines where the SNMP manager store persistent data.

manager_repair() = false | true | force <optional>:

Defines the repair option for the persistent database (if and how the table is repaired when opened).

manager_auto_save() = integer() | infinity <optional>:

The auto save interval. The table is flushed to disk whenever not accessed for this amount of time.

manager_irb() = auto | user | {user, integer()} <optional>:

This option defines how the manager will handle the sending of response (acknowledgment) to received inform-requests.

manager_mibs() = [string()] <optional>:

Specifies a list of MIBs (including path) and defines which MIBs are initially loaded into the SNMP manager.

manager_net_if() = [manager_net_if_opt()] <optional>:

manager_net_if_opt() = {module, manager_net_if_module()} | {verbosity, verbosity()} | {options, manager_net_if_options()}

manager_net_if_options() = [manager_net_if_option()] <optional>:

manager_net_if_option() = {bind_to, bind_to()} | {sndbuf, sndbuf()} | {recbuf, recbuf()} | {no_reuse, no_reuse()} | {filter, manager_net_if_filter_options()} | {extra_sock_opts, extra_socket_options()} | {inet_backend, inet | socket}

manager_net_if_module() = atom() <optional>:

The module which handles the network interface part for the SNMP manager. It must implement the snmpm_network_interface behaviour.

manager_net_if_filter_options() = [manager_net_if_filter_option()] <optional>:

manager_net_if_filter_option() = {module, manager_net_if_filter_module()}

manager_net_if_filter_module() = atom() <optional>:

Module which handles the network interface filter part for the SNMP manager. Must implement the snmpm_network_interface_filter behaviour.

def_user_module() = atom() <optional>:

The module implementing the default user. See the snmpm_user behaviour.

def_user_data() = term() <optional>:

Data for the default user. Passed to the user module when calling the callback functions.

restart_type() = permanent | transient | temporary:

See supervisor documentation for more info.

db_init_error() = terminate | create | create_db_and_dir:

Defines what to do if the agent or manager is unable to open an existing database file. terminate means that the agent/manager will terminate and create means that the agent/manager will remove the faulty file(s) and create new ones, and create_db_and_dir means that the agent/manager will create the database file along with any missing parent directories for the database file.

priority() = atom() <optional>:

Defines the Erlang priority for all SNMP processes.

versions() = [version()] <optional>:

version() = v1 | v2 | v3

verbosity() = silence | info | log | debug | trace <optional>:

Verbosity for a SNMP process. This specifies now much debug info is printed.

bind_to() = bool() <optional>:

If true, net_if binds to the IP address. If false, net_if listens on any IP address on the host where it is running.

no_reuse() = bool() <optional>:

If true, net_if does not specify that the IP and port address should be reusable. If false, the address is set to reusable.

recbuf() = integer() <optional>:

Receive buffer size.

sndbuf() = integer() <optional>:

Send buffer size.

extra_socket_options() = list() <optional>:

A list of arbitrary socket options.

note_store() = [note_store_opt()] <optional>:

note_store_opt() = {timeout, note_store_timeout()} | {verbosity, verbosity()}

note_store_timeout() = integer() <optional>:

Note cleanup time. When storing a note in the note store, each note is given lifetime. Every timeout the note_store process performs a GC to remove the expired note's. Time in milli-seconds.

audit_trail_log() = [audit_trail_log_opt()] <optional>:

audit_trail_log_opt() = {type, atl_type()} | {dir, atl_dir()} | {size, atl_size()} | {repair, atl_repair()} | {seqno, atl_seqno()}

atl_type() = read | write | read_write <optional>:

Specifies what type of an audit trail log should be used. The effect of the type is actually different for the the agent and the manager.

atl_dir = dir() <mandatory>:

Specifies where the audit trail log should be stored.

atl_size() = {integer(), integer()} <mandatory>:

Specifies the size of the audit trail log. This parameter is sent to disk_log.

atl_repair() = true | false | truncate | snmp_repair <optional>:

Specifies if and how the audit trail log shall be repaired when opened. Unless this parameter has the value snmp_repair it is sent to disk_log. If, on the other hand, the value is snmp_repair, snmp attempts to handle certain faults on its own. And even if it cannot repair the file, it does not truncate it directly, but instead moves it aside for later off-line analysis.

atl_seqno() = true | false <optional>:

Specifies if the audit trail log entries will be (sequence) numbered or not. The range of the sequence numbers are according to RFC 5424, i.e. 1 through 2147483647.