1inet(3) Erlang Module Definition inet(3)
2
6 inet - Access to TCP/IP protocols.
7
9 This module provides access to TCP/IP protocols.
10 See also ERTS User's Guide: Inet Configuration for more information
12 about how to configure an Erlang runtime system for IP communication.
13 The following two Kernel configuration parameters affect the behavior
15 of all sockets opened on an Erlang node:
16 * inet_default_connect_options can contain a list of default options
18 used for all sockets returned when doing connect.
19 * inet_default_listen_options can contain a list of default options
21 used when issuing a listen call.
22 When accept is issued, the values of the listening socket options are
24 inherited. No such application variable is therefore needed for accept.
25 Using the Kernel configuration parameters above, one can set default
27 options for all TCP sockets on a node, but use this with care. Options
28 such as {delay_send,true} can be specified in this way. The following
29 is an example of starting an Erlang node with all sockets using delayed
30 send:
31 $ erl -sname test -kernel \
33 inet_default_connect_options '[{delay_send,true}]' \
34 inet_default_listen_options '[{delay_send,true}]'
35 Notice that default option {active, true} cannot be changed, for inter‐
37 nal reasons.
38 Addresses as inputs to functions can be either a string or a tuple. For
40 example, the IP address 150.236.20.73 can be passed to gethostbyaddr/1,
41 either as string "150.236.20.73" or as tuple {150, 236, 20, 73}.
42 IPv4 address examples:
44 Address ip_address()
46 ------- ------------
47 127.0.0.1 {127,0,0,1}
48 192.168.42.2 {192,168,42,2}
49 IPv6 address examples:
51 Address ip_address()
53 ------- ------------
54 ::1 {0,0,0,0,0,0,0,1}
55 ::192.168.42.2 {0,0,0,0,0,0,(192 bsl 8) bor 168,(42 bsl 8) bor 2}
56 ::FFFF:192.168.42.2
57 {0,0,0,0,0,16#FFFF,(192 bsl 8) bor 168,(42 bsl 8) bor 2}
58 3ffe:b80:1f8d:2:204:acff:fe17:bf38
59 {16#3ffe,16#b80,16#1f8d,16#2,16#204,16#acff,16#fe17,16#bf38}
60 fe80::204:acff:fe17:bf38
61 {16#fe80,0,0,0,16#204,16#acff,16#fe17,16#bf38}
62 Function parse_address/1 can be useful:
64 1> inet:parse_address("192.168.42.2").
66 {ok,{192,168,42,2}}
67 2> inet:parse_address("::FFFF:192.168.42.2").
68 {ok,{0,0,0,0,0,65535,49320,10754}}
69
71 hostent() =
72 #hostent{h_name = inet:hostname(),
73 h_aliases = [inet:hostname()],
74 h_addrtype = inet | inet6,
75 h_length = integer() >= 0,
76 h_addr_list = [inet:ip_address()]}
77 The record is defined in the Kernel include file "inet.hrl".
79 Add the following directive to the module:
81 -include_lib("kernel/include/inet.hrl").
83 hostname() = atom() | string()
85 ip_address() = ip4_address() | ip6_address()
87 ip4_address() = {0..255, 0..255, 0..255, 0..255}
89 ip6_address() =
91 {0..65535,
92 0..65535,
93 0..65535,
94 0..65535,
95 0..65535,
96 0..65535,
97 0..65535,
98 0..65535}
99 port_number() = 0..65535
101 family_address() =
103 inet_address() | inet6_address() | local_address()
104 A general address format on the form {Family, Destination} where
106 Family is an atom such as local and the format of Destination
107 depends on Family, and is a complete address (for example an IP
108 address including port number).
109 inet_address() =
111 {inet, {ip4_address() | any | loopback, port_number()}}
112 Warning:
114 This address format is for now experimental and for completeness
115 to make all address families have a {Family, Destination} repre‐
116 sentation.
117 inet6_address() =
120 {inet6, {ip6_address() | any | loopback, port_number()}}
121 Warning:
123 This address format is for now experimental and for completeness
124 to make all address families have a {Family, Destination} repre‐
125 sentation.
126 local_address() = {local, File :: binary() | string()}
129 This address family only works on Unix-like systems.
131 File is normally a file pathname in a local filesystem. It is
133 limited in length by the operating system, traditionally to 108
134 bytes.
135 A binary() is passed as is to the operating system, but a
137 string() is encoded according to the system filename encoding
138 mode.
139 Other addresses are possible, for example Linux implements "Ab‐
141 stract Addresses". See the documentation for Unix Domain Sockets
142 on your system, normally unix in manual section 7.
143 In most API functions where you can use this address family the
145 port number must be 0.
146 inet_backend() = {inet_backend, inet | socket}
148 Select the implementation backend for sockets. The current de‐
150 fault is inet which at the bottom uses inet_drv.c to call the
151 platform's socket API. The value socket instead at the bottom
152 uses the socket module and its NIF implementation.
153 This is a temporary option that will be ignored in a future re‐
155 lease.
156 socket_address() =
158 ip_address() | any | loopback | local_address()
159 socket_getopt() =
161 gen_sctp:option_name() |
162 gen_tcp:option_name() |
163 gen_udp:option_name()
164 socket_setopt() =
166 gen_sctp:option() | gen_tcp:option() | gen_udp:option()
167 returned_non_ip_address() =
169 {local, binary()} | {unspec, <<>>} | {undefined, any()}
170 Addresses besides ip_address() ones that are returned from
172 socket API functions. See in particular local_address(). The
173 unspec family corresponds to AF_UNSPEC and can occur if the
174 other side has no socket address. The undefined family can only
175 occur in the unlikely event of an address family that the VM
176 does not recognize.
177 ancillary_data() =
179 [{tos, byte()} | {tclass, byte()} | {ttl, byte()}]
180 Ancillary data received with the data packet, read with the
182 socket option pktoptions from a TCP socket, or to set in a call
183 to gen_udp:send/4 or gen_udp:send/5.
184 The value(s) correspond to the currently active socket options
186 recvtos, recvtclass and recvttl, or for a single send operation
187 the option(s) to override the currently active socket option(s).
188 getifaddrs_ifopts() =
190 [Ifopt ::
191 {flags,
192 Flags ::
193 [up | broadcast | loopback | pointtopoint |
194 running | multicast]} |
195 {addr, Addr :: ip_address()} |
196 {netmask, Netmask :: ip_address()} |
197 {broadaddr, Broadaddr :: ip_address()} |
198 {dstaddr, Dstaddr :: ip_address()} |
199 {hwaddr, Hwaddr :: [byte()]}]
200 Interface address description list returned from getifaddrs/0,1
202 for a named interface, translated from the returned data of the
203 POSIX API function getaddrinfo().
204 Hwaddr is hardware dependent, for example, on Ethernet inter‐
206 faces it is the 6-byte Ethernet address (MAC address (EUI-48 ad‐
207 dress)).
208 The tuples {addr,Addr}, {netmask,Netmask}, and possibly {broad‐
210 addr,Broadaddr} or {dstaddr,Dstaddr} are repeated in the list if
211 the interface has got multiple addresses. An interface may have
212 multiple {flag,_} tuples for example if it has different flags
213 for different address families. Multiple {hwaddr,Hwaddr} tuples
214 is hard to say anything definite about, though. The tuple
215 {flag,Flags} is mandatory, all others are optional.
216 Do not rely too much on the order of Flags atoms or the Ifopt
218 tuples. There are however some rules:
219 * A {flag,_} tuple applies to all other tuples that follow.
221 * Immediately after {addr,_} follows {netmask,_}.
223 * Immediately thereafter may {broadaddr,_} follow if broadcast
225 is member of Flags, or {dstaddr,_} if pointtopoint is member
226 of Flags. Both {dstaddr,_} and {broadaddr,_} does not occur
227 for the same {addr,_}.
228 * Any {netmask,_}, {broadaddr,_}, or {dstaddr,_} tuples that
230 follow an {addr,Addr} tuple concerns the address Addr.
231 The tuple {hwaddr,_} is not returned on Solaris, as the hardware
233 address historically belongs to the link layer and it is not re‐
234 turned by the Solaris API function getaddrinfo().
235 Warning:
237 On Windows, the data is fetched from different OS API functions,
238 so the Netmask and Broadaddr values may be calculated, just as
239 some Flags values.
240 posix() =
243 eaddrinuse | eaddrnotavail | eafnosupport | ealready |
244 econnaborted | econnrefused | econnreset | edestaddrreq |
245 ehostdown | ehostunreach | einprogress | eisconn | emsgsize |
246 enetdown | enetunreach | enopkg | enoprotoopt | enotconn |
247 enotty | enotsock | eproto | eprotonosupport | eprototype |
248 esocktnosupport | etimedout | ewouldblock | exbadport |
249 exbadseq |
250 file:posix()
251 An atom that is named from the POSIX error codes used in Unix,
253 and in the runtime libraries of most C compilers. See section
254 POSIX Error Codes.
255 socket()
257 See gen_tcp:type-socket and gen_udp:type-socket.
259 address_family() = inet | inet6 | local
261 socket_protocol() = tcp | udp | sctp
263 stat_option() =
265 recv_cnt | recv_max | recv_avg | recv_oct | recv_dvi |
266 send_cnt | send_max | send_avg | send_oct | send_pend
267
269 close(Socket) -> ok
270 Types:
272 Socket = socket()
274 Closes a socket of any type.
276 cancel_monitor(MRef) -> boolean()
278 Types:
280 MRef = reference()
282 If MRef is a reference that the calling process obtained by
284 calling monitor/1, this monitor is turned off. If the monitoring
285 is already turned off, nothing happens.
286 The returned value is one of the following:
288 true:
290 The monitor was found and removed. In this case, no 'DOWN'
291 message corresponding to this monitor has been delivered and
292 will not be delivered.
293 false:
295 The monitor was not found and could not be removed. This
296 probably because a 'DOWN' message corresponding to this mon‐
297 itor has already been placed in the caller message queue.
298 Failure: It is an error if MRef refers to a monitor started by
300 another process.
301 format_error(Reason) -> string()
303 Types:
305 Reason = posix() | system_limit
307 Returns a diagnostic error string. For possible POSIX values and
309 corresponding strings, see section POSIX Error Codes.
310 get_rc() ->
312 [{Par :: atom(), Val :: any()} |
313 {Par :: atom(), Val1 :: any(), Val2 :: any()}]
314 Returns the state of the Inet configuration database in form of
316 a list of recorded configuration parameters. For more informa‐
317 tion, see ERTS User's Guide: Inet Configuration.
318 Only actual parameters with other than default values are re‐
320 turned, for example not directives that specify other sources
321 for configuration parameters nor directives that clear parame‐
322 ters.
323 getaddr(Host, Family) -> {ok, Address} | {error, posix()}
325 Types:
327 Host = ip_address() | hostname()
329 Family = address_family()
330 Address = ip_address()
331 Returns the IP address for Host as a tuple of integers. Host can
333 be an IP address, a single hostname, or a fully qualified host‐
334 name.
335 getaddrs(Host, Family) -> {ok, Addresses} | {error, posix()}
337 Types:
339 Host = ip_address() | hostname()
341 Family = address_family()
342 Addresses = [ip_address()]
343 Returns a list of all IP addresses for Host. Host can be an IP
345 address, a single hostname, or a fully qualified hostname.
346 gethostbyaddr(Address) -> {ok, Hostent} | {error, posix()}
348 Types:
350 Address = string() | ip_address()
352 Hostent = hostent()
353 Returns a hostent record for the host with the specified ad‐
355 dress.
356 gethostbyname(Hostname) -> {ok, Hostent} | {error, posix()}
358 Types:
360 Hostname = hostname()
362 Hostent = hostent()
363 Returns a hostent record for the host with the specified host‐
365 name.
366 If resolver option inet6 is true, an IPv6 address is looked up.
368 gethostbyname(Hostname, Family) ->
370 {ok, Hostent} | {error, posix()}
371 Types:
373 Hostname = hostname()
375 Family = address_family()
376 Hostent = hostent()
377 Returns a hostent record for the host with the specified name,
379 restricted to the specified address family.
380 gethostname() -> {ok, Hostname}
382 Types:
384 Hostname = string()
386 Returns the local hostname. Never fails.
388 getifaddrs() ->
390 {ok,
391 [{Ifname :: string(),
392 Ifopts :: getifaddrs_ifopts()}]} |
393 {error, posix()}
394 Returns a list of 2-tuples containing interface names and the
396 interfaces' addresses. Ifname is a Unicode string and Ifopts is
397 a list of interface address description tuples.
398 The interface address description tuples are documented under
400 the type of the Ifopts value.
401 getifaddrs(Opts) -> {ok, [{Ifname, Ifopts}]} | {error, Posix}
403 Types:
405 Opts = [{netns, Namespace}]
407 Namespace = file:filename_all()
408 Ifname = string()
409 Ifopts = getifaddrs_ifopts()
410 Posix = posix()
411 The same as getifaddrs/0 but the Option {netns, Namespace} sets
413 a network namespace for the OS call, on platforms that supports
414 that feature.
415 See the socket option {netns, Namespace} under setopts/2.
417 getopts(Socket, Options) -> {ok, OptionValues} | {error, posix()}
419 Types:
421 Socket = socket()
423 Options = [socket_getopt()]
424 OptionValues = [socket_setopt() | gen_tcp:pktoptions_value()]
425 Gets one or more options for a socket. For a list of available
427 options, see setopts/2. See also the description for the type
428 gen_tcp:pktoptions_value().
429 The number of elements in the returned OptionValues list does
431 not necessarily correspond to the number of options asked for.
432 If the operating system fails to support an option, it is left
433 out in the returned list. An error tuple is returned only when
434 getting options for the socket is impossible (that is, the
435 socket is closed or the buffer size in a raw request is too
436 large). This behavior is kept for backward compatibility rea‐
437 sons.
438 A raw option request RawOptReq = {raw, Protocol, OptionNum, Val‐
440 ueSpec} can be used to get information about socket options not
441 (explicitly) supported by the emulator. The use of raw socket
442 options makes the code non-portable, but allows the Erlang pro‐
443 grammer to take advantage of unusual features present on a par‐
444 ticular platform.
445 RawOptReq consists of tag raw followed by the protocol level,
447 the option number, and either a binary or the size, in bytes, of
448 the buffer in which the option value is to be stored. A binary
449 is to be used when the underlying getsockopt requires input in
450 the argument field. In this case, the binary size is to corre‐
451 spond to the required buffer size of the return value. The sup‐
452 plied values in a RawOptReq correspond to the second, third, and
453 fourth/fifth parameters to the getsockopt call in the C socket
454 API. The value stored in the buffer is returned as a binary Val‐
455 ueBin, where all values are coded in the native endianess.
456 Asking for and inspecting raw socket options require low-level
458 information about the current operating system and TCP stack.
459 Example:
461 Consider a Linux machine where option TCP_INFO can be used to
463 collect TCP statistics for a socket. Assume you are interested
464 in field tcpi_sacked of struct tcp_info filled in when asking
465 for TCP_INFO. To be able to access this information, you need to
466 know the following:
467 * The numeric value of protocol level IPPROTO_TCP
469 * The numeric value of option TCP_INFO
471 * The size of struct tcp_info
473 * The size and offset of the specific field
475 By inspecting the headers or writing a small C program, it is
477 found that IPPROTO_TCP is 6, TCP_INFO is 11, the structure size
478 is 92 (bytes), the offset of tcpi_sacked is 28 bytes, and the
479 value is a 32-bit integer. The following code can be used to re‐
480 trieve the value:
481 get_tcpi_sacked(Sock) ->
483 {ok,[{raw,_,_,Info}]} = inet:getopts(Sock,[{raw,6,11,92}]),
484 <<_:28/binary,TcpiSacked:32/native,_/binary>> = Info,
485 TcpiSacked.
486 Preferably, you would check the machine type, the operating sys‐
488 tem, and the Kernel version before executing anything similar to
489 this code.
490 getstat(Socket) -> {ok, OptionValues} | {error, posix()}
492 getstat(Socket, Options) -> {ok, OptionValues} | {error, posix()}
494 Types:
496 Socket = socket()
498 Options = [stat_option()]
499 OptionValues = [{stat_option(), integer()}]
500 stat_option() =
501 recv_cnt | recv_max | recv_avg | recv_oct | recv_dvi |
502 send_cnt | send_max | send_avg | send_oct | send_pend
503 Gets one or more statistic options for a socket.
505 getstat(Socket) is equivalent to getstat(Socket, [recv_avg,
507 recv_cnt, recv_dvi, recv_max, recv_oct, send_avg, send_cnt,
508 send_pend, send_max, send_oct]).
509 The following options are available:
511 recv_avg:
513 Average size of packets, in bytes, received by the socket.
514 recv_cnt:
516 Number of packets received by the socket.
517 recv_dvi:
519 Average packet size deviation, in bytes, received by the
520 socket.
521 recv_max:
523 Size of the largest packet, in bytes, received by the
524 socket.
525 recv_oct:
527 Number of bytes received by the socket.
528 send_avg:
530 Average size of packets, in bytes, sent from the socket.
531 send_cnt:
533 Number of packets sent from the socket.
534 send_pend:
536 Number of bytes waiting to be sent by the socket.
537 send_max:
539 Size of the largest packet, in bytes, sent from the socket.
540 send_oct:
542 Number of bytes sent from the socket.
543 i() -> ok
545 i(Proto :: socket_protocol()) -> ok
547 i(X1 :: socket_protocol(), Fs :: [atom()]) -> ok
549 Lists all TCP, UDP and SCTP sockets, including those that the
551 Erlang runtime system uses as well as those created by the ap‐
552 plication.
553 The following options are available:
555 port:
557 The internal index of the port.
558 module:
560 The callback module of the socket.
561 recv:
563 Number of bytes received by the socket.
564 sent:
566 Number of bytes sent from the socket.
567 owner:
569 The socket owner process.
570 local_address:
572 The local address of the socket.
573 foreign_address:
575 The address and port of the other end of the connection.
576 state:
578 The connection state.
579 type:
581 STREAM or DGRAM or SEQPACKET.
582 info(Socket) -> Info
584 Types:
586 Socket = socket()
588 Info = term()
589 Produces a term containg miscellaneous information about a
591 socket.
592 monitor(Socket) -> reference()
594 Types:
596 Socket = socket()
598 Start monitor the socket Socket.
600 If the monitored socket does not exist or when the monitor is
602 triggered, a 'DOWN' message is sent that has the following pat‐
603 tern:
604 {'DOWN', MonitorRef, Type, Object, Info}
606 MonitorRef:
609 The identity of the socket.
610 Type:
612 The type of socket, can be one of the following atoms: port
613 or socket.
614 Object:
616 The monitored entity, the socket, which triggered the event.
617 Info:
619 Either the termination reason of the socket or nosock
620 (socket Socket did not exist at the time of monitor cre‐
621 ation).
622 Making several calls to inet:monitor/1 for the same Socket is
624 not an error; it results in as many independent monitoring in‐
625 stances.
626 ntoa(IpAddress) -> Address | {error, einval}
628 Types:
630 Address = string()
632 IpAddress = ip_address()
633 Parses an ip_address() and returns an IPv4 or IPv6 address
635 string.
636 parse_address(Address) -> {ok, IPAddress} | {error, einval}
638 Types:
640 Address = string()
642 IPAddress = ip_address()
643 Parses an IPv4 or IPv6 address string and returns an ip4_ad‐
645 dress() or ip6_address(). Accepts a shortened IPv4 address
646 string.
647 parse_ipv4_address(Address) -> {ok, IPv4Address} | {error, einval}
649 Types:
651 Address = string()
653 IPv4Address = ip_address()
654 Parses an IPv4 address string and returns an ip4_address(). Ac‐
656 cepts a shortened IPv4 address string.
657 parse_ipv4strict_address(Address) ->
659 {ok, IPv4Address} | {error, einval}
660 Types:
662 Address = string()
664 IPv4Address = ip_address()
665 Parses an IPv4 address string containing four fields, that is,
667 not shortened, and returns an ip4_address().
668 parse_ipv6_address(Address) -> {ok, IPv6Address} | {error, einval}
670 Types:
672 Address = string()
674 IPv6Address = ip_address()
675 Parses an IPv6 address string and returns an ip6_address(). If
677 an IPv4 address string is specified, an IPv4-mapped IPv6 address
678 is returned.
679 parse_ipv6strict_address(Address) ->
681 {ok, IPv6Address} | {error, einval}
682 Types:
684 Address = string()
686 IPv6Address = ip_address()
687 Parses an IPv6 address string and returns an ip6_address(). Does
689 not accept IPv4 addresses.
690 ipv4_mapped_ipv6_address(X1 :: ip_address()) -> ip_address()
692 Convert an IPv4 address to an IPv4-mapped IPv6 address or the
694 reverse. When converting from an IPv6 address all but the 2 low
695 words are ignored so this function also works on some other
696 types of addresses than IPv4-mapped.
697 parse_strict_address(Address) -> {ok, IPAddress} | {error, einval}
699 Types:
701 Address = string()
703 IPAddress = ip_address()
704 Parses an IPv4 or IPv6 address string and returns an ip4_ad‐
706 dress() or ip6_address(). Does not accept a shortened IPv4 ad‐
707 dress string.
708 peername(Socket :: socket()) ->
710 {ok,
711 {ip_address(), port_number()} |
712 returned_non_ip_address()} |
713 {error, posix()}
714 Returns the address and port for the other end of a connection.
716 Notice that for SCTP sockets, this function returns only one of
718 the peer addresses of the socket. Function peernames/1,2 returns
719 all.
720 peernames(Socket :: socket()) ->
722 {ok,
723 [{ip_address(), port_number()} |
724 returned_non_ip_address()]} |
725 {error, posix()}
726 Equivalent to peernames(Socket, 0).
728 Notice that the behavior of this function for an SCTP one-to-
730 many style socket is not defined by the SCTP Sockets API Exten‐
731 sions.
732 peernames(Socket, Assoc) ->
734 {ok, [{Address, Port}]} | {error, posix()}
735 Types:
737 Socket = socket()
739 Assoc = #sctp_assoc_change{} | gen_sctp:assoc_id()
740 Address = ip_address()
741 Port = integer() >= 0
742 Returns a list of all address/port number pairs for the other
744 end of an association Assoc of a socket.
745 This function can return multiple addresses for multihomed sock‐
747 ets, such as SCTP sockets. For other sockets it returns a one-
748 element list.
749 Notice that parameter Assoc is by the SCTP Sockets API Exten‐
751 sions defined to be ignored for one-to-one style sockets. What
752 the special value 0 means, hence its behavior for one-to-many
753 style sockets, is unfortunately undefined.
754 port(Socket) -> {ok, Port} | {error, any()}
756 Types:
758 Socket = socket()
760 Port = port_number()
761 Returns the local port number for a socket.
763 setopts(Socket, Options) -> ok | {error, posix()}
765 Types:
767 Socket = socket()
769 Options = [socket_setopt()]
770 Sets one or more options for a socket.
772 The following options are available:
774 {active, true | false | once | N}:
776 If the value is true, which is the default, everything re‐
777 ceived from the socket is sent as messages to the receiving
778 process.
779 If the value is false (passive mode), the process must ex‐
781 plicitly receive incoming data by calling gen_tcp:recv/2,3,
782 gen_udp:recv/2,3, or gen_sctp:recv/1,2 (depending on the
783 type of socket).
784 If the value is once ({active, once}), one data message from
786 the socket is sent to the process. To receive one more mes‐
787 sage, setopts/2 must be called again with option {active,
788 once}.
789 If the value is an integer N in the range -32768 to 32767
791 (inclusive), the value is added to the socket's count of
792 data messages sent to the controlling process. A socket's
793 default message count is 0. If a negative value is speci‐
794 fied, and its magnitude is equal to or greater than the
795 socket's current message count, the socket's message count
796 is set to 0. Once the socket's message count reaches 0, ei‐
797 ther because of sending received data messages to the
798 process or by being explicitly set, the process is then no‐
799 tified by a special message, specific to the type of socket,
800 that the socket has entered passive mode. Once the socket
801 enters passive mode, to receive more messages setopts/2 must
802 be called again to set the socket back into an active mode.
803 When using {active, once} or {active, N}, the socket changes
805 behavior automatically when data is received. This can be
806 confusing in combination with connection-oriented sockets
807 (that is, gen_tcp), as a socket with {active, false} behav‐
808 ior reports closing differently than a socket with {active,
809 true} behavior. To simplify programming, a socket where the
810 peer closed, and this is detected while in {active, false}
811 mode, still generates message {tcp_closed,Socket} when set
812 to {active, once}, {active, true}, or {active, N} mode. It
813 is therefore safe to assume that message
814 {tcp_closed,Socket}, possibly followed by socket port termi‐
815 nation (depending on option exit_on_close) eventually ap‐
816 pears when a socket changes back and forth between {active,
817 true} and {active, false} mode. However, when peer closing
818 is detected it is all up to the underlying TCP/IP stack and
819 protocol.
820 Notice that {active, true} mode provides no flow control; a
822 fast sender can easily overflow the receiver with incoming
823 messages. The same is true for {active, N} mode, while the
824 message count is greater than zero.
825 Use active mode only if your high-level protocol provides
827 its own flow control (for example, acknowledging received
828 messages) or the amount of data exchanged is small. {active,
829 false} mode, use of the {active, once} mode, or {active, N}
830 mode with values of N appropriate for the application pro‐
831 vides flow control. The other side cannot send faster than
832 the receiver can read.
833 {broadcast, Boolean} (UDP sockets):
835 Enables/disables permission to send broadcasts.
836 {buffer, Size}:
838 The size of the user-level buffer used by the driver. Not to
839 be confused with options sndbuf and recbuf, which correspond
840 to the Kernel socket buffers. For TCP it is recommended to
841 have val(buffer) >= val(recbuf) to avoid performance issues
842 because of unnecessary copying. For UDP the same recommenda‐
843 tion applies, but the max should not be larger than the MTU
844 of the network path. val(buffer) is automatically set to the
845 above maximum when recbuf is set. However, as the size set
846 for recbuf usually become larger, you are encouraged to use
847 getopts/2 to analyze the behavior of your operating system.
848 Note that this is also the maximum amount of data that can
850 be received from a single recv call. If you are using higher
851 than normal MTU consider setting buffer higher.
852 {delay_send, Boolean}:
854 Normally, when an Erlang process sends to a socket, the
855 driver tries to send the data immediately. If that fails,
856 the driver uses any means available to queue up the message
857 to be sent whenever the operating system says it can handle
858 it. Setting {delay_send, true} makes all messages queue up.
859 The messages sent to the network are then larger but fewer.
860 The option affects the scheduling of send requests versus
861 Erlang processes instead of changing any real property of
862 the socket. The option is implementation-specific. Defaults
863 to false.
864 {deliver, port | term}:
866 When {active, true}, data is delivered on the form port :
867 {S, {data, [H1,..Hsz | Data]}} or term : {tcp, S, [H1..Hsz |
868 Data]}.
869 {dontroute, Boolean}:
871 Enables/disables routing bypass for outgoing messages.
872 {exit_on_close, Boolean}:
874 This option is set to true by default.
875 The only reason to set it to false is if you want to con‐
877 tinue sending data to the socket after a close is detected,
878 for example, if the peer uses gen_tcp:shutdown/2 to shut
879 down the write side.
880 {header, Size}:
882 This option is only meaningful if option binary was speci‐
883 fied when the socket was created. If option header is speci‐
884 fied, the first Size number bytes of data received from the
885 socket are elements of a list, and the remaining data is a
886 binary specified as the tail of the same list. For example,
887 if Size == 2, the data received matches [Byte1,Byte2|Bi‐
888 nary].
889 {high_msgq_watermark, Size}:
891 The socket message queue is set to a busy state when the
892 amount of data on the message queue reaches this limit. No‐
893 tice that this limit only concerns data that has not yet
894 reached the ERTS internal socket implementation. Defaults to
895 8 kB.
896 Senders of data to the socket are suspended if either the
898 socket message queue is busy or the socket itself is busy.
899 For more information, see options low_msgq_watermark,
901 high_watermark, and low_watermark.
902 Notice that distribution sockets disable the use of
904 high_msgq_watermark and low_msgq_watermark. Instead use the
905 distribution buffer busy limit, which is a similar feature.
906 {high_watermark, Size} (TCP/IP sockets):
908 The socket is set to a busy state when the amount of data
909 queued internally by the ERTS socket implementation reaches
910 this limit. Defaults to 8 kB.
911 Senders of data to the socket are suspended if either the
913 socket message queue is busy or the socket itself is busy.
914 For more information, see options low_watermark,
916 high_msgq_watermark, and low_msqg_watermark.
917 {ipv6_v6only, Boolean}:
919 Restricts the socket to use only IPv6, prohibiting any IPv4
920 connections. This is only applicable for IPv6 sockets (op‐
921 tion inet6).
922 On most platforms this option must be set on the socket be‐
924 fore associating it to an address. It is therefore only rea‐
925 sonable to specify it when creating the socket and not to
926 use it when calling function (setopts/2) containing this de‐
927 scription.
928 The behavior of a socket with this option set to true is the
930 only portable one. The original idea when IPv6 was new of
931 using IPv6 for all traffic is now not recommended by FreeBSD
932 (you can use {ipv6_v6only,false} to override the recommended
933 system default value), forbidden by OpenBSD (the supported
934 GENERIC kernel), and impossible on Windows (which has sepa‐
935 rate IPv4 and IPv6 protocol stacks). Most Linux distros
936 still have a system default value of false. This policy
937 shift among operating systems to separate IPv6 from IPv4
938 traffic has evolved, as it gradually proved hard and compli‐
939 cated to get a dual stack implementation correct and secure.
940 On some platforms, the only allowed value for this option is
942 true, for example, OpenBSD and Windows. Trying to set this
943 option to false, when creating the socket, fails in this
944 case.
945 Setting this option on platforms where it does not exist is
947 ignored. Getting this option with getopts/2 returns no
948 value, that is, the returned list does not contain an
949 {ipv6_v6only,_} tuple. On Windows, the option does not ex‐
950 ist, but it is emulated as a read-only option with value
951 true.
952 Therefore, setting this option to true when creating a
954 socket never fails, except possibly on a platform where you
955 have customized the kernel to only allow false, which can be
956 doable (but awkward) on, for example, OpenBSD.
957 If you read back the option value using getopts/2 and get no
959 value, the option does not exist in the host operating sys‐
960 tem. The behavior of both an IPv6 and an IPv4 socket listen‐
961 ing on the same port, and for an IPv6 socket getting IPv4
962 traffic is then no longer predictable.
963 {keepalive, Boolean}(TCP/IP sockets):
965 Enables/disables periodic transmission on a connected socket
966 when no other data is exchanged. If the other end does not
967 respond, the connection is considered broken and an error
968 message is sent to the controlling process. Defaults to
969 false.
970 {linger, {true|false, Seconds}}:
972 Determines the time-out, in seconds, for flushing unsent
973 data in the close/1 socket call.
974 The first component is if linger is enabled, the second com‐
976 ponent is the flushing time-out, in seconds. There are 3 al‐
977 ternatives:
978 {false, _}:
980 close/1 or shutdown/2 returns immediately, not waiting for
981 data to be flushed, with closing happening in the back‐
982 ground.
983 {true, 0}:
985 Aborts the connection when it is closed. Discards any data
986 still remaining in the send buffers and sends RST to the
987 peer.
988 This avoids TCP's TIME_WAIT state, but leaves open the
990 possibility that another "incarnation" of this connection
991 being created.
992 {true, Time} when Time > 0:
994 close/1 or shutdown/2 will not return until all queued
995 messages for the socket have been successfully sent or the
996 linger timeout (Time) has been reached.
997 {low_msgq_watermark, Size}:
999 If the socket message queue is in a busy state, the socket
1000 message queue is set in a not busy state when the amount of
1001 data queued in the message queue falls below this limit. No‐
1002 tice that this limit only concerns data that has not yet
1003 reached the ERTS internal socket implementation. Defaults to
1004 4 kB.
1005 Senders that are suspended because of either a busy message
1007 queue or a busy socket are resumed when the socket message
1008 queue and the socket are not busy.
1009 For more information, see options high_msgq_watermark,
1011 high_watermark, and low_watermark.
1012 Notice that distribution sockets disable the use of
1014 high_msgq_watermark and low_msgq_watermark. Instead they use
1015 the distribution buffer busy limit, which is a similar fea‐
1016 ture.
1017 {low_watermark, Size} (TCP/IP sockets):
1019 If the socket is in a busy state, the socket is set in a not
1020 busy state when the amount of data queued internally by the
1021 ERTS socket implementation falls below this limit. Defaults
1022 to 4 kB.
1023 Senders that are suspended because of a busy message queue
1025 or a busy socket are resumed when the socket message queue
1026 and the socket are not busy.
1027 For more information, see options high_watermark,
1029 high_msgq_watermark, and low_msgq_watermark.
1030 {mode, Mode :: binary | list}:
1032 Received Packet is delivered as defined by Mode.
1033 {netns, Namespace :: file:filename_all()}:
1035 Sets a network namespace for the socket. Parameter Namespace
1036 is a filename defining the namespace, for example,
1037 "/var/run/netns/example", typically created by command ip
1038 netns add example. This option must be used in a function
1039 call that creates a socket, that is, gen_tcp:connect/3,4,
1040 gen_tcp:listen/2, gen_udp:open/1,2 or gen_sctp:open/0,1,2,
1041 and also getifaddrs/1.
1042 This option uses the Linux-specific syscall setns(), such as
1044 in Linux kernel 3.0 or later, and therefore only exists when
1045 the runtime system is compiled for such an operating system.
1046 The virtual machine also needs elevated privileges, either
1048 running as superuser or (for Linux) having capability
1049 CAP_SYS_ADMIN according to the documentation for setns(2).
1050 However, during testing also CAP_SYS_PTRACE and
1051 CAP_DAC_READ_SEARCH have proven to be necessary.
1052 Example:
1054 setcap cap_sys_admin,cap_sys_ptrace,cap_dac_read_search+epi beam.smp
1056 Notice that the filesystem containing the virtual machine
1058 executable (beam.smp in the example) must be local, mounted
1059 without flag nosetuid, support extended attributes, and the
1060 kernel must support file capabilities. All this runs out of
1061 the box on at least Ubuntu 12.04 LTS, except that SCTP sock‐
1062 ets appear to not support network namespaces.
1063 Namespace is a filename and is encoded and decoded as dis‐
1065 cussed in module file, with the following exceptions:
1066 * Emulator flag +fnu is ignored.
1068 * getopts/2 for this option returns a binary for the file‐
1070 name if the stored filename cannot be decoded. This is
1071 only to occur if you set the option using a binary that
1072 cannot be decoded with the emulator's filename encoding:
1073 file:native_name_encoding/0.
1074 {bind_to_device, Ifname :: binary()}:
1076 Binds a socket to a specific network interface. This option
1077 must be used in a function call that creates a socket, that
1078 is, gen_tcp:connect/3,4, gen_tcp:listen/2, gen_udp:open/1,2,
1079 or gen_sctp:open/0,1,2.
1080 Unlike getifaddrs/0, Ifname is encoded a binary. In the un‐
1082 likely case that a system is using non-7-bit-ASCII charac‐
1083 ters in network device names, special care has to be taken
1084 when encoding this argument.
1085 This option uses the Linux-specific socket option SO_BIND‐
1087 TODEVICE, such as in Linux kernel 2.0.30 or later, and
1088 therefore only exists when the runtime system is compiled
1089 for such an operating system.
1090 Before Linux 3.8, this socket option could be set, but could
1092 not retrieved with getopts/2. Since Linux 3.8, it is read‐
1093 able.
1094 The virtual machine also needs elevated privileges, either
1096 running as superuser or (for Linux) having capability
1097 CAP_NET_RAW.
1098 The primary use case for this option is to bind sockets into
1100 Linux VRF instances.
1101 list:
1103 Received Packet is delivered as a list.
1104 binary:
1106 Received Packet is delivered as a binary.
1107 {nodelay, Boolean}(TCP/IP sockets):
1109 If Boolean == true, option TCP_NODELAY is turned on for the
1110 socket, which means that also small amounts of data are sent
1111 immediately.
1112 This option is not supported for domain = local, but if
1114 inet_backend =/= socket this error will be ignored.
1115 {nopush, Boolean}(TCP/IP sockets):
1117 This translates to TCP_NOPUSH on BSD and to TCP_CORK on
1118 Linux.
1119 If Boolean == true, the corresponding option is turned on
1121 for the socket, which means that small amounts of data are
1122 accumulated until a full MSS-worth of data is available or
1123 this option is turned off.
1124 Note that while TCP_NOPUSH socket option is available on
1126 OSX, its semantics is very different (e.g., unsetting it
1127 does not cause immediate send of accumulated data). Hence,
1128 nopush option is intentionally ignored on OSX.
1129 {packet, PacketType}(TCP/IP sockets):
1131 Defines the type of packets to use for a socket. Possible
1132 values:
1133 raw | 0:
1135 No packaging is done.
1136 1 | 2 | 4:
1138 Packets consist of a header specifying the number of bytes
1139 in the packet, followed by that number of bytes. The
1140 header length can be one, two, or four bytes, and contain‐
1141 ing an unsigned integer in big-endian byte order. Each
1142 send operation generates the header, and the header is
1143 stripped off on each receive operation.
1144 The 4-byte header is limited to 2Gb.
1146 asn1 | cdr | sunrm | fcgi | tpkt | line:
1148 These packet types only have effect on receiving. When
1149 sending a packet, it is the responsibility of the applica‐
1150 tion to supply a correct header. On receiving, however,
1151 one message is sent to the controlling process for each
1152 complete packet received, and, similarly, each call to
1153 gen_tcp:recv/2,3 returns one complete packet. The header
1154 is not stripped off.
1155 The meanings of the packet types are as follows:
1157 * asn1 - ASN.1 BER
1159 * sunrm - Sun's RPC encoding
1161 * cdr - CORBA (GIOP 1.1)
1163 * fcgi - Fast CGI
1165 * tpkt - TPKT format [RFC1006]
1167 * line - Line mode, a packet is a line-terminated with
1169 newline, lines longer than the receive buffer are trun‐
1170 cated
1171 http | http_bin:
1173 The Hypertext Transfer Protocol. The packets are returned
1174 with the format according to HttpPacket described in er‐
1175 lang:decode_packet/3 in ERTS. A socket in passive mode re‐
1176 turns {ok, HttpPacket} from gen_tcp:recv while an active
1177 socket sends messages like {http, Socket, HttpPacket}.
1178 httph | httph_bin:
1180 These two types are often not needed, as the socket auto‐
1181 matically switches from http/http_bin to httph/httph_bin
1182 internally after the first line is read. However, there
1183 can be occasions when they are useful, such as parsing
1184 trailers from chunked encoding.
1185 {packet_size, Integer}(TCP/IP sockets):
1187 Sets the maximum allowed length of the packet body. If the
1188 packet header indicates that the length of the packet is
1189 longer than the maximum allowed length, the packet is con‐
1190 sidered invalid. The same occurs if the packet header is too
1191 large for the socket receive buffer.
1192 For line-oriented protocols (line, http*), option
1194 packet_size also guarantees that lines up to the indicated
1195 length are accepted and not considered invalid because of
1196 internal buffer limitations.
1197 {line_delimiter, Char}(TCP/IP sockets):
1199 Sets the line delimiting character for line-oriented proto‐
1200 cols (line). Defaults to $\n.
1201 {raw, Protocol, OptionNum, ValueBin}:
1203 See below.
1204 {read_packets, Integer}(UDP sockets):
1206 Sets the maximum number of UDP packets to read without in‐
1207 tervention from the socket when data is available. When this
1208 many packets have been read and delivered to the destination
1209 process, new packets are not read until a new notification
1210 of available data has arrived. Defaults to 5. If this param‐
1211 eter is set too high, the system can become unresponsive be‐
1212 cause of UDP packet flooding.
1213 {recbuf, Size}:
1215 The minimum size of the receive buffer to use for the
1216 socket. You are encouraged to use getopts/2 to retrieve the
1217 size set by your operating system.
1218 {recvtclass, Boolean}:
1220 If set to true activates returning the received TCLASS value
1221 on platforms that implements the protocol IPPROTO_IPV6 op‐
1222 tion IPV6_RECVTCLASS or IPV6_2292RECVTCLASS for the socket.
1223 The value is returned as a {tclass,TCLASS} tuple regardless
1224 of if the platform returns an IPV6_TCLASS or an IPV6_RECVT‐
1225 CLASS CMSG value.
1226 For packet oriented sockets that supports receiving ancil‐
1228 lary data with the payload data (gen_udp and gen_sctp), the
1229 TCLASS value is returned in an extended return tuple con‐
1230 tained in an ancillary data list. For stream oriented
1231 sockets (gen_tcp) the only way to get the TCLASS value is if
1232 the platform supports the pktoptions option.
1233 {recvtos, Boolean}:
1235 If set to true activates returning the received TOS value on
1236 platforms that implements the protocol IPPROTO_IP option
1237 IP_RECVTOS for the socket. The value is returned as a
1238 {tos,TOS} tuple regardless of if the platform returns an
1239 IP_TOS or an IP_RECVTOS CMSG value.
1240 For packet oriented sockets that supports receiving ancil‐
1242 lary data with the payload data (gen_udp and gen_sctp), the
1243 TOS value is returned in an extended return tuple contained
1244 in an ancillary data list. For stream oriented sockets
1245 (gen_tcp) the only way to get the TOS value is if the plat‐
1246 form supports the pktoptions option.
1247 {recvttl, Boolean}:
1249 If set to true activates returning the received TTL value on
1250 platforms that implements the protocol IPPROTO_IP option
1251 IP_RECVTTL for the socket. The value is returned as a
1252 {ttl,TTL} tuple regardless of if the platform returns an
1253 IP_TTL or an IP_RECVTTL CMSG value.
1254 For packet oriented sockets that supports receiving ancil‐
1256 lary data with the payload data (gen_udp and gen_sctp), the
1257 TTL value is returned in an extended return tuple contained
1258 in an ancillary data list. For stream oriented sockets
1259 (gen_tcp) the only way to get the TTL value is if the plat‐
1260 form supports the pktoptions option.
1261 {reuseaddr, Boolean}:
1263 Allows or disallows local reuse of port numbers. By default,
1264 reuse is disallowed.
1265 {send_timeout, Integer}:
1267 Only allowed for connection-oriented sockets.
1268 Specifies a longest time to wait for a send operation to be
1270 accepted by the underlying TCP stack. When the limit is ex‐
1271 ceeded, the send operation returns {error,timeout}. How much
1272 of a packet that got sent is unknown; the socket is there‐
1273 fore to be closed whenever a time-out has occurred (see
1274 send_timeout_close below). Defaults to infinity.
1275 {send_timeout_close, Boolean}:
1277 Only allowed for connection-oriented sockets.
1278 Used together with send_timeout to specify whether the
1280 socket is to be automatically closed when the send operation
1281 returns {error,timeout}. The recommended setting is true,
1282 which automatically closes the socket. Defaults to false be‐
1283 cause of backward compatibility.
1284 {show_econnreset, Boolean} (TCP/IP sockets) :
1286 When this option is set to false, which is default, an RST
1287 received from the TCP peer is treated as a normal close (as
1288 though an FIN was sent). A caller to gen_tcp:recv/2 gets
1289 {error, closed}. In active mode, the controlling process re‐
1290 ceives a {tcp_closed, Socket} message, indicating that the
1291 peer has closed the connection.
1292 Setting this option to true allows you to distinguish be‐
1294 tween a connection that was closed normally, and one that
1295 was aborted (intentionally or unintentionally) by the TCP
1296 peer. A call to gen_tcp:recv/2 returns {error, econnreset}.
1297 In active mode, the controlling process receives a {tcp_er‐
1298 ror, Socket, econnreset} message before the usual
1299 {tcp_closed, Socket}, as is the case for any other socket
1300 error. Calls to gen_tcp:send/2 also returns {error, econnre‐
1301 set} when it is detected that a TCP peer has sent an RST.
1302 A connected socket returned from gen_tcp:accept/1 inherits
1304 the show_econnreset setting from the listening socket.
1305 {sndbuf, Size}:
1307 The minimum size of the send buffer to use for the socket.
1308 You are encouraged to use getopts/2, to retrieve the size
1309 set by your operating system.
1310 {priority, Integer}:
1312 Sets the SO_PRIORITY socket level option on platforms where
1313 this is implemented. The behavior and allowed range varies
1314 between different systems. The option is ignored on plat‐
1315 forms where it is not implemented. Use with caution.
1316 {tos, Integer}:
1318 Sets IP_TOS IP level options on platforms where this is im‐
1319 plemented. The behavior and allowed range varies between
1320 different systems. The option is ignored on platforms where
1321 it is not implemented. Use with caution.
1322 {tclass, Integer}:
1324 Sets IPV6_TCLASS IP level options on platforms where this is
1325 implemented. The behavior and allowed range varies between
1326 different systems. The option is ignored on platforms where
1327 it is not implemented. Use with caution.
1328 In addition to these options, raw option specifications can be
1330 used. The raw options are specified as a tuple of arity four,
1331 beginning with tag raw, followed by the protocol level, the op‐
1332 tion number, and the option value specified as a binary. This
1333 corresponds to the second, third, and fourth arguments to the
1334 setsockopt call in the C socket API. The option value must be
1335 coded in the native endianess of the platform and, if a struc‐
1336 ture is required, must follow the structure alignment conven‐
1337 tions on the specific platform.
1338 Using raw socket options requires detailed knowledge about the
1340 current operating system and TCP stack.
1341 Example:
1343 This example concerns the use of raw options. Consider a Linux
1345 system where you want to set option TCP_LINGER2 on protocol
1346 level IPPROTO_TCP in the stack. You know that on this particular
1347 system it defaults to 60 (seconds), but you want to lower it to
1348 30 for a particular socket. Option TCP_LINGER2 is not explicitly
1349 supported by inet, but you know that the protocol level trans‐
1350 lates to number 6, the option number to number 8, and the value
1351 is to be specified as a 32-bit integer. You can use this code
1352 line to set the option for the socket named Sock:
1353 inet:setopts(Sock,[{raw,6,8,<<30:32/native>>}]),
1355 As many options are silently discarded by the stack if they are
1357 specified out of range; it can be a good idea to check that a
1358 raw option is accepted. The following code places the value in
1359 variable TcpLinger2:
1360 {ok,[{raw,6,8,<<TcpLinger2:32/native>>}]}=inet:getopts(Sock,[{raw,6,8,4}]),
1362 Code such as these examples is inherently non-portable, even
1364 different versions of the same OS on the same platform can re‐
1365 spond differently to this kind of option manipulation. Use with
1366 care.
1367 Notice that the default options for TCP/IP sockets can be
1369 changed with the Kernel configuration parameters mentioned in
1370 the beginning of this manual page.
1371 sockname(Socket :: socket()) ->
1373 {ok,
1374 {ip_address(), port_number()} |
1375 returned_non_ip_address()} |
1376 {error, posix()}
1377 Returns the local address and port number for a socket.
1379 Notice that for SCTP sockets this function returns only one of
1381 the socket addresses. Function socknames/1,2 returns all.
1382 socknames(Socket :: socket()) ->
1384 {ok,
1385 [{ip_address(), port_number()} |
1386 returned_non_ip_address()]} |
1387 {error, posix()}
1388 Equivalent to socknames(Socket, 0).
1390 socknames(Socket, Assoc) ->
1392 {ok, [{Address, Port}]} | {error, posix()}
1393 Types:
1395 Socket = socket()
1397 Assoc = #sctp_assoc_change{} | gen_sctp:assoc_id()
1398 Address = ip_address()
1399 Port = integer() >= 0
1400 Returns a list of all local address/port number pairs for a
1402 socket for the specified association Assoc.
1403 This function can return multiple addresses for multihomed sock‐
1405 ets, such as SCTP sockets. For other sockets it returns a one-
1406 element list.
1407 Notice that parameter Assoc is by the SCTP Sockets API Exten‐
1409 sions defined to be ignored for one-to-one style sockets. For
1410 one-to-many style sockets, the special value 0 is defined to
1411 mean that the returned addresses must be without any particular
1412 association. How different SCTP implementations interpret this
1413 varies somewhat.
1414
1416 * e2big - Too long argument list
1417 * eacces - Permission denied
1419 * eaddrinuse - Address already in use
1421 * eaddrnotavail - Cannot assign requested address
1423 * eadv - Advertise error
1425 * eafnosupport - Address family not supported by protocol family
1427 * eagain - Resource temporarily unavailable
1429 * ealign - EALIGN
1431 * ealready - Operation already in progress
1433 * ebade - Bad exchange descriptor
1435 * ebadf - Bad file number
1437 * ebadfd - File descriptor in bad state
1439 * ebadmsg - Not a data message
1441 * ebadr - Bad request descriptor
1443 * ebadrpc - Bad RPC structure
1445 * ebadrqc - Bad request code
1447 * ebadslt - Invalid slot
1449 * ebfont - Bad font file format
1451 * ebusy - File busy
1453 * echild - No children
1455 * echrng - Channel number out of range
1457 * ecomm - Communication error on send
1459 * econnaborted - Software caused connection abort
1461 * econnrefused - Connection refused
1463 * econnreset - Connection reset by peer
1465 * edeadlk - Resource deadlock avoided
1467 * edeadlock - Resource deadlock avoided
1469 * edestaddrreq - Destination address required
1471 * edirty - Mounting a dirty fs without force
1473 * edom - Math argument out of range
1475 * edotdot - Cross mount point
1477 * edquot - Disk quota exceeded
1479 * eduppkg - Duplicate package name
1481 * eexist - File already exists
1483 * efault - Bad address in system call argument
1485 * efbig - File too large
1487 * ehostdown - Host is down
1489 * ehostunreach - Host is unreachable
1491 * eidrm - Identifier removed
1493 * einit - Initialization error
1495 * einprogress - Operation now in progress
1497 * eintr - Interrupted system call
1499 * einval - Invalid argument
1501 * eio - I/O error
1503 * eisconn - Socket is already connected
1505 * eisdir - Illegal operation on a directory
1507 * eisnam - Is a named file
1509 * el2hlt - Level 2 halted
1511 * el2nsync - Level 2 not synchronized
1513 * el3hlt - Level 3 halted
1515 * el3rst - Level 3 reset
1517 * elbin - ELBIN
1519 * elibacc - Cannot access a needed shared library
1521 * elibbad - Accessing a corrupted shared library
1523 * elibexec - Cannot exec a shared library directly
1525 * elibmax - Attempting to link in more shared libraries than system
1527 limit
1528 * elibscn - .lib section in a.out corrupted
1530 * elnrng - Link number out of range
1532 * eloop - Too many levels of symbolic links
1534 * emfile - Too many open files
1536 * emlink - Too many links
1538 * emsgsize - Message too long
1540 * emultihop - Multihop attempted
1542 * enametoolong - Filename too long
1544 * enavail - Unavailable
1546 * enet - ENET
1548 * enetdown - Network is down
1550 * enetreset - Network dropped connection on reset
1552 * enetunreach - Network is unreachable
1554 * enfile - File table overflow
1556 * enoano - Anode table overflow
1558 * enobufs - No buffer space available
1560 * enocsi - No CSI structure available
1562 * enodata - No data available
1564 * enodev - No such device
1566 * enoent - No such file or directory
1568 * enoexec - Exec format error
1570 * enolck - No locks available
1572 * enolink - Link has been severed
1574 * enomem - Not enough memory
1576 * enomsg - No message of desired type
1578 * enonet - Machine is not on the network
1580 * enopkg - Package not installed
1582 * enoprotoopt - Bad protocol option
1584 * enospc - No space left on device
1586 * enosr - Out of stream resources or not a stream device
1588 * enosym - Unresolved symbol name
1590 * enosys - Function not implemented
1592 * enotblk - Block device required
1594 * enotconn - Socket is not connected
1596 * enotdir - Not a directory
1598 * enotempty - Directory not empty
1600 * enotnam - Not a named file
1602 * enotsock - Socket operation on non-socket
1604 * enotsup - Operation not supported
1606 * enotty - Inappropriate device for ioctl
1608 * enotuniq - Name not unique on network
1610 * enxio - No such device or address
1612 * eopnotsupp - Operation not supported on socket
1614 * eperm - Not owner
1616 * epfnosupport - Protocol family not supported
1618 * epipe - Broken pipe
1620 * eproclim - Too many processes
1622 * eprocunavail - Bad procedure for program
1624 * eprogmismatch - Wrong program version
1626 * eprogunavail - RPC program unavailable
1628 * eproto - Protocol error
1630 * eprotonosupport - Protocol not supported
1632 * eprototype - Wrong protocol type for socket
1634 * erange - Math result unrepresentable
1636 * erefused - EREFUSED
1638 * eremchg - Remote address changed
1640 * eremdev - Remote device
1642 * eremote - Pathname hit remote filesystem
1644 * eremoteio - Remote I/O error
1646 * eremoterelease - EREMOTERELEASE
1648 * erofs - Read-only filesystem
1650 * erpcmismatch - Wrong RPC version
1652 * erremote - Object is remote
1654 * eshutdown - Cannot send after socket shutdown
1656 * esocktnosupport - Socket type not supported
1658 * espipe - Invalid seek
1660 * esrch - No such process
1662 * esrmnt - Srmount error
1664 * estale - Stale remote file handle
1666 * esuccess - Error 0
1668 * etime - Timer expired
1670 * etimedout - Connection timed out
1672 * etoomanyrefs - Too many references
1674 * etxtbsy - Text file or pseudo-device busy
1676 * euclean - Structure needs cleaning
1678 * eunatch - Protocol driver not attached
1680 * eusers - Too many users
1682 * eversion - Version mismatch
1684 * ewouldblock - Operation would block
1686 * exdev - Cross-domain link
1688 * exfull - Message tables full
1690 * nxdomain - Hostname or domain name cannot be found
1692Ericsson AB kernel 8.3.2 inet(3)