NAME

       net - Network interface.

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 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 addresses 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() -> {ok, Names} | {error, Reason}

              Types:

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

              Get network interface names and indexes.