View Source socket (kernel v9.3)
Socket interface.
This module provides an API for network socket. Functions are provided to create, delete and manipulate the sockets as well as sending and receiving data on them.
The intent is that it shall be as "close as possible" to the OS level socket
interface. The only significant addition is that some of the functions, e.g.
recv/3, have a time-out argument.
Note
Some functions allow for an asynchronous call. This is achieved by setting the
Timeoutargument tonowaitor to a (select or completion) handle.For instance, if calling the
recv/3function with Timeout set tonowait(recv(Sock, 0, nowait)) when there is actually nothing to read, it will return with either one of:
- ____ -
{completion,CompletionInfo}- ____ -
{select,SelectInfo}
CompletionInfocontains the CompletionHandle andSelectInfocontains the SelectHandle.We have two different implementations. One on Unix (
select, based directly on the synchronous standard socket interface) and one on Windows (completion, based on the asynchronous I/O Completion Ports).These two implementations have a slightly different behaviour and message interface.
The difference will only manifest for the user, if calls are made with the timeout argument set to 'nowait' (see above).
When an completion message is received (with the result of the operation), that means that the operation (connect, send, recv, ...) has been completed (successfully or otherwise). When a select message is received, that only means that the operation can now be completed, via a call to, for instance,
connect/1.The completion message has the format:
- ____ -
{'$socket', socket(), completion, {CompletionHandle, CompletionStatus}}The select message has the format:
- ____ -
{'$socket', socket(), select, SelectHandle}Note that, on select "system", all other users are locked out until the 'current user' has called the function (
recvfor instance) and its return value shows that the operation has completed. Such an operation can also be cancelled withcancel/2.Instead of
Timeout = nowaitit is equivalent to create aSelectHandleorCompletionHandlewithmake_ref()and give asTimeout. This will then be theHandlein the 'completion' or 'select' message, which enables a compiler optimization for receiving a message containing a newly createdreference/0(ignore the part of the message queue that had arrived before the thereference/0was created).Another message the user must be prepared for (when making asynchronous calls) is the
abortmessage:
- ____ -
{'$socket', socket(), abort, Info}This message indicates that the (asynchronous) operation has been aborted. If, for instance, the socket has been closed (by another process),
Infowill be{SelectHandle, closed}.
Note
The Windows support has currently pre-release status.
Support for IPv6 has been implemented but not fully tested.
SCTP has only been partly implemented (and not tested).
Examples
client(SAddr, SPort) ->
{ok, Sock} = socket:open(inet, stream, tcp),
ok = socket:connect(Sock, #{family => inet,
addr => SAddr,
port => SPort}),
Msg = <<"hello">>,
ok = socket:send(Sock, Msg),
ok = socket:shutdown(Sock, write),
{ok, Msg} = socket:recv(Sock),
ok = socket:close(Sock).
server(Addr, Port) ->
{ok, LSock} = socket:open(inet, stream, tcp),
ok = socket:bind(LSock, #{family => inet,
port => Port,
addr => Addr}),
ok = socket:listen(LSock),
{ok, Sock} = socket:accept(LSock),
{ok, Msg} = socket:recv(Sock),
ok = socket:send(Sock, Msg),
ok = socket:close(Sock),
ok = socket:close(LSock).Summary
Types
Control messages (ancillary messages) returned by
recvmsg/1,2,3,5.
Control messages (ancillary messages) accepted by
sendmsg/2,3,4.
A reference/0 that uniquely identifies the (completion) operation, contained
in the returned completion_info/0.
Returned by an operation that requires the caller to wait for a
completion message containing the
CompletionHandle and the result of the operation;
the CompletionStatus.
A tag that describes the ongoing (completion) operation (= function name),
contained in the returned completion_info/0.
Extended Error Info. A term containing additional (error) info if the socket nif has been configured to produce it.
The smallest allowed iov_max value according to POSIX is 16, but check your
platform documentation to be sure.
Corresponds to the C struct ip_mreq for managing multicast groups.
Corresponds to the C struct ip_mreq_source for managing multicast groups.
Corresponds to the C struct ip_msfilter for managing multicast source
filtering (RFC 3376).
Lowercase atom/0 values corresponding to the C library constants
IP_PMTUDISC_*. Some constant(s) may be unsupported by the platform.
Lowercase atom/0 values corresponding to the C library constants IPTOS_*.
Some constant(s) may be unsupported by the platform.
The value default is only valid to set and is translated to the C value
-1, meaning the route default.
Corresponds to the C struct ipv6_mreq for managing multicast groups. See also
RFC 2553.
Lowercase atom/0 values corresponding to the C library constants
IPV6_PMTUDISC_*. Some constant(s) may be unsupported by the platform.
The OS protocol levels for, for example, socket options and control messages, with the following names in the OS header files
Corresponds to the C struct linger for managing the
socket option {socket, linger}.
Flags corresponding to the message flag constants on the platform. The flags are
lowercase and the constants are uppercase with the prefix MSG_.
Message returned by recvmsg/1,2,3,5.
Message sent by sendmsg/2,3,4.
These are socket options for the otp protocol level, that is {otp, Name}
options, above all OS protocol levels. They affect Erlang/OTP's socket
implementation.
The POSIX error codes originates from the OS level socket interface.
An atom/0 means any protocol as enumerated by the C library call
getprotoent() on the platform, or at least the supported ones of
ip | ipv6 | tcp | udp | sctp.
Corresponds to the C struct sctp_assocparams.
Corresponds to the C struct sctp_event_subscribe.
Corresponds to the C struct sctp_initmsg.
Corresponds to the C struct sctp_rtoinfo.
A reference/0 that uniquely identifies the (select) operation, contained in
the returned select_info/0.
Returned by an operation that requires the caller to wait for a
select message containing the
SelectHandle.
A tag that describes the (select) operation (= function name), contained in the
returned select_info/0.
The path element will always be a binary when returned from this module.
When supplied to an API function in this module it may be a string/0, which
will be encoded into a binary according to the
native file name encoding on the platform.
As returned by open/1,2,3,4 and accept/1,2.
An opaque socket handle unique for the socket.
Socket option on the form {Level, Opt} where the OS protocol Level =
level/0 and Opt is a socket option on that protocol level.
Corresponds to the C struct timeval. The field sec holds seconds, and usec
microseconds.
Functions
Equivalent to accept/2
Bind a name to a socket.
Cancel an asynchronous (select) request.
If MRef is a reference that the calling process obtained by calling
monitor/1, this monitor is turned off. If the monitoring is already turned
off, nothing happens.
Closes the socket.
This function finalizes a connection setup on a socket, after calling
connect(_, _, nowait | select_handle()) that returned
{select, SelectInfo}, and receiving the select message
{'$socket', Socket, select, SelectHandle}, and returns whether the connection
setup was successful or not.
Equivalent to connect/3
Gets a socket option from the protocol level otp, which is this
implementation's level above the OS protocol layers.
getopt(Socket, Level, Opt) -> ok | {error, Reason}
Gets a socket option that may be unknown to our implementation, or that has a type not compatible with our implementation, that is; in "native mode".
Print all sockets in table format in the erlang shell.
Print all sockets in table format in the erlang shell. What information is
included is defined by InfoKeys.
Print a selection, based on domain, of the sockets in table format in the erlang
shell. What information is included is defined by InfoKeys.
Get miscellaneous info about the socket library.
Get miscellaneous info about the socket.
Retrieve socket (device) parameters.
Set socket (device) parameters. This function sets a specific parameter,
according to SetRequest argument. The third argument is the "key", identifying
the interface (usually the name of the interface), and the fourth is the "new"
value.
Equivalent to is_supported/2
This function retrieves information about what the platform supports, such as if SCTP is supported, or if a socket options are supported.
Equivalent to listen/2
Listen for connections on a socket.
Start monitor the socket Socket.
Returns the number of active sockets.
Creates an endpoint (socket) for communication based on an already existing file
descriptor. The function attempts to retrieve domain, type and protocol
from the system. This is however not possible on all platforms, and they should
then be specified in Opts.
Creates an endpoint (socket) for communication.
Creates an endpoint (socket) for communication.
Returns the address of the peer connected to the socket.
Equivalent to recv/4
Equivalent to recvfrom/4
Equivalent to recvfrom/4
Equivalent to recvfrom/4
Equivalent to recvmsg/5
Equivalent to recvmsg/5
Equivalent to send/4
sendfile(Socket, FileHandle) -> Result
Depending on the Timeout argument; the same as
sendfile(Socket, FileHandle, 0, 0, infinity), sendfile(Socket, FileHandle, 0, 0, Timeout), or
sendfile(Socket, FileHandle, 0, 0, SelectHandle), that
is: send all data in the file to the socket, with the given Timeout.
The same as
sendfile(Socket, FileHandle, Offset, Count, infinity), that
is: send the file data at Offset and Count to the socket, without time-out
other than from the platform's network stack.
Equivalent to sendmsg/4
Equivalent to sendto/4
Sets a socket option in the protocol level otp, which is this implementation's
level above the OS protocol layers.
setopt(Socket, Level, Opt, Value) -> ok | {error, Reason}
Sets a socket option that may be unknown to our implementation, or that has a type not compatible with our implementation, that is; in "native mode".
Shut down all or part of a full-duplex connection.
Returns the current address to which the socket is bound.
Equivalent to supports/2
Equivalent to supports/2
These functions function retrieves information about what the platform supports, such which platform features or which socket options, are supported.
Equivalent to which_sockets/1
Returns a list of all sockets, according to the filter rule.
Types
-type cmsg_recv() :: #{level := socket, type := timestamp, data := binary(), value => timeval()} | #{level := socket, type := rights, data := binary()} | #{level := socket, type := credentials, data := binary()} | #{level := ip, type := tos, data := binary(), value => ip_tos() | integer()} | #{level := ip, type := recvtos, data := binary(), value := ip_tos() | integer()} | #{level := ip, type := ttl, data := binary(), value => integer()} | #{level := ip, type := recvttl, data := binary(), value := integer()} | #{level := ip, type := pktinfo, data := binary(), value => ip_pktinfo()} | #{level := ip, type := origdstaddr, data := binary(), value => sockaddr_recv()} | #{level := ip, type := recverr, data := binary(), value => extended_err()} | #{level := ipv6, type := hoplimit, data := binary(), value => integer()} | #{level := ipv6, type := pktinfo, data := binary(), value => ipv6_pktinfo()} | #{level := ipv6, type := recverr, data := binary(), value => extended_err()} | #{level := ipv6, type := tclass, data := binary(), value => integer()}.
Control messages (ancillary messages) returned by
recvmsg/1,2,3,5.
A control message has got a data field with a native (binary) value for the
message data, and may also have a decoded value field if this socket library
successfully decoded the data.
-type cmsg_send() :: #{level := socket, type := timestamp, data => native_value(), value => timeval()} | #{level := socket, type := rights, data := native_value()} | #{level := socket, type := credentials, data := native_value()} | #{level := ip, type := tos, data => native_value(), value => ip_tos() | integer()} | #{level := ip, type := ttl, data => native_value(), value => integer()} | #{level := ip, type := hoplimit, data => native_value(), value => integer()} | #{level := ipv6, type := tclass, data => native_value(), value => integer()}.
Control messages (ancillary messages) accepted by
sendmsg/2,3,4.
A control message may for some message types have a value field with a
symbolic value, or a data field with a native value, that has to be binary
compatible what is defined in the platform's header files.
-type completion_handle() :: reference().
A reference/0 that uniquely identifies the (completion) operation, contained
in the returned completion_info/0.
-type completion_info() :: {completion_info, CompletionTag :: completion_tag(), CompletionHandle :: completion_handle()}.
Returned by an operation that requires the caller to wait for a
completion message containing the
CompletionHandle and the result of the operation;
the CompletionStatus.
-type completion_tag() :: accept | connect | recv | recvfrom | recvmsg | send | sendto | sendmsg.
A tag that describes the ongoing (completion) operation (= function name),
contained in the returned completion_info/0.
-type domain() :: inet | inet6 | local | unspec.
A lowercase atom/0 representing a protocol domain on the platform named
AF_* (or PF_*).
The calls supports(),
is_supported(ipv6) and
is_supported(local) tells if the IPv6 protocol for the
inet6 protocol domain / address family, and if the local protocol domain /
address family is supported by the platform's header files.
-type ee_origin() :: none | local | icmp | icmp6.
-type eei() :: #{info := econnreset | econnaborted | netname_deleted | too_many_cmds | atom(), raw_info := term()}.
Extended Error Info. A term containing additional (error) info if the socket nif has been configured to produce it.
-type extended_err() :: #{error := posix(), origin := icmp, type := dest_unreach, code := icmp_dest_unreach() | 0..255, info := 0..4294967295, data := 0..4294967295, offender := sockaddr_recv()} | #{error := posix(), origin := icmp, type := time_exceeded | 0..255, code := 0..255, info := 0..4294967295, data := 0..4294967295, offender := sockaddr_recv()} | #{error := posix(), origin := icmp6, type := dest_unreach, code := icmpv6_dest_unreach() | 0..255, info := 0..4294967295, data := 0..4294967295, offender := sockaddr_recv()} | #{error := posix(), origin := icmp6, type := pkt_toobig | time_exceeded | 0..255, code := 0..255, info := 0..4294967295, data := 0..4294967295, offender := sockaddr_recv()} | #{error := posix(), origin := ee_origin() | 0..255, type := 0..255, code := 0..255, info := 0..4294967295, data := 0..4294967295, offender := sockaddr_recv()}.
-type hatype() :: netrom | eether | ether | ax25 | pronet | chaos | ieee802 | arcnet | appletlk | dlci | atm | metricom | ieee1394 | eui64 | infiniband | tunnel | tunnel6 | loopback | localtlk | none | void | non_neg_integer().
-type icmp_dest_unreach() ::
net_unreach | host_unreach | port_unreach | frag_needed | net_unknown | host_unknown.
-type icmpv6_dest_unreach() ::
noroute | adm_prohibited | not_neighbour | addr_unreach | port_unreach | policy_fail |
reject_route.
-type in6_addr() :: {0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535, 0..65535}.
-type in6_flow_info() :: 0..1048575.
-type in6_scope_id() :: 0..4294967295.
-type in_addr() :: {0..255, 0..255, 0..255, 0..255}.
-type info() :: #{counters := #{atom() := non_neg_integer()}, iov_max := non_neg_integer(), use_registry := boolean(), io_backend := #{name := atom()}}.
The smallest allowed iov_max value according to POSIX is 16, but check your
platform documentation to be sure.
-type info_keys() ::
[domain | type | protocol | fd | owner | local_address | remote_address | recv | sent | state].
Defines the information elements of the table(s) printed by the i/0, i/1 and
i/2 functions.
-type invalid() :: {invalid, What :: term()}.
-type ioctl_device_flag() ::
up | broadcast | debug | loopback | pointopoint | notrailers | knowsepoch | running | noarp |
promisc | allmulti | master | oactive | slave | simplex | link0 | link1 | link2 | multicast |
portsel | automedia | cantconfig | ppromisc | dynamic | monitor | staticarp | dying |
renaming | nogroup | lower_up | dormant | echo.
-type ioctl_device_map() :: #{mem_start := non_neg_integer(), mem_end := non_neg_integer(), base_addr := non_neg_integer(), irq := non_neg_integer(), dma := non_neg_integer(), port := non_neg_integer()}.
Corresponds to the C struct ip_mreq for managing multicast groups.
-type ip_mreq_source() :: #{multiaddr := in_addr(), interface := in_addr(), sourceaddr := in_addr()}.
Corresponds to the C struct ip_mreq_source for managing multicast groups.
-type ip_msfilter() :: #{multiaddr := in_addr(), interface := in_addr(), mode := include | exclude, slist := [in_addr()]}.
Corresponds to the C struct ip_msfilter for managing multicast source
filtering (RFC 3376).
-type ip_pktinfo() :: #{ifindex := non_neg_integer(), spec_dst := in_addr(), addr := in_addr()}.
-type ip_pmtudisc() :: want | dont | do | probe.
Lowercase atom/0 values corresponding to the C library constants
IP_PMTUDISC_*. Some constant(s) may be unsupported by the platform.
-type ip_tos() :: lowdelay | throughput | reliability | mincost.
Lowercase atom/0 values corresponding to the C library constants IPTOS_*.
Some constant(s) may be unsupported by the platform.
-type ipv6_hops() :: default | 0..255.
The value default is only valid to set and is translated to the C value
-1, meaning the route default.
-type ipv6_mreq() :: #{multiaddr := in6_addr(), interface := non_neg_integer()}.
Corresponds to the C struct ipv6_mreq for managing multicast groups. See also
RFC 2553.
-type ipv6_pmtudisc() :: want | dont | do | probe.
Lowercase atom/0 values corresponding to the C library constants
IPV6_PMTUDISC_*. Some constant(s) may be unsupported by the platform.
-type level() :: socket | protocol().
The OS protocol levels for, for example, socket options and control messages, with the following names in the OS header files:
socket-SOL_SOCKETwith options namedSO_*.ip-IPPROTO_IPa.k.aSOL_IPwith options namedIP_*.ipv6-IPPROTO_IPV6a.k.aSOL_IPV6with options namedIPV6_*.tcp-IPPROTO_TCPwith options namedTCP_*.udp-IPPROTO_UDPwith options namedUDP_*.sctp-IPPROTO_SCTPwith options namedSCTP_*.
There are many other possible protocols, but the ones above are those for which this socket library implements socket options and/or control messages.
All protocols known to the OS are enumerated when the Erlang VM is started. See
the OS man page for protocols(5). The protocol level 'socket' is always
implemented as SOL_SOCKET and all the others mentioned in the list above are
valid, if supported by the platform, enumerated or not.
The calls supports() and
is_supported(protocols, Protocol) can be used to find out
if protocols ipv6 and/or sctp are supported according to the platform's
header files.
-type linger() :: #{onoff := boolean(), linger := non_neg_integer()}.
Corresponds to the C struct linger for managing the
socket option {socket, linger}.
-type msg_flag() ::
cmsg_cloexec | confirm | ctrunc | dontroute | eor | errqueue | more | oob | peek | trunc.
Flags corresponding to the message flag constants on the platform. The flags are
lowercase and the constants are uppercase with the prefix MSG_.
Some flags are only used for sending, some only for receiving, some in received
control messages, and some for several of these. Not all flags are supported on
all platforms. See the platform's documentation,
supports(msg_flags), and
is_supported(msg_flags, MsgFlag).
-type msg_recv() :: #{addr => sockaddr_recv(), iov := erlang:iovec(), ctrl := [cmsg_recv() | #{level := level() | integer(), type := integer(), data := binary()}], flags := [msg_flag() | integer()]}.
Message returned by recvmsg/1,2,3,5.
Corresponds to a C struct msghdr, see your platform documentation for
recvmsg(2).
addr- Optional peer address, used on unconnected sockets. Corresponds tomsg_nameandmsg_namelenfields of astruct msghdr. IfNULLthe map key is not present.iov- Data as a list of binaries. Themsg_iovandmsg_iovlenfields of astruct msghdr.ctrl- A possibly empty list of control messages (CMSG). Corresponds to themsg_controlandmsg_controllenfields of astruct msghdr.flags- Message flags. Corresponds to themsg_flagsfield of astruct msghdr. Unknown flags, if any, are returned in oneinteger/0, last in the containing list.
-type msg_send() :: #{addr => sockaddr(), iov := erlang:iovec(), ctrl => [cmsg_send() | #{level := level() | integer(), type := integer(), data := binary()}]}.
Message sent by sendmsg/2,3,4.
Corresponds to a C struct msghdr, see your platform documentation for
sendmsg(2).
addr- Optional peer address, used on unconnected sockets. Corresponds tomsg_nameandmsg_namelenfields of astruct msghdr. If not used they are set toNULL,0.iov- Mandatory data as a list of binaries. Themsg_iovandmsg_iovlenfields of astruct msghdr.ctrl- Optional list of control messages (CMSG). Corresponds to themsg_controlandmsg_controllenfields of astruct msghdr. If not used they are set toNULL,0.
The msg_flags field of the struct msghdr is set to 0.
-type otp_socket_option() ::
debug | iow | controlling_process | rcvbuf | rcvctrlbuf | sndctrlbuf | meta | use_registry |
fd | domain.
These are socket options for the otp protocol level, that is {otp, Name}
options, above all OS protocol levels. They affect Erlang/OTP's socket
implementation.
debug-boolean/0- Activate debug printout.iow-boolean/0- Inform On Wrap of statistics counters.controlling_process-pid/0- The socket "owner". Only the current controlling process can set this option.rcvbuf-BufSize :: (default | integer()>0) | {N :: integer()>0, BufSize :: (default | integer()>0)}- Receive buffer size.The value
defaultis only valid to set.Nspecifies the number of read attempts to do in a tight loop before assuming no more data is pending.This is the allocation size for the receive buffer used when calling the OS protocol stack's receive API, when no specific size (size 0) is requested. When the receive function returns the receive buffer is reallocated to the actually received size. If the data is copied or shrinked in place is up to the allocator, and can to some extent be configured in the Erlang VM.
The similar socket option;
{socket,rcvbuf}is a related option for the OS' protocol stack that on Unix corresponds toSOL_SOCKET,SO_RCVBUF.rcvctrlbuf-BufSize :: (default | integer()>0)- Allocation size for the ancillary data buffer used when calling the OS protocol stack's receive API.The value
defaultis only valid to set.sndctrlbuf-BufSize :: (default | integer()>0)- Allocation size for the ancillary data buffer used when calling the OS protocol stack's sendmsg API.The value
defaultis only valid to set.It is the user's responsibility to set a buffer size that has room for the encoded ancillary data in the message to send.
See sendmsg and also the
ctrlfield of themsg_send/0type.fd-integer/0- Only valid to get. The OS protocol levels' socket descriptor. Functionsopen/1,2can be used to create a socket according to this module from an existing OS socket descriptor.use_registry-boolean/0- Only valid to get. The value is set when the socket is created withopen/2oropen/4.
Options not described here are intentionally undocumented and for Erlang/OTP internal use only.
-type packet_type() :: host | broadcast | multicast | otherhost | outgoing | loopback | user | kernel | fastroute | non_neg_integer().
-type port_number() :: 0..65535.
-type posix() :: inet:posix().
The POSIX error codes originates from the OS level socket interface.
-type protocol() :: atom().
An atom/0 means any protocol as enumerated by the C library call
getprotoent() on the platform, or at least the supported ones of
ip | ipv6 | tcp | udp | sctp.
See open/2,3,4
The call supports(protocols) returns which protocols are
supported, and is_supported(protocols, Protocol) tells if
Protocol is among the enumerated.
-type sctp_assocparams() :: #{assoc_id := integer(), asocmaxrxt := 0..65535, numbe_peer_destinations := 0..65535, peer_rwnd := 0..4294967295, local_rwnd := 0..4294967295, cookie_life := 0..4294967295}.
Corresponds to the C struct sctp_assocparams.
-type sctp_event_subscribe() :: #{data_io := boolean(), association := boolean(), address := boolean(), send_failure := boolean(), peer_error := boolean(), shutdown := boolean(), partial_delivery := boolean(), adaptation_layer => boolean(), sender_dry => boolean()}.
Corresponds to the C struct sctp_event_subscribe.
Not all fields are implemented on all platforms; unimplemented fields are ignored, but implemented fields are mandatory. Note that the '_event' suffixes have been stripped from the C struct field names, for convenience.
-type sctp_initmsg() ::
#{num_ostreams := 0..65535,
max_instreams := 0..65535,
max_attempts := 0..65535,
max_init_timeo := 0..65535}.
Corresponds to the C struct sctp_initmsg.
-type sctp_rtoinfo() :: #{assoc_id := integer(), initial := 0..4294967295, max := 0..4294967295, min := 0..4294967295}.
Corresponds to the C struct sctp_rtoinfo.
-type select_handle() :: reference().
A reference/0 that uniquely identifies the (select) operation, contained in
the returned select_info/0.
-type select_info() :: {select_info, SelectTag :: select_tag(), SelectHandle :: select_handle()}.
Returned by an operation that requires the caller to wait for a
select message containing the
SelectHandle.
-type select_tag() :: accept | connect | recv | recvfrom | recvmsg | send | sendto | sendmsg | sendfile | {recv | recvfrom | recvmsg | send | sendto | sendmsg | sendfile, ContData :: term()}.
A tag that describes the (select) operation (= function name), contained in the
returned select_info/0.
-type sockaddr() :: sockaddr_in() | sockaddr_in6() | sockaddr_un() | sockaddr_ll() | sockaddr_dl() | sockaddr_unspec() | sockaddr_native().
-type sockaddr_dl() :: #{family := link, index := non_neg_integer(), type := non_neg_integer(), nlen := non_neg_integer(), alen := non_neg_integer(), slen := non_neg_integer(), data := binary()}.
-type sockaddr_in6() :: #{family := inet6, port := port_number(), addr := any | loopback | in6_addr(), flowinfo := in6_flow_info(), scope_id := in6_scope_id()}.
-type sockaddr_in() :: #{family := inet, port := port_number(), addr := any | broadcast | loopback | in_addr()}.
-type sockaddr_ll() :: #{family := packet, protocol := non_neg_integer(), ifindex := integer(), pkttype := packet_type(), hatype := hatype(), addr := binary()}.
The path element will always be a binary when returned from this module.
When supplied to an API function in this module it may be a string/0, which
will be encoded into a binary according to the
native file name encoding on the platform.
A terminating zero character will be appended before the address path is given to the OS, and the terminating zero will be stripped before giving the address path to the caller.
Linux's non-portable abstract socket address extension is handled by not doing any terminating zero processing in either direction, if the first byte of the address is zero.
-type sockaddr_unspec() :: #{family := unspec, addr := binary()}.
-type socket() :: {'$socket', socket_handle()}.
As returned by open/1,2,3,4 and accept/1,2.
-type socket_counters() :: #{read_byte := non_neg_integer(), read_fails := non_neg_integer(), read_pkg := non_neg_integer(), read_pkg_max := non_neg_integer(), read_tries := non_neg_integer(), read_waits := non_neg_integer(), write_byte := non_neg_integer(), write_fails := non_neg_integer(), write_pkg := non_neg_integer(), write_pkg_max := non_neg_integer(), write_tries := non_neg_integer(), write_waits := non_neg_integer(), sendfile => non_neg_integer(), sendfile_byte => non_neg_integer(), sendfile_fails => non_neg_integer(), sendfile_max => non_neg_integer(), sendfile_pkg => non_neg_integer(), sendfile_pkg_max => non_neg_integer(), sendfile_tries => non_neg_integer(), sendfile_waits => non_neg_integer(), acc_success := non_neg_integer(), acc_fails := non_neg_integer(), acc_tries := non_neg_integer(), acc_waits := non_neg_integer()}.
-opaque socket_handle()
An opaque socket handle unique for the socket.
-type socket_info() :: #{domain := domain() | integer(), type := type() | integer(), protocol := protocol() | integer(), owner := pid(), ctype := normal | fromfd | {fromfd, integer()}, counters := socket_counters(), num_readers := non_neg_integer(), num_writers := non_neg_integer(), num_acceptors := non_neg_integer(), writable := boolean(), readable := boolean(), rstates := [atom()], wstates := [atom()]}.
-type socket_option() ::
{Level :: socket,
Opt ::
acceptconn | acceptfilter | bindtodevice | broadcast | bsp_state | busy_poll | debug |
domain | dontroute | error | exclusiveaddruse | keepalive | linger | mark | maxdg |
max_msg_size | oobinline | passcred | peek_off | peercred | priority | protocol |
rcvbuf | rcvbufforce | rcvlowat | rcvtimeo | reuseaddr | reuseport | rxq_ovfl | setfib |
sndbuf | sndbufforce | sndlowat | sndtimeo | timestamp | type} |
{Level :: ip,
Opt ::
add_membership | add_source_membership | block_source | dontfrag | drop_membership |
drop_source_membership | freebind | hdrincl | minttl | msfilter | mtu | mtu_discover |
multicast_all | multicast_if | multicast_loop | multicast_ttl | nodefrag | options |
pktinfo | recvdstaddr | recverr | recvif | recvopts | recvorigdstaddr | recvtos |
recvttl | retopts | router_alert | sndsrcaddr | tos | transparent | ttl | unblock_source} |
{Level :: ipv6,
Opt ::
addrform | add_membership | authhdr | auth_level | checksum | drop_membership | dstopts |
esp_trans_level | esp_network_level | faith | flowinfo | hopopts | ipcomp_level |
join_group | leave_group | mtu | mtu_discover | multicast_hops | multicast_if |
multicast_loop | portrange | pktoptions | recverr | recvhoplimit | hoplimit |
recvpktinfo | pktinfo | recvtclass | router_alert | rthdr | tclass | unicast_hops |
use_min_mtu | v6only} |
{Level :: tcp,
Opt ::
congestion | cork | info | keepcnt | keepidle | keepintvl | maxseg | md5sig | nodelay |
noopt | nopush | syncnt | user_timeout} |
{Level :: udp, Opt :: cork} |
{Level :: sctp,
Opt ::
adaption_layer | associnfo | auth_active_key | auth_asconf | auth_chunk | auth_key |
auth_delete_key | autoclose | context | default_send_params | delayed_ack_time |
disable_fragments | hmac_ident | events | explicit_eor | fragment_interleave |
get_peer_addr_info | initmsg | i_want_mapped_v4_addr | local_auth_chunks | maxseg |
maxburst | nodelay | partial_delivery_point | peer_addr_params | peer_auth_chunks |
primary_addr | reset_streams | rtoinfo | set_peer_primary_addr | status |
use_ext_recvinfo}.
Socket option on the form {Level, Opt} where the OS protocol Level =
level/0 and Opt is a socket option on that protocol level.
The OS name for an options is, except where otherwise noted, the Opt atom, in
capitals, with prefix according to level/0.
Note
The
IPv6optionpktoptionsis a special (barf) case. It is intended for backward compatibility usage only.Do not use this option.
Note
See the OS documentation for every socket option.
An option below that has the value type boolean/0 will translate the value
false to a C int with value 0, and the value true to !!0 (not (not
false)).
An option with value type integer/0 will be translated to a C int that may
have a restricted range, for example byte: 0..255. See the OS documentation.
The calls supports(options),
supports(options, Level) and
is_supported(options, {Level, Opt}) can be used to find
out which socket options that are supported by the platform.
Options for protocol level socket:
{socket, acceptconn}-Value = boolean(){socket, bindtodevice}-Value = string(){socket, broadcast}-Value = boolean(){socket, debug}-Value = integer(){socket, domain}-Value =domain/0Only valid to get.
The socket's protocol domain. Does not work on for instance FreeBSD.
{socket, dontroute}-Value = boolean(){socket, keepalive}-Value = boolean(){socket, linger}-Value = abort |linger/0The value
abortis shorthand for#{onoff => true, linger => 0}, and only valid to set.{socket, oobinline}-Value = boolean(){socket, passcred}-Value = boolean(){socket, peek_off}-Value = integer()Currently disabled due to a possible infinite loop when calling
recv/1-4withpeekinFlags.{socket, priority}-Value = integer(){socket, protocol}-Value =protocol/0Only valid to get.
The socket's protocol. Does not work on for instance Darwin.
{socket, rcvbuf}-Value = integer(){socket, rcvlowat}-Value = integer(){socket, rcvtimeo}-Value =timeval/0This option is unsupported per default; OTP has to be explicitly built with the
--enable-esock-rcvsndtimeoconfigure option for this to be available.Since our implementation uses nonblocking sockets, it is unknown if and how this option works, or even if it may cause malfunction. Therefore, we do not recommend setting this option.
Instead, use the
Timeoutargument to, for instance, therecv/3function.{socket, reuseaddr}-Value = boolean(){socket, reuseport}-Value = boolean(){socket, sndbuf}-Value = integer(){socket, sndlowat}-Value = integer(){socket, sndtimeo}-Value =timeval/0This option is unsupported per default; OTP has to be explicitly built with the
--enable-esock-rcvsndtimeoconfigure option for this to be available.Since our implementation uses nonblocking sockets, it is unknown if and how this option works, or even if it may cause malfunction. Therefore, we do not recommend setting this option.
Instead, use the
Timeoutargument to, for instance, thesend/3function.{socket, timestamp}-Value = boolean(){socket, type}-Value =type/0Only valid to get.
The socket's type.
Options for protocol level ip:
{ip, add_membership}-Value =ip_mreq/0Only valid to set.
{ip, add_source_membership}-Value =ip_mreq_source/0Only valid to set.
{ip, block_source}-Value =ip_mreq_source/0Only valid to set.
{ip, drop_membership}-Value =ip_mreq/0Only valid to set.
{ip, drop_source_membership}-Value =ip_mreq_source/0Only valid to set.
{ip, freebind}-Value = boolean(){ip, hdrincl}-Value = boolean(){ip, minttl}-Value = integer(){ip, msfilter}-Value =null |ip_msfilter/0Only valid to set.
The value
nullpasses aNULLpointer and size0to the C library call.{ip, mtu}-Value = integer()Only valid to get.
{ip, mtu_discover}-Value =ip_pmtudisc()| integer()An
integer/0value is according to the platform's header files.{ip, multicast_all}-Value = boolean(){ip, multicast_if}-Value =any |in_addr/0{ip, multicast_loop}-Value = boolean(){ip, multicast_ttl}-Value = integer(){ip, nodefrag}-Value = boolean(){ip, pktinfo}-Value = boolean(){ip, recvdstaddr}-Value = boolean(){ip, recverr}-Value = boolean()Warning! When this option is enabled, error messages may arrive on the socket's error queue, which should be read using the message flag
errqueue, and usingrecvmsg/1,2,3,4,5to get all error information in the message'sctrlfield as a control message#{level := ip, type := recverr}.A working strategy should be to first poll the error queue using
recvmsg/2,3,4withTimeout =:= 0andFlagscontainingerrqueue(ignore the return value{error, timeout}) before reading the actual data to ensure that the error queue gets cleared. And read the data using one of thenowait |select_handle()recv functions:recv/3,4,recvfrom/3,4orrecvmsg/3,4,5. Otherwise you might accidentally cause a busy loop in and out of 'select' for the socket.{ip, recvif}-Value = boolean(){ip, recvopts}-Value = boolean(){ip, recvorigdstaddr}-Value = boolean(){ip, recvtos}-Value = boolean(){ip, recvttl}-Value = boolean(){ip, retopts}-Value = boolean(){ip, router_alert}-Value = integer(){ip, sendsrcaddr}-Value = boolean(){ip, tos}-Value =ip_tos()| integer()An
integer/0value is according to the platform's header files.{ip, transparent}-Value = boolean(){ip, ttl}-Value = integer(){ip, unblock_source}-Value =ip_mreq_source/0Only valid to set.
Options for protocol level ipv6:
{ipv6, addrform}-Value =domain/0As far as we know the only valid value is
inetand it is only allowed for an IPv6 socket that is connected and bound to an IPv4-mapped IPv6 address.{ipv6, add_membership}-Value =ipv6_mreq/0Only valid to set.
{ipv6, authhdr}-Value = boolean(){ipv6, drop_membership}-Value =ipv6_mreq/0Only valid to set.
{ipv6, dstopts}-Value = boolean(){ipv6, flowinfo}-Value = boolean(){ipv6, hoplimit}-Value = boolean(){ipv6, hopopts}-Value = boolean(){ipv6, mtu}-Value = integer(){ipv6, mtu_discover}-Value =ipv6_pmtudisc()| integer()An
integer/0value is according to the platform's header files.{ipv6, multicast_hops}-Value =ipv6_hops/0{ipv6, multicast_if}-Value = integer(){ipv6, multicast_loop}-Value = boolean(){ipv6, recverr}-Value = boolean()Warning! See the socket option
{ip, recverr}regarding the socket's error queue. The same warning applies for this option.{ipv6, recvhoplimit}-Value = boolean(){ipv6, recvpktinfo}-Value = boolean(){ipv6, recvtclass}-Value = boolean(){ipv6, router_alert}-Value = integer(){ipv6, rthdr}-Value = boolean(){ipv6, tclass}-Value = boolean(){ipv6, unicast_hops}-Value =ipv6_hops/0{ipv6, v6only}-Value = boolean()
Options for protocol level sctp. See also RFC 6458.
{sctp, associnfo}-Value =sctp_assocparams/0{sctp, autoclose}-Value = integer(){sctp, disable_fragments}-Value = boolean(){sctp, events}-Value =sctp_event_subscribe/0Only valid to set.
{sctp, initmsg}-Value =sctp_initmsg/0{sctp, maxseg}-Value = integer(){sctp, nodelay}-Value = boolean(){sctp, rtoinfo}-Value =sctp_rtoinfo/0
Options for protocol level tcp:
{tcp, congestion}-Value = string(){tcp, cork}-Value = boolean(){tcp, maxseg}-Value = integer(){tcp, nodelay}-Value = boolean()
Options for protocol level udp:
{udp, cork}-Value = boolean()
Corresponds to the C struct timeval. The field sec holds seconds, and usec
microseconds.
-type type() :: stream | dgram | raw | rdm | seqpacket.
A lowercase atom/0 representing a protocol type on the platform named
SOCK_*.
Functions
-spec accept(ListenSocket) -> {ok, Socket} | {error, Reason} when ListenSocket :: socket(), Socket :: socket(), Reason :: posix() | closed | invalid().
Equivalent to accept/2
-spec accept(ListenSocket, Timeout :: nowait) -> {ok, Socket} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when ListenSocket :: socket(), Socket :: socket(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | {create_accept_socket, posix()} | {add_accept_socket, posix()} | {update_accept_context, posix()}; (ListenSocket, Handle :: select_handle() | completion_handle()) -> {ok, Socket} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when ListenSocket :: socket(), Socket :: socket(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | {create_accept_socket, posix()} | {add_socket, posix()} | {update_accept_context, posix()}; (ListenSocket, Timeout :: infinity) -> {ok, Socket} | {error, Reason} when ListenSocket :: socket(), Socket :: socket(), Reason :: posix() | closed | invalid() | {create_accept_socket, posix()} | {add_socket, posix()} | {update_accept_context, posix()}; (ListenSocket, Timeout :: non_neg_integer()) -> {ok, Socket} | {error, Reason} when ListenSocket :: socket(), Socket :: socket(), Reason :: posix() | closed | invalid() | timeout | {create_accept_socket, posix()} | {add_socket, posix()} | {update_accept_context, posix()}.
Accept a connection on a socket.
This call is used with connection oriented socket types (stream or
seqpacket). It returns the first pending incoming connection for a listen
socket, or waits for one to arrive, and returns the (newly) connected socket.
The same as accept/1 but returns {error, timeout} if no connection has been
accepted after Timeout milliseconds.
Note
On unix, note that if multiple calls are made only the last call is "valid":
{select, {select_info, _Handle}} = socket:accept(LSock, nowait), {error, timeout} = socket:accept(LSock, 500), . . .In the example above,
Handleis not valid once the second (accept-) call has been made (the first call is automatically "cancelled" and an abort messaage sent, when the second call is made). After the (accept-) call resulting in the timeout has been made, there is no longer an active accept call!
The same as accept/1 but returns promptly.
When there is no pending connection to return, the function will return (on
Unix) {select, SelectInfo} or (on Windows)
{completion, CompletionInfo}, and the caller will
later receive either one of these messages (depending on the platform) when the
client connects:
selectmessage -{'$socket', Socket, select, SelectHandle}(with theSelectHandlecontained in theSelectInfo).A subsequent call to
accept/1,2will then return the socket.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the accept will be in the
CompletionStatus.
If the time-out argument is a Handle, that term will be contained in a
returned SelectInfo or CompletionInfo and the corresponding select or
completion message. The Handle is presumed to be unique to this call.
If the time-out argument is nowait:
On Unix - And a
SelectInfois returned, it will contain aselect_handle/0generated by the call.On Windows - And a
CompletionInfois returned, it will contain acompletion_handle/0generated by the call.
If the caller doesn't want to wait for a connection, it must immediately call
cancel/2 to cancel the operation.
Note
On unix, note that if multiple calls are made only the last call is "valid":
{select, {select_info, _Handle1}} = socket:accept(LSock, nowait), {select, {select_info, _Handle2}} = socket:accept(LSock, nowait), receive {'$socket', LSock, select, Handle2} -> {ok, ASock} = socket:accept(LSock, nowait), . . . endIn the example above, only
Handle2is valid once the second (accept-) call has been made (the first call is automatically "cancelled" and an abort messaage sent, when the second call is made).
-spec bind(Socket, Addr) -> ok | {error, Reason} when Socket :: socket(), Addr :: sockaddr() | any | broadcast | loopback, Reason :: posix() | closed | invalid().
Bind a name to a socket.
When a socket is created (with open), it has no address assigned
to it. bind assigns the address specified by the Addr argument.
The rules used for name binding vary between domains.
If you bind a socket to an address in for example the 'inet' or 'inet6' address
families, with an ephemeral port number (0), and want to know which port that
was chosen, you can find out using something like: {ok, #{port := Port}} =
socket:sockname(Socket)
-spec cancel(Socket, SelectInfo) -> ok | {error, Reason} when Socket :: socket(), SelectInfo :: select_info(), Reason :: closed | invalid(); (Socket, CompletionInfo) -> ok | {error, Reason} when Socket :: socket(), CompletionInfo :: completion_info(), Reason :: closed | invalid().
Cancel an asynchronous (select) request.
Call this function in order to cancel a previous asynchronous call to, e.g.
recv/3.
An ongoing asynchronous operation blocks the socket until the operation has been finished in good order, or until it has been cancelled by this function.
Any other process that tries an operation of the same basic type (accept / send
/ recv) will be enqueued and notified with the regular select mechanism for
asynchronous operations when the current operation and all enqueued before it
has been completed.
If SelectInfo does not match an operation in progress for the calling process,
this function returns {error, {invalid, SelectInfo}}.
Cancel an asynchronous (completion) request.
Call this function in order to cancel a previous asynchronous call to, e.g.
recv/3.
An ongoing asynchronous operation blocks the socket until the operation has been finished in good order, or until it has been cancelled by this function.
Any other process that tries an operation of the same basic type (accept / send
/ recv) will be enqueued and notified with the regular select mechanism for
asynchronous operations when the current operation and all enqueued before it
has been completed.
If CompletionInfo does not match an operation in progress for the calling
process, this function returns {error, {invalid, CompletionInfo}}.
If MRef is a reference that the calling process obtained by calling
monitor/1, this monitor is turned off. If the monitoring is already turned
off, nothing happens.
The returned value is one of the following:
true- The monitor was found and removed. In this case, no'DOWN'message corresponding to this monitor has been delivered and will not be delivered.false- The monitor was not found and could not be removed. This probably because a'DOWN'message corresponding to this monitor has already been placed in the caller message queue.
Failure: It is an error if MRef refers to a monitor started by another
process.
-spec close(Socket) -> ok | {error, Reason} when Socket :: socket(), Reason :: posix() | closed | timeout.
Closes the socket.
Note
Note that for e.g.
protocol=tcp, most implementations doing a close does not guarantee that any data sent is delivered to the recipient before the close is detected at the remote side.One way to handle this is to use the
shutdownfunction (socket:shutdown(Socket, write)) to signal that no more data is to be sent and then wait for the read side of the socket to be closed.
-spec connect(Socket) -> ok | {error, Reason} when Socket :: socket(), Reason :: posix() | closed | invalid().
This function finalizes a connection setup on a socket, after calling
connect(_, _, nowait | select_handle()) that returned
{select, SelectInfo}, and receiving the select message
{'$socket', Socket, select, SelectHandle}, and returns whether the connection
setup was successful or not.
Instead of calling this function, for backwards compatibility, it is allowed to
call connect/2,3, but that incurs more overhead since the
connect address and time-out are processed in vain.
Note
Not used on Windows.
-spec connect(Socket, SockAddr) -> ok | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr(), Reason :: posix() | closed | invalid() | already.
Equivalent to connect/3
-spec connect(Socket, SockAddr, Timeout :: nowait) -> ok | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | already | not_bound | {add_socket, posix()} | {update_connect_context, posix()}; (Socket, SockAddr, Handle :: select_handle() | completion_handle()) -> ok | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | already | not_bound | {add_socket, posix()} | {update_connect_context, posix()}; (Socket, SockAddr, Timeout :: infinity) -> ok | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr(), Reason :: posix() | closed | invalid() | already | not_bound | {add_socket, posix()} | {update_connect_context, posix()}; (Socket, SockAddr, Timeout :: non_neg_integer()) -> ok | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr(), Reason :: posix() | closed | invalid() | already | not_bound | timeout | {add_socket, posix()} | {update_connect_context, posix()}.
This function connects the socket to the address specified by the SockAddr
argument, and returns when the connection has been established or failed.
If a connection attempt is already in progress (by another process),
{error, already} is returned.
Note
On Windows the socket has to be bound.
The same as connect/2 but returns {error, timeout} if no connection has been
established after Timeout milliseconds.
Note
On Windows the socket has to be bound.
Note that when this call has returned
{error, timeout}the connection state of the socket is uncertain since the platform's network stack may complete the connection at any time, up to some platform specific time-out.Repeating a connection attempt towards the same address would be ok, but towards a different address could end up with a connection to either address.
The safe play would be to close the socket and start over.
Also note that all this applies to cancelling a connect call with a no-wait time-out described below.
The same as connect/2 but returns promptly.
If it is not possible to immediately establish a connection, the function will
return {select, SelectInfo}, and the caller will later
receive a select message, {'$socket', Socket, select, SelectHandle} ( with the
SelectHandle contained in the
SelectInfo ) when the connection has been completed or
failed. A subsequent call to connect/1 will then finalize the connection and
return the result.
If the time-out argument is SelectHandle, that term will be contained in a
returned SelectInfo and the corresponding select message. The SelectHandle
is presumed to be unique to this call.
If the time-out argument is nowait, and a SelectInfo is returned, it will
contain a select_handle() generated by the call.
If the caller doesn't want to wait for the connection to complete, it must
immediately call cancel/2 to cancel the operation.
Note
On Windows the socket has to be bound.
-spec getopt(socket(), SocketOption :: {Level :: otp, Opt :: otp_socket_option()}) -> {ok, Value :: term()} | {error, invalid() | closed}; (socket(), SocketOption :: socket_option()) -> {ok, Value :: term()} | {error, posix() | invalid() | closed}.
Gets a socket option from the protocol level otp, which is this
implementation's level above the OS protocol layers.
See the type otp_socket_option() for a description of the options on this level.
Gets a socket option from one of the OS's protocol levels. See the type
socket_option/0 for which options that this implementation knows about, how
they are related to option names in the OS, and if there are known peculiarities
with any of them.
What options are valid depends on what kind of socket it is (domain/0,
type/0 and protocol/0).
See the socket options chapter of the users guide for more info.
Note
Not all options are valid, nor possible to get, on all platforms. That is, even if "we" support an option; it does not mean that the underlying OS does.
-spec getopt(socket(), otp | level(), term()) -> {ok, Value :: term()} | {error, posix() | invalid() | closed}.
getopt(Socket, Level, Opt) -> ok | {error, Reason}
Backwards compatibility function.
The same as getopt(Socket, {Level, Opt})
-spec getopt_native(socket(), SocketOption :: socket_option() | {Level :: level() | (NativeLevel :: integer()), NativeOpt :: integer()}, ValueType :: integer) -> {ok, Value :: integer()} | {error, posix() | invalid() | closed}; (socket(), SocketOption :: socket_option() | {Level :: level() | (NativeLevel :: integer()), NativeOpt :: integer()}, ValueType :: boolean) -> {ok, Value :: boolean()} | {error, posix() | invalid() | closed}; (socket(), SocketOption :: socket_option() | {Level :: level() | (NativeLevel :: integer()), NativeOpt :: integer()}, ValueSize :: non_neg_integer()) -> {ok, Value :: binary()} | {error, posix() | invalid() | closed}; (socket(), SocketOption :: socket_option() | {Level :: level() | (NativeLevel :: integer()), NativeOpt :: integer()}, ValueSpec :: binary()) -> {ok, Value :: binary()} | {error, posix() | invalid() | closed}.
Gets a socket option that may be unknown to our implementation, or that has a type not compatible with our implementation, that is; in "native mode".
The socket option may be specified with an ordinary
socket_option() tuple, with a known
Level = level() and an integer NativeOpt, or with both an
integer NativeLevel and NativeOpt.
How to decode the option value has to be specified either with ValueType, by
specifying the ValueSize for a binary/0 that will contain the fetched
option value, or by specifying a binary/0 ValueSpec that will be copied to
a buffer for the getsockopt() call to write the value in which will be
returned as a new binary/0.
If ValueType is integer a C type (int) will be fetched, if it is
boolean a C type (int) will be fetched and converted into a boolean/0
according to the C implementation.
What options are valid depends on what kind of socket it is (domain/0,
type/0 and protocol/0).
The integer values for NativeLevel and NativeOpt as well as the Value
encoding has to be deduced from the header files for the running system.
-spec i() -> ok.
Print all sockets in table format in the erlang shell.
-spec i(InfoKeys) -> ok when InfoKeys :: info_keys(); (Domain) -> ok when Domain :: inet | inet6 | local; (Proto) -> ok when Proto :: sctp | tcp | udp; (Type) -> ok when Type :: dgram | seqpacket | stream.
Print all sockets in table format in the erlang shell. What information is
included is defined by InfoKeys.
Print a selection, based on domain, of the sockets in table format in the erlang shell.
Print a selection, based on protocol, of the sockets in table format in the erlang shell.
Print a selection, based on type, of the sockets in table format in the erlang shell.
-spec i(Domain, InfoKeys) -> ok when Domain :: inet | inet6 | local, InfoKeys :: info_keys(); (Proto, InfoKeys) -> ok when Proto :: sctp | tcp | udp, InfoKeys :: info_keys(); (Type, InfoKeys) -> ok when Type :: dgram | seqpacket | stream, InfoKeys :: info_keys().
Print a selection, based on domain, of the sockets in table format in the erlang
shell. What information is included is defined by InfoKeys.
Print a selection, based on domain, of the sockets in table format in the erlang
shell. What information is included is defined by InfoKeys.
Print a selection, based on type, of the sockets in table format in the erlang
shell. What information is included is defined by InfoKeys.
-spec info() -> info().
Get miscellaneous info about the socket library.
The function returns a map with each info item as a key-value binding.
Note
In order to ensure data integrity, mutex'es are taken when needed. So, do not call this function often.
-spec info(Socket) -> socket_info() when Socket :: socket().
Get miscellaneous info about the socket.
The function returns a map with each info item as a key-value binding. It reflects the "current" state of the socket.
Note
In order to ensure data integrity, mutex'es are taken when needed. So, do not call this function often.
-spec ioctl(Socket, GetRequest :: gifconf) -> {ok, IFConf :: [#{name := string, addr := sockaddr()}]} | {error, Reason} when Socket :: socket(), Reason :: posix() | closed; (Socket, GetRequest :: nread | nwrite | nspace) -> {ok, NumBytes :: non_neg_integer()} | {error, Reason} when Socket :: socket(), Reason :: posix() | closed; (Socket, GetRequest :: atmark) -> {ok, Available :: boolean()} | {error, Reason} when Socket :: socket(), Reason :: posix() | closed; (Socket, GetRequest :: tcp_info) -> {ok, Info :: map()} | {error, Reason} when Socket :: socket(), Reason :: posix() | closed.
Retrieve socket (device) parameters.
This function retrieves a specific parameter, according to GetRequest
argument.
gifconf- Return a list of interface (transport layer) addresses.Result, a list of interfaces, map with name and address.
nread- Get the number of bytes that are immediately available for reading.Result, number of bytes, is a
integer/0.nwrite- The number of bytes in the send queue.Result, number of bytes, is a
integer/0.nspace- Get the free space in the send queue.Result, number of bytes, is a
integer/0.atmark- Test if there is oob (out-of-bound) data waiting to be read.Result is a
boolean/0.tcp_info- Return miscellaneous TCP related information for a connected socket.Result is a
map/0.
Note
To see if a ioctl request is supported on the current platform:
Request = nread, {ok, true} = socket:is_supported(ioctl_requests, Request), . . .
-spec ioctl(Socket, GetRequest, NameOrIndex) -> {ok, Result} | {error, Reason} when Socket :: socket(), GetRequest :: gifname | gifindex | gifaddr | gifdstaddr | gifbrdaddr | gifnetmask | gifhwaddr | gifmtu | giftxqlen | gifflags | tcp_info, NameOrIndex :: string() | integer(), Result :: term(), Reason :: posix() | closed; (Socket, SetRequest, Value) -> ok | {error, Reason} when Socket :: socket(), SetRequest :: rcvall, Value :: off | on | iplevel, Reason :: posix() | closed; (Socket, SetRequest, Value) -> ok | {error, Reason} when Socket :: socket(), SetRequest :: rcvall_igmpmcast | rcvall_mcast, Value :: off | on, Reason :: posix() | closed.
Retrieve socket (device) parameters.
This function retrieves a specific parameter, according to GetRequest
argument. The third argument is a the (lookup) "key", identifying the interface
(usually the name of the interface) or a command to set.
gifname- Get the name of the interface with the specified index (integer()).Result, name of the interface, is a
string/0.gifindex- Get the index of the interface with the specified name.Result, interface index, is a
integer/0.gifaddr- Get the address of the interface with the specified name. Result, address of the interface, is asocket:sockaddr().gifdstaddr- Get the destination address of the point-to-point interface with the specified name.Result, destination address of the interface, is a
socket:sockaddr().gifbrdaddr- Get the droadcast address for the interface with the specified name.Result, broadcast address of the interface, is a
socket:sockaddr().gifnetmask- Get the network mask for the interface with the specified name.Result, network mask of the interface, is a
socket:sockaddr().gifhwaddr- Get the hardware address for the interface with the specified name.Result, hardware address of the interface, is a
socket:sockaddr(). The family field contains the 'ARPHRD' device type (or an integer).gifmtu- Get the MTU (Maximum Transfer Unit) for the interface with the specified name.Result, MTU of the interface, is an
integer/0.giftxqlen- Get the transmit queue length of the interface with the specified name.Result, transmit queue length of the interface, is an
integer/0.gifflags- Get the active flag word of the interface with the specified name.Result, the active flag word of the interface, is an list of
socket:ioctl_device_flag() | integer().
Set socket (device) parameters.
This function sets a specific parameter, according to SetRequest argument. The
third argument is the value to set.
rcvall- Enables (or disables) a socket to receive all IPv4 or IPv6 packages passing through a network interface.The socket has to be either one of:
An IPv4 socket - Created with the address family of
inet, socket type ofrawand protocol set toip.An IPv6 socket - Created with the address family of
inet6, socket type ofrawand protocol set toipv6.
The socket must also be bound to an (explicit) local IPv4 or IPv6 interface (
anynot allowed).Setting this IOCTL requires admin privileges.
Set socket (device) parameters.
This function sets a specific parameter, according to SetRequest argument. The
third argument is the value to set.
rcvall_igmpmcall- Enables (or disables) a socket to receive IGMP multicast IP traffic, without receiving any other IP traffic.The socket has to be created with the address family of
inet, socket type ofrawand protocol set toigmp.The socket must also be bound to an (explicit) local interface (
anynot allowed).Must have a sufficiently large buffer.
Setting this IOCTL requires admin privileges.
rcvall_mcall- Enables (or disables) a socket to receive all multicast IP traffic (as in; all IP packets destined for IP addresses in the range of 224.0.0.0 to 239.255.255.255).The socket has to be created with the address family of
inet, socket type ofrawand protocol set toudp.The socket must also be bound to an (explicit) local interface (
anynot allowed). And bind to port zeroMust have a sufficiently large buffer.
Setting this IOCTL requires admin privileges.
-spec ioctl(Socket, SetRequest, Name, Value) -> ok | {error, Reason} when Socket :: socket(), SetRequest :: sifflags | sifaddr | sifdstaddr | sifbrdaddr | sifnetmask | sifhwaddr | gifmtu | siftxqlen, Name :: string(), Value :: term(), Reason :: posix() | closed.
Set socket (device) parameters. This function sets a specific parameter,
according to SetRequest argument. The third argument is the "key", identifying
the interface (usually the name of the interface), and the fourth is the "new"
value.
These are privileged operation's.
sifflags- Set the the active flag word,#{Flag => boolean()}, of the interface with the specified name.Each flag to be changed, should be added to the value map, with the value
'true'if the flag (Flag) should be set and'false'if the flag should be reset.sifaddr- Set the address,sockaddr/0, of the interface with the specified name.sifdstaddr- Set the destination address,sockaddr/0, of a point-to-point interface with the specified name.sifbrdaddr- Set the broadcast address,sockaddr/0, of the interface with the specified name.sifnetmask- Set the network mask,sockaddr/0, of the interface with the specified name.sifmtu- Set the MTU (Maximum Transfer Unit),integer/0, for the interface with the specified name.siftxqlen- Set the transmit queue length,integer/0, of the interface with the specified name.
Equivalent to is_supported/2
This function retrieves information about what the platform supports, such as if SCTP is supported, or if a socket options are supported.
For keys other than the known false is returned. Note that in a future version
or on a different platform there might be more supported items.
This functions returns a boolean corresponding to what
supports/0-2 reports for the same Key1 (and Key2).
-spec listen(Socket) -> ok | {error, Reason} when Socket :: socket(), Reason :: posix() | closed | not_bound.
Equivalent to listen/2
-spec listen(Socket, Backlog) -> ok | {error, Reason} when Socket :: socket(), Backlog :: integer(), Reason :: posix() | closed.
Listen for connections on a socket.
Note
On Windows the socket has to be bound.
Start monitor the socket Socket.
If the monitored socket does not exist or when the monitor is triggered, a
'DOWN' message is sent that has the following pattern:
{'DOWN', MonitorRef, socket, Object, Info}In the monitor message MonitorRef and Type are the same as described
earlier, and:
Object- The monitored entity, socket, which triggered the event.Info- Either the termination reason of the socket ornosock(socketSocketdid not exist at the time of monitor creation).
Making several calls to socket:monitor/1 for the same Socket is not an
error; it results in as many independent monitoring instances.
-spec number_of() -> non_neg_integer().
Returns the number of active sockets.
-spec open(FD) -> {ok, Socket} | {error, Reason} when FD :: integer(), Socket :: socket(), Reason :: posix() | domain | type | protocol.
Equivalent to open/2
-spec open(FD, Opts) -> {ok, Socket} | {error, Reason} when FD :: integer(), Opts :: #{domain => domain() | integer(), type => type() | integer(), protocol => default | protocol() | integer(), dup => boolean(), debug => boolean(), use_registry => boolean()}, Socket :: socket(), Reason :: posix() | domain | type | protocol; (Domain, Type) -> {ok, Socket} | {error, Reason} when Domain :: domain() | integer(), Type :: type() | integer(), Socket :: socket(), Reason :: posix() | protocol.
Creates an endpoint (socket) for communication based on an already existing file
descriptor. The function attempts to retrieve domain, type and protocol
from the system. This is however not possible on all platforms, and they should
then be specified in Opts.
The Opts argument is intended for providing extra information for the open
call:
domain- Which protocol domain is the descriptor of. See alsoopen/2,3,4.type- Which protocol type type is the descriptor of.See also
open/2,3,4.protocol- Which protocol is the descriptor of. The atomdefaultis equivalent to the integer protocol number0which means the default protocol for a given domain and type.If the protocol can not be retrieved from the platform for the socket, and
protocolis not specified, the default protocol is used, which may or may not be correct.See also
open/2,3,4.dup- Shall the provided descriptor be duplicated (dup) or not.
Defaults totrue.debug- Enable or disable debug during the open call.
Defaults tofalse.use_registry- Enable or disable use of the socket registry for this socket. This overrides the global value.
Defaults to the global value, seeuse_registry/1.
Note
This function should be used with care!
On some platforms it is necessary to provide
domain,typeandprotocolsince they cannot be retrieved from the platform.
-spec open(Domain, Type, Opts) -> {ok, Socket} | {error, Reason} when Domain :: domain() | integer(), Type :: type() | integer(), Opts :: map(), Socket :: socket(), Reason :: posix() | protocol; (Domain, Type, Protocol) -> {ok, Socket} | {error, Reason} when Domain :: domain() | integer(), Type :: type() | integer(), Protocol :: default | protocol() | integer(), Socket :: socket(), Reason :: posix() | protocol.
Creates an endpoint (socket) for communication.
The same as open(Domain, Type, default) and
open(Domain, Type, default, Opts) respectively.
-spec open(Domain, Type, Protocol, Opts) -> {ok, Socket} | {error, Reason} when Domain :: domain() | integer(), Type :: type() | integer(), Protocol :: default | protocol() | integer(), Opts :: #{netns => string(), debug => boolean(), use_registry => boolean()}, Socket :: socket(), Reason :: posix() | protocol.
Creates an endpoint (socket) for communication.
Domain and Type may be integer/0s, as defined in the platform's header
files. The same goes for Protocol as defined in the platform's services(5)
database. See also the OS man page for the library call socket(2).
Note
For some combinations of
DomainandTypethe platform has got a default protocol that can be selected withProtocol = default, and the platform may allow or require selecting the default protocol, a specific protocol, or either.Examples:
socket:open(inet, stream, tcp)- It is common that for protocol domain and typeinet,streamit is allowed to select thetcpprotocol although that mostly is the default.socket:open(local, dgram)- It is common that for the protocol domainlocalit is mandatory to not select a protocol, that is; to select the default protocol.
The Opts argument is intended for "other" options. The supported option(s) are
described below:
netns: string()- Used to set the network namespace during the open call. Only supported on the Linux platform.debug: boolean()- Enable or disable debug during the open call.
Defaults tofalse.use_registry: boolean()- Enable or disable use of the socket registry for this socket. This overrides the global value.
Defaults to the global value, seeuse_registry/1.
-spec peername(Socket) -> {ok, SockAddr} | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr_recv(), Reason :: posix() | closed.
Returns the address of the peer connected to the socket.
-spec recv(Socket) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Data :: binary(), Reason :: posix() | closed | invalid().
Equivalent to recv/4
-spec recv(Socket, Flags) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Length) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Data :: binary(), Reason :: posix() | closed | invalid().
Equivalent to recv/4
-spec recv(Socket, Flags, Handle :: nowait) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Flags :: [msg_flag() | integer()], Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Handle :: select_handle() | completion_handle()) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Flags :: [msg_flag() | integer()], Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: infinity) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: non_neg_integer()) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid() | timeout; (Socket, Length, Flags) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Length, Handle :: nowait) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Length, Handle :: select_handle() | completion_handle()) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Length, Timeout :: infinity) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Length, Timeout :: non_neg_integer()) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Data :: binary(), Reason :: posix() | closed | invalid() | timeout.
Equivalent to recv/4
-spec recv(Socket, Length, Flags, Handle :: nowait) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Flags :: [msg_flag() | integer()], Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Length, Flags, Handle :: select_handle() | completion_handle()) -> {ok, Data} | {select, SelectInfo} | {select, {SelectInfo, Data}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Flags :: [msg_flag() | integer()], Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Length, Flags, Timeout :: infinity) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Length, Flags, Timeout :: non_neg_integer()) -> {ok, Data} | {error, Reason} | {error, {Reason, Data}} when Socket :: socket(), Length :: non_neg_integer(), Flags :: [msg_flag() | integer()], Data :: binary(), Reason :: posix() | closed | invalid() | timeout.
Receives data from a socket, waiting for it to arrive.
The argument Length specifies how many bytes to receive, with the special case
0 meaning "all available".
For a socket of type stream this call will not return until all
requested data can be delivered, or if "all available" data was requested when
the first data chunk arrives.
The message Flags may be symbolic msg_flag/0s and/or integer/0s, as in
the platform's appropriate header files. The values of all symbolic flags and
integers are or:ed together.
When there is a socket error this function returns {error, Reason}, or if some
data arrived before the error; {error, {Reason, Data}}.
Receives data from a socket, waiting at most Timeout milliseconds for it to
arrive.
The same as infinite time-out recv/1,2,3,4 but
returns {error, timeout} or {error, {timeout, Data}} after Timeout
milliseconds, if the requested data has not been delivered.
Receives data from a socket, but returns a select or completion continuation
if the data could not be returned immediately.
The same as infinite time-out recv/1,2,3,4 but if
the data can be delivered immediately, the function returns (on Unix)
{select, SelectInfo} or (on Windows)
{completion, CompletionInfo}, and the caller will
then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}(with theSelectHandlethat was contained in theSelectInfo) when data has arrived.A subsequent call to
recv/1,2,3,4will then return the data.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the receive will be in the
CompletionStatus.
If Handle is a select_handle/0 or completion_handle/0, that term will
be contained in a returned SelectInfo or CompletionInfo and the
corresponding (select or completion) message. The Handle is presumed to be
unique to this call.
If the time-out argument is nowait, and a SelectInfo or CompletionInfo is
returned, it will contain a select_handle/0 or completion_handle/0
generated by the call.
Note that for a socket of type stream (on Unix), if Length > 0 and only
part of that amount of data is available, the function will return
{ok, {Data, SelectInfo}} with partial data. If the caller
doesn't want to wait for more data, it must immediately call cancel/2 to
cancel the operation.
-spec recvfrom(Socket) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid().
Equivalent to recvfrom/4
-spec recvfrom(Socket, Flags) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, BufSz) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid().
Equivalent to recvfrom/4
-spec recvfrom(Socket, Flags, Handle :: nowait) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Handle :: select_handle() | completion_handle()) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: infinity) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: non_neg_integer()) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid() | timeout; (Socket, BufSz, Flags) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Handle :: nowait) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Handle :: select_handle() | completion_handle()) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Timeout :: infinity) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Timeout :: non_neg_integer()) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid() | timeout.
Equivalent to recvfrom/4
-spec recvfrom(Socket, BufSz, Flags, Handle :: nowait) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Flags, Handle :: select_handle() | completion_handle()) -> {ok, {Source, Data}} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Flags, Timeout :: infinity) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid(); (Socket, BufSz, Flags, Timeout :: non_neg_integer()) -> {ok, {Source, Data}} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Source :: sockaddr_recv(), Data :: binary(), Reason :: posix() | closed | invalid() | timeout.
Receive a message from a socket, waiting for it to arrive.
The function returns when a message is received, or when there is a socket
error. Argument BufSz specifies the number of bytes for the receive buffer. If
the buffer size is too small, the message will be truncated.
If BufSz is not specified or 0, a default buffer size is used, which can be
set by socket:setopt(Socket, {otp,recvbuf}, BufSz).
If it is impossible to know the appropriate buffer size, it may be possible to
use the receive message flag peek. When this flag is used,
the message is not "consumed" from the underlying buffers, so another
recvfrom/1,2,3,4 call is needed, possibly with an adjusted buffer size.
The message Flags may be symbolic msg_flag/0s and/or integer/0s, as in
the platform's appropriate header files. The values of all symbolic flags and
integers are or:ed together.
Receives a message from a socket, waiting at most Timeout milliseconds for it
to arrive.
The same as
infinite time-out recvfrom/1,2,3,4 but returns
{error, timeout} after Timeout milliseconds, if no message has been
delivered.
Receives a message from a socket, but returns a select continuation or a completion term if no message could be returned immediately.
The same as
infinite time-out recvfrom/1,2,3,4 but if no
message can be delivered immediately, the function returns (on /Unix)
{select, SelectInfo} or (on Windows)
{completion, CompletionInfo}, and the caller will
then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}(with theSelectHandlethat was contained in theSelectInfo) when data has arrived.A subsequent call to
recvfrom/1,2,3,4will then return the message.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the receive will be in the
CompletionStatus.
If the Handle is a select_handle/0 or completion_handle/0, that term
will be contained in a returned SelectInfo or CompletionInfo and the
corresponding (select or completion) message. The Handle is presumed to be
unique to this call.
If the time-out argument is nowait, and a SelectInfo or CompletionInfo is
returned, it will contain a select_handle/0 or completion_handle/0
generated by the call.
If the caller doesn't want to wait for the data, it must immediately call
cancel/2 to cancel the operation.
-spec recvmsg(Socket) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Msg :: msg_recv(), Reason :: posix() | closed | invalid().
Equivalent to recvmsg/5
-spec recvmsg(Socket, Flags) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), Reason :: posix() | closed | invalid(); (Socket, Timeout :: nowait) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Handle :: select_handle() | completion_handle()) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Timeout :: infinity) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Msg :: msg_recv(), Reason :: posix() | closed | invalid(); (Socket, Timeout :: non_neg_integer()) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Msg :: msg_recv(), Reason :: posix() | closed | invalid() | timeout.
Equivalent to recvmsg/5
-spec recvmsg(Socket, Flags, Timeout :: nowait) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Handle :: select_handle() | completion_handle()) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: infinity) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), Reason :: posix() | closed | invalid(); (Socket, Flags, Timeout :: non_neg_integer()) -> {ok, Msg} | {error, Reason} when Socket :: socket(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), Reason :: posix() | closed | invalid() | timeout; (Socket, BufSz, CtrlSz) -> {ok, Msg} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Msg :: msg_recv(), Reason :: posix() | closed | invalid().
Equivalent to recvmsg/5
-spec recvmsg(Socket, BufSz, CtrlSz, Timeout :: nowait) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Handle :: select_handle() | completion_handle()) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Timeout :: infinity) -> {ok, Msg} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Msg :: msg_recv(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Timeout :: non_neg_integer()) -> {ok, Msg} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Msg :: msg_recv(), Reason :: posix() | closed | invalid() | timeout.
Equivalent to recvmsg/5
-spec recvmsg(Socket, BufSz, CtrlSz, Flags, Timeout :: nowait) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Flags, Handle :: select_handle() | completion_handle()) -> {ok, Msg} | {select, SelectInfo} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Flags, Timeout :: infinity) -> {ok, Msg} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), Reason :: posix() | closed | invalid(); (Socket, BufSz, CtrlSz, Flags, Timeout :: non_neg_integer()) -> {ok, Msg} | {error, Reason} when Socket :: socket(), BufSz :: non_neg_integer(), CtrlSz :: non_neg_integer(), Flags :: [msg_flag() | integer()], Msg :: msg_recv(), Reason :: posix() | closed | invalid() | timeout.
Receive a message from a socket, waiting for it to arrive.
The function returns when a message is received, or when there is a socket
error. Arguments BufSz and CtrlSz specifies the number of bytes for the
receive buffer and the control message buffer. If the buffer size(s) is(are) too
small, the message and/or control message list will be truncated.
If BufSz is not specified or 0, a default buffer size is used, which can be
set by socket:setopt(Socket, {otp,recvbuf}, BufSz). The same
applies to CtrlSz and
socket:setopt(Socket, {otp,recvctrlbuf}, CtrlSz).
If it is impossible to know the appropriate buffer size, it may be possible to
use the receive message flag peek. When this flag is used,
the message is not "consumed" from the underlying buffers, so another
recvfrom/1,2,3,4,5 call is needed, possibly with an adjusted buffer size.
The message Flags may be symbolic msg_flag/0s and/or integer/0s, as in
the platform's appropriate header files. The values of all symbolic flags and
integers are or:ed together.
Receives a message from a socket, waiting at most Timeout milliseconds for it
to arrive.
The same as recvmsg/1,2,3,4,5 but returns
{error, timeout} after Timeout milliseconds, if no message has been
delivered.
Receives a message from a socket, but returns a select continuation or a completion term if no message could be returned immediately.
The same as
infinite time-out recvmsg/1,2,3,4 but if no
message can delivered immediately, the function returns (on Unix)
{select, SelectInfo} or (on Windows)
{completion, CompletionInfo}, and the caller will
then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}(with theSelectHandlethat was contained in theSelectInfo) when data has arrived.A subsequent call to
recvmsg/1,2,3,4,5will then return the data.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the receive will be in the
CompletionStatus.
If the Handle is a select_handle/0 or completion_handle/0, that term
will be contained in a returned SelectInfo or CompletionInfo and the
corresponding (select or completion) message. The Handle is presumed to be
unique to this call.
If the time-out argument is nowait, and a SelectInfo or CompletionInfo is
returned, it will contain a select_handle/0 or completion_handle/0
generated by the call.
If the caller doesn't want to wait for the data, it must immediately call
cancel/2 to cancel the operation.
-spec send(Socket, Data) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), RestData :: binary(), Reason :: posix() | closed | invalid().
Equivalent to send/4
-spec send(Socket, Data, Flags) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Handle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), RestData :: binary(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), RestData :: binary(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei().
Equivalent to send/4
-spec send(Socket, Data, Flags, Handle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Flags :: [msg_flag() | integer()], RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Flags, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Flags :: [msg_flag() | integer()], RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Flags, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Flags, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid() | netname_deleted | too_many_cmds | eei(); (Socket, Data, Cont, SelectHandle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {error, Reason} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, SelectHandle :: select_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {error, Reason} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid().
Sends data on a connected socket, waiting for it to be sent.
This call will not return until the Data has been accepted by the platform's
network layer, or it reports an error.
The message Flags may be symbolic msg_flag/0s and/or integer/0s,
matching the platform's appropriate header files. The values of all symbolic
flags and integers are or:ed together.
The Data, if it is not a binary/0, is copied into one before calling the
platform network API, because a single buffer is required. A returned RestData
is a sub binary of this data binary.
The return value indicates the result from the platform's network layer:
ok- All data has been accepted.{ok, RestData}- Not all data has been accepted, but no error has been reported.RestDatais the tail ofDatathat has not been accepted.This cannot happen for a socket of type
streamwhere a partially successful send is retried until the data is either accepted or there is an error.For a socket of type
dgramthis should probably also not happen since a message that cannot be passed atomically should render an error.It is nevertheless possible for the platform's network layer to return this.
{error, Reason}- An error has been reported and no data has been accepted. Theposix/0Reasonsare from the platform's network layer.closedmeans that this socket library knows that the socket is closed, andinvalid/0means that something about an argument is invalid.{error, {Reason, RestData}}- An error has been reported but before that some data was accepted.RestDatais the tail ofDatathat has not been accepted. See{error, Reason}above.This can only happen for a socket of type
streamwhen a partially successful send is retried until there is an error.
Sends data on a connected socket, waiting at most Timeout milliseconds for it
to be sent.
The same as infinite time-out send/2,3,4 but
returns {error, timeout} or {error, {timeout, RestData}} after Timeout
milliseconds, if no Data or only some of it was accepted by the platform's
network layer.
Sends data on a connected socket, but returns completion or a select continuation if the data could not be sent immediately.
The same as infinite time-out send/2,3 but if the
data is not immediately accepted by the platform network layer, the function
returns (on Unix) {select, SelectInfo} or (on
Windows) {completion, CompletionInfo}, and the
caller will then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}( with theSelectHandlethat was contained in theSelectInfo) when there is room for more data.A subsequent call to
send/2-4will then send the data.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the send will be in the
CompletionStatus.
If Handle is a select_handle/0 or completion_handle/0, that term will
be contained in a returned SelectInfo or CompletionInfo and the
corresponding select or completion message. The Handle is presumed to be
unique to this call.
If Handle is nowait, and a SelectInfo or CompletionInfo is returned, it
will contain a select_handle/0 or completion_handle/0 generated by the
call.
If some of the data was sent, the function will return
{select, {RestData, SelectInfo},which can only happen
(on Unix) for a socket of type stream. If the caller does not
want to wait to send the rest of the data, it should immediately cancel the
operation with cancel/2.
Continues sending data on a connected socket, where the send operation was
initiated by send/3,4 that returned a SelectInfo
continuation. Otherwise like
infinite time-out send/2,3,4 ,
limited time-out send/3,4 or
nowait send/3,4 respectively.
Cont is the SelectInfo that was returned from the previous send() call.
If Data is not a binary/0, it will be copied into one, again.
The return value indicates the result from the platform's network layer. See
send/2,3,4 and
nowait send/3,4.
-spec sendfile(socket(), file:fd()) -> {ok, BytesSent} | {error, Reason} | {error, {Reason, BytesSent}} when Reason :: posix() | closed | invalid(), BytesSent :: non_neg_integer().
sendfile(Socket, FileHandle) -> Result
The same as
sendfile(Socket, FileHandle, 0, 0, infinity), that
is: send all data in the file to the socket, without time-out other than from
the platform's network stack.
-spec sendfile(socket(), file:fd(), Timeout) -> {ok, BytesSent} | {select, SelectInfo} | {select, {SelectInfo, BytesSent}} | {error, Reason} | {error, {Reason, BytesSent}} when SelectInfo :: select_info(), Timeout :: timeout() | nowait | select_handle(), Reason :: posix() | closed | invalid() | timeout, BytesSent :: non_neg_integer().
Depending on the Timeout argument; the same as
sendfile(Socket, FileHandle, 0, 0, infinity), sendfile(Socket, FileHandle, 0, 0, Timeout), or
sendfile(Socket, FileHandle, 0, 0, SelectHandle), that
is: send all data in the file to the socket, with the given Timeout.
-spec sendfile(socket(), file:fd(), Offset, Count) -> {ok, BytesSent} | {error, Reason} | {error, {Reason, BytesSent}} when Offset :: integer(), Count :: non_neg_integer(), Reason :: posix() | closed | invalid(), BytesSent :: non_neg_integer().
The same as
sendfile(Socket, FileHandle, Offset, Count, infinity), that
is: send the file data at Offset and Count to the socket, without time-out
other than from the platform's network stack.
-spec sendfile(Socket, Cont, Offset, Count, SelectHandle :: nowait) -> {ok, BytesSent} | {select, SelectInfo} | {select, {SelectInfo, BytesSent}} | {error, Reason} when Socket :: socket(), Cont :: select_info(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Cont, Offset, Count, SelectHandle :: select_handle()) -> {ok, BytesSent} | {select, SelectInfo} | {select, {SelectInfo, BytesSent}} | {error, Reason} when Socket :: socket(), Cont :: select_info(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Cont, Offset, Count, Timeout :: infinity) -> {ok, BytesSent} | {error, Reason} | {error, {Reason, BytesSent}} when Socket :: socket(), Cont :: select_info(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), Reason :: posix() | closed | invalid(); (Socket, Cont, Offset, Count, Timeout :: non_neg_integer()) -> {ok, BytesSent} | {error, Reason | timeout} | {error, {Reason | timeout, BytesSent}} when Socket :: socket(), Cont :: select_info(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), Reason :: posix() | closed | invalid(); (Socket, FileHandle, Offset, Count, SelectHandle :: nowait) -> {ok, BytesSent} | {select, SelectInfo} | {select, {SelectInfo, BytesSent}} | {error, Reason} when Socket :: socket(), FileHandle :: file:fd(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, FileHandle, Offset, Count, SelectHandle :: select_handle()) -> {ok, BytesSent} | {select, SelectInfo} | {select, {SelectInfo, BytesSent}} | {error, Reason} when Socket :: socket(), FileHandle :: file:fd(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, FileHandle, Offset, Count, Timeout :: infinity) -> {ok, BytesSent} | {error, Reason} | {error, {Reason, BytesSent}} when Socket :: socket(), FileHandle :: file:fd(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), Reason :: posix() | closed | invalid(); (Socket, FileHandle, Offset, Count, Timeout :: non_neg_integer()) -> {ok, BytesSent} | {error, Reason | timeout} | {error, {Reason | timeout, BytesSent}} when Socket :: socket(), FileHandle :: file:fd(), Offset :: integer(), Count :: non_neg_integer(), BytesSent :: non_neg_integer(), Reason :: posix() | closed | invalid().
Sends file data on a socket, to the specified destination, waiting for it to be sent ("infinite" time-out).
The FileHandle must refer to an open raw file as described in file:open/2.
This call will not return until the data has been accepted by the platform's network layer, or it reports an error.
The Offset argument is the file offset to start reading from. The default
value is 0.
The Count argument is the number of bytes to transfer from FileHandle to
Socket. If Count =:= 0 (the default) the transfer stops at the end of file.
The return value indicates the result from the platform's network layer:
{ok, BytesSent}- The transfer completed successfully afterBytesSentbytes of data.{error, Reason}- An error has been reported and no data has been transferred. Theposix/0Reasonsare from the platform's network layer.closedmeans that this socket library knows that the socket is closed, andinvalid/0means that something about an argument is invalid.{error, {Reason, BytesSent}}- An error has been reported but before that some data was transferred. See{error, Reason}and{ok, BytesSent}above.
Sends file data on a socket, waiting at most Timeout milliseconds for it to be
sent (limited time-out).
The same as "infinite" time-out sendfile/5 but
returns {error, timeout} or {error, {timeout, BytesSent}} after Timeout
milliseconds, if not all file data was transferred by the platform's network
layer.
Sends file data on a socket, but returns a select continuation if the data could not be sent immediately (nowait).
The same as "infinite" time-out sendfile/5 but
if the data is not immediately accepted by the platform network layer, the
function returns {select, SelectInfo}, and the caller
will then receive a select message, {'$socket', Socket, select, SelectHandle}
( with the SelectHandle that was contained in the
SelectInfo ) when there is room for more data. Then a
call to sendfile/3 with SelectInfo as the second
argument will continue the data transfer.
If SelectHandle is a select_handle/0, that term will be contained in a
returned SelectInfo and the corresponding select message. The SelectHandle
is presumed to be unique to this call.
If SelectHandle is nowait, and a SelectInfo is returned, it will contain a
select_handle() generated by the call.
If some file data was sent, the function will return
{ok, {BytesSent, SelectInfo}.If the caller does not want
to wait to send the rest of the data, it should immediately cancel the operation
with cancel/2.
Continues sending file data on a socket, where the send operation was initiated
by sendfile/3,5 that returned a SelectInfo
continuation. Otherwise like
"infinite" time-out sendfile/5 ,
limited time-out sendfile/5 or
nowait sendfile/5 respectively.
Cont is the SelectInfo that was returned from the previous sendfile()
call.
The return value indicates the result from the platform's network layer. See
"infinite" time-out sendfile/5.
-spec sendmsg(Socket, Msg) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid().
Equivalent to sendmsg/4
-spec sendmsg(Socket, Msg, Flags) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), Flags :: [msg_flag() | integer()], RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: erlang:iovec(), Cont :: select_info(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Msg, Timeout :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), RestData :: erlang:iovec(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Msg, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), RestData :: erlang:iovec(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Msg, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Msg, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Msg :: msg_send(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid().
Equivalent to sendmsg/4
-spec sendmsg(Socket, Msg, Flags, Timeout :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), Flags :: [msg_flag() | integer()], RestData :: erlang:iovec(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Msg, Flags, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), Flags :: [msg_flag() | integer()], RestData :: erlang:iovec(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Msg, Flags, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Msg :: msg_send(), Flags :: [msg_flag() | integer()], RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Msg, Flags, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Msg :: msg_send(), Flags :: [msg_flag() | integer()], RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: msg_send() | erlang:iovec(), Cont :: select_info(), RestData :: erlang:iovec(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, SelectHandle :: select_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: msg_send() | erlang:iovec(), Cont :: select_info(), RestData :: erlang:iovec(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: msg_send() | erlang:iovec(), Cont :: select_info(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: msg_send() | erlang:iovec(), Cont :: select_info(), RestData :: erlang:iovec(), Reason :: posix() | closed | invalid().
Sends a message on a socket, waiting for it to be sent.
The destination, if needed, that is: if the socket is not connected, is
provided in Msg, which also contains the data to send as a
list of binaries. Msg may also contain an list of
optional control messages (depending on what the protocol and
platform supports).
For a connected socket no address field should be present in Msg, the platform
may return an error or ignore one.
The message data is given to to the platform's network layer in the form of an
I/O vector without copying the content. If the number of elements in the I/O
vector is larger than allowed on the platform (reported in the
iov_max field from info/0), on a socket of
type stream the send is iterated over all elements, but for
other socket types the call fails.
This call will not return until the data has been handed over to the platform's network layer, or when it reports an error.
The message Flags may be symbolic msg_flag/0s and/or integer/0s,
matching the platform's appropriate header files. The values of all symbolic
flags and integers are or:ed together.
The return value indicates the result from the platform's network layer. See
send/2,3,4.
Note
On Windows, this function can only be used with datagram and raw sockets.
Sends a message on a socket, waiting at most Timeout milliseconds for it to be
sent.
The same as infinite time-out sendmsg/2,3,4 but
returns {error, timeout} or {error, {timeout, RestData}} after Timeout
milliseconds, if no data or only some of it was accepted by the platform's
network layer.
Note
On Windows, this function can only be used with datagram and raw sockets.
Sends a message on a socket, but returns completion or a select continuation if the data could not be sent immediately.
The same as infinity time-out sendmsg/2,3 but
if the data is not immediately accepted by the platform network layer, the
function returns (on Unix) {select, SelectInfo} or (on
Windows) {completion, CompletionInfo}, and the
caller will then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}( with theSelectHandlethat was contained in theSelectInfo) when there is room for more data. A subsequent call tosendmsg/2-4will then send the data.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the send will be in the
CompletionStatus.
If Handle, is a select_handle/0 or completion_handle/0, that term will
be contained in a returned SelectInfo or CompletionInfo and the
corresponding select or completion message. The Handle is presumed to be
unique to this call.
If Timeout is nowait, and a SelectInfo or CompletionInfo is returned, it
will contain a select_handle/0 or completion_handle/0 generated by the
call.
If some of the data was sent, the function will return
{select, {RestData, SelectInfo},which can only happen
for a socket of type stream. If the caller does not want to wait
to send the rest of the data, it should immediately cancel the operation with
cancel/2.
Note
On Windows, this function can only be used with datagram and raw sockets.
Continues sending a message data on a socket, where the send operation was
initiated by sendmsg/3,4 that returned a
SelectInfo continuation. Otherwise like
infinite time-out sendmsg/2,3,4 ,
limited time-out sendmsg/3,4 or
nowait sendmsg/3,4 respectively.
Cont is the SelectInfo that was returned from the previous sendmsg() call.
The return value indicates the result from the platform's network layer. See
send/2,3,4 and
nowait sendmsg/3,4.
-spec sendto(Socket, Data, Dest) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid().
Equivalent to sendto/4
-spec sendto(Socket, Data, Dest, Flags) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Handle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, SelectHandle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {error, Reason} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, SelectHandle :: select_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {error, Reason} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), SelectInfo :: select_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Cont, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), Cont :: select_info(), RestData :: binary(), Reason :: posix() | closed | invalid().
Continues sending data on a socket, where the send operation was initiated by
sendto/4,5 that returned a SelectInfo
continuation. Otherwise like
infinite time-out sendto/3,4,5 ,
limited time-out sendto/4,5 or
nowait sendto/4,5 respectively.
Cont is the SelectInfo that was returned from the previous sendto() call.
If Data is not a binary/0, it will be copied into one, again.
The return value indicates the result from the platform's network layer. See
send/2,3,4 and
nowait sendto/4,5.
-spec sendto(Socket, Data, Dest, Flags, Handle :: nowait) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), Flags :: [msg_flag() | integer()], RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Flags, Handle :: select_handle() | completion_handle()) -> ok | {ok, RestData} | {select, SelectInfo} | {select, {SelectInfo, RestData}} | {completion, CompletionInfo} | {error, Reason} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), Flags :: [msg_flag() | integer()], RestData :: binary(), SelectInfo :: select_info(), CompletionInfo :: completion_info(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Flags, Timeout :: infinity) -> ok | {ok, RestData} | {error, Reason} | {error, {Reason, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid(); (Socket, Data, Dest, Flags, Timeout :: non_neg_integer()) -> ok | {ok, RestData} | {error, Reason | timeout} | {error, {Reason | timeout, RestData}} when Socket :: socket(), Data :: iodata(), Dest :: sockaddr(), Flags :: [msg_flag() | integer()], RestData :: binary(), Reason :: posix() | closed | invalid().
Sends data on a socket, to the specified destination, waiting for it to be sent.
This call will not return until the data has been accepted by the platform's network layer, or it reports an error.
If this call is used on a connection mode socket or on a connected socket, the platforms's network layer may return an error or ignore the destination address.
The message Flags may be symbolic msg_flag/0s and/or integer/0s,
matching the platform's appropriate header files. The values of all symbolic
flags and integers are or:ed together.
The return value indicates the result from the platform's network layer. See
send/2,3,4.
Sends data on a socket, waiting at most Timeout milliseconds for it to be
sent.
The same as infinite time-out sendto/3,4,5 but
returns {error, timeout} or {error, {timeout, RestData}} after Timeout
milliseconds, if no Data or only some of it was accepted by the platform's
network layer.
Sends data on a socket, but returns completion or a select continuation if the data could not be sent immediately.
The same as infinity time-out sendto/3,4 but if
the data is not immediately accepted by the platform network layer, the function
returns (on Unix) {select, SelectInfo} or (on
Windows) {completion, CompletionInfo}, and the
caller will then receive one of these messages:
selectmessage -{'$socket', Socket, select, SelectHandle}( with theSelectHandlethat was contained in theSelectInfo) when there is room for more data.A subsequent call to
send/2-4will then send the data.completionmessage -{'$socket', Socket, completion, {CompletionHandle, CompletionStatus}}(with theCompletionHandlecontained in theCompletionInfo).The result of the send will be in the
CompletionStatus.
If Handle is a select_handle/0 or completion_handle/0, that term will
be contained in a returned SelectInfo or CompletionInfo and the
corresponding select or completion message. The Handle is presumed to be
unique to this call.
If Handle is nowait, and a SelectInfo or CompletionInfo is returned, it
will contain a select_handle/0 or completion_handle/0 generated by the
call.
If some of the data was sent, the function will return
{select, {RestData, SelectInfo},which can only happen
(on Unix) for a socket of type stream. If the caller does not
want to wait to send the rest of the data, it should immediately cancel the
operation with cancel/2.
-spec setopt(socket(), SocketOption :: {Level :: otp, Opt :: otp_socket_option()}, _) -> ok | {error, invalid() | closed}; (socket(), SocketOption :: socket_option(), _) -> ok | {error, posix() | invalid() | closed}.
Sets a socket option in the protocol level otp, which is this implementation's
level above the OS protocol layers.
See the type otp_socket_option() for a description of the options on this level.
Set a socket option in one of the OS's protocol levels. See the type
socket_option/0 for which options that this implementation knows about, how
they are related to option names in the OS, and if there are known peculiarities
with any of them.
What options are valid depends on what kind of socket it is (domain/0,
type/0 and protocol/0).
See the socket options chapter of the users guide for more info.
Note
Not all options are valid, nor possible to set, on all platforms. That is, even if "we" support an option; it does not mean that the underlying OS does.
-spec setopt(socket(), otp | level(), term(), term()) -> ok | {error, posix() | invalid() | closed}.
setopt(Socket, Level, Opt, Value) -> ok | {error, Reason}
Backwards compatibility function.
The same as setopt(Socket, {Level, Opt}, Value)
-spec setopt_native(socket(), SocketOption :: socket_option() | {Level :: level() | (NativeLevel :: integer()), NativeOpt :: integer()}, Value :: native_value()) -> ok | {error, posix() | invalid() | closed}.
Sets a socket option that may be unknown to our implementation, or that has a type not compatible with our implementation, that is; in "native mode".
If Value is an integer/0 it will be used as a C type (int), if it is a
boolean/0 it will be used as a C type (int) with the C implementations
values for false or true, and if it is a binary/0 its content and size
will be used as the option value.
The socket option may be specified with an ordinary
socket_option() tuple, with a known
Level = level() and an integer NativeOpt, or with both an
integer NativeLevel and NativeOpt.
What options are valid depends on what kind of socket it is (domain/0,
type/0 and protocol/0).
The integer values for NativeLevel and NativeOpt as well as the encoding of
Value has to be deduced from the header files for the running system.
-spec shutdown(Socket, How) -> ok | {error, Reason} when Socket :: socket(), How :: read | write | read_write, Reason :: posix() | closed.
Shut down all or part of a full-duplex connection.
-spec sockname(Socket) -> {ok, SockAddr} | {error, Reason} when Socket :: socket(), SockAddr :: sockaddr_recv(), Reason :: posix() | closed.
Returns the current address to which the socket is bound.
-spec supports() -> [{Key1 :: term(), boolean() | [{Key2 :: term(), boolean() | [{Key3 :: term(), boolean()}]}]}].
Equivalent to supports/2
Equivalent to supports/2
These functions function retrieves information about what the platform supports, such which platform features or which socket options, are supported.
For keys other than the known the empty list is returned, Note that in a future version or on a different platform there might be more supported items.
supports/0- Returns a list of{Key1, supports(Key1)}tuples for everyKey1described insupports/1and{Key1, boolean()}tuples for each of the following keys:sctp- SCTP supportipv6- IPv6 supportlocal- Unix Domain sockets support (AF_UNIX | AF_LOCAL)netns- Network Namespaces support (Linux,setns(2))sendfile- Sendfile support (sendfile(2))
supports(msg_flags = Key1)- Returns a list of{Flag, boolean()}tuples for everyFlaginmsg_flag()with theboolean/0indicating if the flag is supported on this platform.supports(protocols = Key1)- Returns a list of{Name :: atom(), boolean()}tuples for everyNameinprotocol()with theboolean/0indicating if the protocol is supported on this platform.supports(options = Key1)- Returns a list of{SocketOption, boolean()}tuples for everySocketOptioninsocket_option()with theboolean/0indicating if the socket option is supported on this platform.supports(options = Key1, Key2)- For aKey2inlevel()returns a list of{Opt, boolean()}tuples for all known socket optionsOpton thatLevel =:= Key2, and theboolean/0indicating if the socket option is supported on this platform. Seesetopt/3andgetopt/2.
-spec use_registry(D :: boolean()) -> ok.
Globally change if the socket registry is to be used or not. Note that its still
possible to override this explicitly when creating an individual sockets, see
open/2 or open/4 for more info (use the Extra argument).
-spec which_sockets() -> [socket()].
Equivalent to which_sockets/1
-spec which_sockets(FilterRule) -> [socket()] when FilterRule :: inet | inet6 | local | stream | dgram | seqpacket | sctp | tcp | udp | pid() | fun((socket_info()) -> boolean()).
Returns a list of all sockets, according to the filter rule.
There are several pre-made filter rule(s) and one general:
inet | inet6- Selection based on the domain of the socket.
Only a subset is valid.stream | dgram | seqpacket- Selection based on the type of the socket.
Only a subset is valid.sctp | tcp | udp- Selection based on the protocol of the socket.
Only a subset is valid.pid/0- Selection base on which sockets has this pid as Controlling Process.fun((socket_info()) -> boolean())- The general filter rule.
A fun that takes the socket info and returns aboolean/0(trueif the socket could be included andfalseif should not).