# `SmolNet.Inet6.Udp`
[🔗](https://github.com/ausimian/smolnet/blob/0.7.1/lib/smol_net/inet6/udp.ex#L1)

IPv6 UDP callback and shared adapter for Erlang `:gen_udp` and `:inet`.

Select this callback with `{:udp_module, SmolNet.Inet6.Udp}` and pass
the target stack with `{:smolnet_stack, stack}`. Each returned OTP socket is
backed by one temporary `:gen_statem` child of the stack's inet supervisor.

`SmolNet.Inet6.Udp` is the IPv6 callback. The IPv4 callback
`SmolNet.Inet.Udp` selects the other address family and delegates its
socket operations here, so both families have identical bounded behaviour.

Datagram boundaries are preserved. Ancillary data, multicast, and file
descriptors are intentionally unsupported.

# `socket_term`

```elixir
@type socket_term() :: {:"$inet", SmolNet.Inet.Udp | SmolNet.Inet6.Udp, pid()}
```

# `child_spec`

```elixir
@spec child_spec(map()) :: Supervisor.child_spec()
```

# `close`

```elixir
@spec close(socket_term()) :: :ok
```

# `connect`

```elixir
@spec connect(socket_term(), map()) :: :ok | {:error, atom()}
```

# `connect`

```elixir
@spec connect(socket_term(), term(), term()) :: :ok | {:error, atom()}
```

# `controlling_process`

```elixir
@spec controlling_process(socket_term(), pid()) :: :ok | {:error, atom()}
```

# `family`

```elixir
@spec family() :: :inet6
```

# `fdopen`

```elixir
@spec fdopen(term(), list()) :: {:error, :enotsup}
```

# `getaddr`

```elixir
@spec getaddr(term()) :: {:ok, :inet.ip6_address()} | {:error, atom()}
```

# `getaddr`

```elixir
@spec getaddr(term(), term()) :: {:ok, :inet.ip6_address()} | {:error, atom()}
```

# `getopts`

```elixir
@spec getopts(socket_term(), list()) :: {:ok, list()} | {:error, atom()}
```

# `getserv`

```elixir
@spec getserv(term()) :: {:ok, :inet.port_number()} | {:error, atom()}
```

# `getstat`

```elixir
@spec getstat(socket_term(), list()) :: {:ok, list()} | {:error, atom()}
```

# `info`

```elixir
@spec info(socket_term()) :: map() | {:error, atom()}
```

# `open`

```elixir
@spec open(:inet.port_number()) :: {:ok, socket_term()} | {:error, atom()}
```

# `open`

```elixir
@spec open(:inet.port_number(), list()) :: {:ok, socket_term()} | {:error, atom()}
```

# `peername`

```elixir
@spec peername(socket_term()) ::
  {:ok, {:inet.ip_address(), :inet.port_number()}} | {:error, atom()}
```

# `recv`

```elixir
@spec recv(socket_term(), non_neg_integer()) ::
  {:ok, {:inet.ip_address(), :inet.port_number(), binary() | list()}}
  | {:error, atom()}
```

# `recv`

```elixir
@spec recv(socket_term(), non_neg_integer(), timeout()) ::
  {:ok, {:inet.ip_address(), :inet.port_number(), binary() | list()}}
  | {:error, atom()}
```

# `send`

```elixir
@spec send(socket_term(), iodata()) :: :ok | {:error, atom()}
```

# `send`

```elixir
@spec send(socket_term(), term(), iodata()) :: :ok | {:error, atom()}
```

# `send`

```elixir
@spec send(socket_term(), term(), term(), iodata()) :: :ok | {:error, atom()}
```

# `send`

```elixir
@spec send(socket_term(), term(), term(), list(), iodata()) :: :ok | {:error, atom()}
```

# `setopts`

```elixir
@spec setopts(socket_term(), list()) :: :ok | {:error, atom()}
```

# `socket_to_list`

```elixir
@spec socket_to_list(socket_term()) :: charlist()
```

# `sockname`

```elixir
@spec sockname(socket_term()) ::
  {:ok, {:inet.ip_address(), :inet.port_number()}} | {:error, atom()}
```

# `start_link`

```elixir
@spec start_link(map()) :: :gen_statem.start_ret()
```

# `translate_ip`

```elixir
@spec translate_ip(term()) :: term()
```

---

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