---
name: "net"
section: "3erl"
platform: "linux"
package: "erlang-manpages"
version: "1:25.2.3+dfsg-1+deb12u4"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/net/3erl"
---

# net(3erl)

Network interface.

## 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.