Erlang -- net

# net

###
Module

net

###
Module Summary

Network interface.

###
Since

Module net was introduced in OTP 22.0.

###
Description

This module provides an API for the network interface.

###
Data Types

####
address_info() =
#{family := socket:domain(),
socktype := socket:type(),
protocol := socket:protocol(),
address := socket:sockaddr()}

####
ifaddrs() =
#{name := string(),
flags := ifaddrs_flags(),
addr => socket:sockaddr(),
netmask => socket:sockaddr(),
broadaddr => socket:sockaddr(),
dstaddr => socket:sockaddr()}

This type defines all addresses (and flags) associated with the interface.

Note

Not all fields of this map has to be present. The flags field can be used to test for some of the fields. For example broadaddr will only be present if the broadcast flag is present in flags.

####
ifaddrs_flag() =
up | broadcast | debug | loopback | pointopoint | notrailers |
running | noarp | promisc | master | slave | multicast |
portsel | automedia | dynamic

####
ifaddrs_flags() = [ifaddrs_flag()]

####
ifaddrs_filter() =
all | default | inet | inet6 | packet |
ifaddrs_filter_map() |
ifaddrs_filter_fun()

all
  All interfaces
default
  Interfaces with address family inet and inet6
inet | inet6 | packet
  Interfaces with only the specified address family

####
ifaddrs_filter_map() =
#{family := default | local | inet | inet6 | packet | all,
flags := any | [ifaddrs_flag()]}

The family field can only have the (above) specified values (and not all the values of socket:domain()).

The use of the flags field is that any flag provided must exist for the interface.

For example, if family is set to inet and flags to [broadcast, multicast] only interfaces with address family inet and the flags broadcast and multicast will be listed.

####
ifaddrs_filter_fun() = fun((ifaddrs()) -> boolean())

For each ifaddrs entry, return either true to keep the entry or false to discard the entry.

For example, to get an interface list which only contains non-loopback inet interfaces:

    	net:getifaddrs(fun(#{addr  := #{family := inet},
    	                     flags := Flags}) ->
    			       not lists:member(loopback, Flags);
    			  (_) ->
    			       false
    		       end).

####
name_info() = #{host := string(), service := string()}

####
name_info_flags() = [name_info_flag() | name_info_flag_ext()]

####
name_info_flag() =
namereqd | dgram | nofqdn | numerichost | numericserv

####
name_info_flag_ext() = idn

####
network_interface_name() = string()

####
network_interface_index() = integer() >= 0

###
Exports

####
gethostname() -> {ok, HostName} | {error, Reason}
OTP 22.0

### Types

HostName = string()
Reason = term()

Returns the name of the current host.

####
getnameinfo(SockAddr) -> {ok, Info} | {error, Reason}
OTP 22.0

####
getnameinfo(SockAddr, Flags) -> {ok, Info} | {error, Reason}
OTP 22.0

### Types

SockAddr = socket:sockaddr()
Flags = name_info_flags() | undefined
Info = name_info()
Reason = term()

Address-to-name translation in a protocol-independant manner.

This function is the inverse of getaddrinfo. It converts a socket address to a corresponding host and service.

####
getaddrinfo(Host) -> {ok, Info} | {error, Reason}
OTP 22.0

####
getaddrinfo(Host, Service :: undefined) ->
{ok, Info} | {error, Reason}
OTP 22.0

####
getaddrinfo(Host :: undefined, Service) ->
{ok, Info} | {error, Reason}
OTP 22.0

####
getaddrinfo(Host, Service) -> {ok, Info} | {error, Reason}
OTP 22.0

### Types

Host = Service = string()
Info = [address_info()]
Reason = term()

Network address and service translation.

This function is the inverse of getnameinfo. It converts host and service to a corresponding socket address.

One of the Host and Service may be undefined but not both.

####
getifaddrs() -> {ok, IfAddrs} | {error, Reason}
OTP 22.3

####
getifaddrs(Filter) -> {ok, IfAddrs} | {error, Reason}
OTP 22.3

####
getifaddrs(Namespace) -> {ok, IfAddrs} | {error, Reason}
OTP 22.3

####
getifaddrs(Filter, Namespace) -> {ok, IfAddrs} | {error, Reason}
OTP 22.3

### Types

Filter = ifaddrs_filter()
Namespace = file:filename_all()
IfAddrs = [ifaddrs()]
Reason = term()

Get interface addresses.

This function is used to get the machines interface addresses, possibly filtered according to Filter.

By default, a filter with the content: #{family => default, flags => any} is used. This will return all interfaces with addresses in the inet and inet6 families.

####
if_name2index(Name) -> {ok, Idx} | {error, Reason}
OTP 22.0

### Types

Name = network_interface_name()
Idx = network_interface_index()
Reason = term()

Mappings between network interface names and indexes.

####
if_index2name(Idx) -> {ok, Name} | {error, Reason}
OTP 22.0

### Types

Idx = network_interface_index()
Name = network_interface_name()
Reason = term()

Mappings between network interface index and names.

####
if_names() -> {ok, Names} | {error, Reason}
OTP 22.0

### Types

Names = [{Idx, If}]
Idx = network_interface_index()
If = network_interface_name()
Reason = term()

Get network interface names and indexes.