oracular (3) net.3erl.gz

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.