# `snmpa_network_interface`
[🔗](https://github.com/erlang/otp/blob/master/lib/snmp/src/agent/snmpa_network_interface.erl#L22)

Behaviour module for the SNMP agent network interface.

This module defines the behaviour of the agent network interface. A
`snmpa_network_interface` compliant module must export the following functions:

- `start_link/4`
- `info/1`
- `get_log_type/1`
- `set_log_type/2`
- `verbosity/2`

The semantics of them and their exact signatures are explained below.

But this is not enough. There is also a set of _mandatory_ messages which the
network interface entity must be able to receive and be able to send. This is
described in chapter [snmp_agent_netif](snmp_agent_netif.md).

# `get_log_type`

```elixir
-callback get_log_type(Pid) -> {ok, LogType} | {error, Reason}
                          when Pid :: pid(), LogType :: snmp:atl_type(), Reason :: term().
```

The Audit Trail Log is managed by the network interface process. So, it is this
process that has to retrieve the actual log-type.

# `get_request_limit`
*since OTP 27.0* 

```elixir
-callback get_request_limit(Pid) -> {ok, Limit} when Pid :: pid(), Limit :: non_neg_integer() | infinity.
```

The request limit is the number of simultaneous requests the agent will accept.
This function retrieve the current value.

# `info`

```elixir
-callback info(Pid) -> Info when Pid :: pid(), Info :: [{Key, Value}], Key :: term(), Value :: term().
```

The info returned is basically up to the implementer to decide. This
implementation provided by the application provides info about memory allocation
and various socket information.

The info returned by this function is returned together with other info
collected by the agent when the `info/1` function is called
(tagged with with the key `net_if`).

# `set_log_type`

```elixir
-callback set_log_type(Pid, NewType) -> {ok, OldType} | {error, Reason}
                          when
                              Pid :: pid(),
                              NewType :: snmp:atl_type(),
                              OldType :: snmp:atl_type(),
                              Reason :: term().
```

The Audit Trail Log is managed by the network interface process. So, it is this
process that has to do the actual changing of the type.

See `snmpa:set_log_type/2` for more info.

# `set_request_limit`
*since OTP 27.0* 

```elixir
-callback set_request_limit(Pid, NewLimit) -> {ok, OldLimit}
                               when
                                   Pid :: pid(),
                                   NewLimit :: non_neg_integer() | infinity,
                                   OldLimit :: non_neg_integer() | infinity.
```

The request limit is the number of simultaneous requests the agent will accept.
This function sets a new value.

# `start_link`

```elixir
-callback start_link(Prio, NoteStore, MasterAgent, Opts) -> {ok, Pid} | {error, Reason}
                        when
                            Prio :: low | normal | high,
                            NoteStore :: pid(),
                            MasterAgent :: pid(),
                            Opts :: [Option],
                            Option :: {verbosity, snmp:verbosity()} | {versions, [snmp:version()]} | term(),
                            Pid :: pid(),
                            Reason :: term().
```

Start-link the network interface process.

`NoteStore` is the pid of the note-store process and `MasterAgent` is the pid of
the master-agent process.

`Opts` is an (basically) implementation dependent list of options to the network
interface process. There are however a number of options which _must_ be
handled: `versions` and `verbosity`.

# `verbosity`

```elixir
-callback verbosity(Pid, Verbosity) -> snmp:void() when Pid :: pid(), Verbosity :: snmp:verbosity().
```

Change the verbosity of a running network interface process.

---

*Consult [api-reference.md](api-reference.md) for complete listing*