SmolNet.Inet6.Udp (smolnet v0.7.1)

Copy Markdown View Source

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.

Summary

Types

socket_term()

Functions

child_spec(config)
close(socket)
connect(socket, sockaddr)
connect(socket, address, port)
controlling_process(socket, new_owner)
family()
fdopen(fd, options)
getaddr(address)
getaddr(address, timer)
getopts(socket, names)
getserv(port)
getstat(socket, names)
info(socket)
open(port)
open(port, options)
peername(socket)
recv(socket, length)
recv(socket, length, timeout)
send(socket, packet)
send(socket, destination, packet)
send(socket, destination, ancillary, packet)
send(socket, address, port, ancillary, packet)
setopts(socket, options)
socket_to_list(socket)
sockname(socket)
start_link(config)
translate_ip(address)

Types

socket_term()

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

Functions

child_spec(config)

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

close(socket)

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

connect(socket, sockaddr)

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

connect(socket, address, port)

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

controlling_process(socket, new_owner)

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

family()

@spec family() :: :inet6

fdopen(fd, options)

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

getaddr(address)

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

getaddr(address, timer)

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

getopts(socket, names)

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

getserv(port)

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

getstat(socket, names)

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

info(socket)

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

open(port)

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

open(port, options)

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

peername(socket)

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

recv(socket, length)

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

recv(socket, length, timeout)

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

send(socket, packet)

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

send(socket, destination, packet)

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

send(socket, destination, ancillary, packet)

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

send(socket, address, port, ancillary, packet)

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

setopts(socket, options)

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

socket_to_list(socket)

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

sockname(socket)

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

start_link(config)

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

translate_ip(address)

@spec translate_ip(term()) :: term()