NAME

       net - Network interface.

DESCRIPTION

       This module provides an API for the network interface.

   Note:
       There is currently no support for Windows.

   Note:
       The  content of this file is only valid if the system has been built with 'socket' (esock)
       support, which is the default.

DATA TYPES

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

       ifaddrs() =
           #{name := string(),
             flags := [ifaddrs_flag()],
             addr := socket:sockaddr(),
             netmask := socket:sockaddr(),
             broadaddr := socket:sockaddr(),
             dstaddr := socket:sockaddr()}

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

              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_filter() =
           all | default | inet | inet6 | packet |
           ifaddrs_filter_map() |
           ifaddrs_filter_fun()

                all:
                  All interfaces

                default:
                  Interfaces with address family inetandinet6

                inet | inet6 | packet:
                  Interfaces with only the specified address family

       ifaddrs_filter_map() =
           #{family := default | 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}

              Types:

                 HostName = string()
                 Reason = term()

              Returns the name of the current host.

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

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

              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}

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

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

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

              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}

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

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

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

              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 adresses in the inet and inet6 families.

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

              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}

              Types:

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

              Mappings between network interface index and names.

       if_names() -> Names | {error, Reason}

              Types:

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

              Get network interface names and indexes.