socket

Since

Module socket was introduced in OTP 22.0.

Description

This module provides an API for network socket. Functions are provided to create, delete and manupilate the sockets aswell as sending and reciving 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, has a timeout argument.

Note

Some functions allow for an asynchronous call. This is achieved by setting the Timeout argument to nowait. For instance, if calling the recv/3 function with Timeout set to nowait (recv(Sock, 0, nowait)) when there is actually nothing to read, it will return with {select, SelectInfo} (SelectInfo contains the SelectRef). When data eventually arrives a 'select' message will be sent to the caller:

: {'$socket', socket(), select, SelectRef}

The caller can now make another call to the recv function and now expect data.

Note that all other users are locked out until the 'current user' has called the function (recv in this case).

Another message the user must be prepared for (when making asynchronous calls) is the abort message:

: {'$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), Info will be {SelectRef, closed}.

Note

There is currently no support for Windows.

Support for IPv6 has been implemented but not tested.

SCTP has only been partly implemented (and not tested).

Data Types

domain() = local | inet | inet6

type() = stream | dgram | raw | rdm | seqpacket

protocol() =
ip | tcp | udp | sctp | icmp | igmp | {raw, integer()}

socket()

As returned by open/1,2,3,4 and accept/1,2.

select_tag()

A tag that describes the (select) operation.

select_ref()

A reference that uniquely identifies the (select) operation.

select_info() = {select_info, select_tag(), select_ref()}

socket_counters() =
    #{read_byte := integer() >= 0,
      read_fails := integer() >= 0,
      read_pkg := integer() >= 0,
      read_pkg_max := integer() >= 0,
      read_tries := integer() >= 0,
      read_waits := integer() >= 0,
      write_byte := integer() >= 0,
      write_fails := integer() >= 0,
      write_pkg := integer() >= 0,
      write_pkg_max := integer() >= 0,
      write_tries := integer() >= 0,
      write_waits := integer() >= 0,
      acc_success := integer() >= 0,
      acc_fails := integer() >= 0,
      acc_tries := integer() >= 0,
      acc_waits := integer() >= 0}

socket_info() =
    #{domain := domain(),
      type := type(),
      protocol := protocol(),
      ctrl := pid(),
      ctype := normal | fromfd | {fromfd, integer()},
      counters := socket_counters(),
      num_readers := integer() >= 0,
      num_writers := integer() >= 0,
      num_acceptors := integer() >= 0,
      writable := boolean(),
      readable := boolean()}

ip4_address() = {0..255, 0..255, 0..255, 0..255}

ip6_address() =
    {0..65535,
     0..65535,
     0..65535,
     0..65535,
     0..65535,
     0..65535,
     0..65535,
     0..65535}

sockaddr() =
    sockaddr_in4() |
    sockaddr_in6() |
    sockaddr_un() |
    sockaddr_ll()

sockaddr_in4() =
    #{family := inet,
      port := port_number(),
      addr := any | broadcast | loopback | ip4_address()}

sockaddr_in6() =
    #{family := inet6,
      port := port_number(),
      addr := any | loopback | ip6_address(),
      flowinfo := in6_flow_info(),
      scope_id := in6_scope_id()}

sockaddr_un() = #{family := local, path := binary() | string()}

sockaddr_ll() =
    #{family := packet,
      protocol := integer() >= 0,
      ifindex := integer(),
      pkttype := packet_type(),
      hatype := integer() >= 0,
      addr := binary()}

port_number() = 0..65535

in6_flow_info() = uint20()

in6_scope_id() = uint32()

send_flags() = [send_flag()]

recv_flags() = [recv_flag()]

recv_flag() = cmsg_cloexec | errqueue | oob | peek | trunc

shutdown_how() = read | write | read_write

sockopt_level() =
otp | socket | ip | ipv6 | tcp | udp | sctp |
integer() >= 0

udp_socket_option() = cork

timeval() = #{sec := integer(), usec := integer()}

ip_tos() =
lowdelay | throughput | reliability | mincost | integer()

ip_mreq() =
#{multiaddr := ip4_address(),
interface := any | ip4_address()}

ip_mreq_source() =
    #{multiaddr := ip4_address(),
      interface := ip4_address(),
      sourceaddr := ip4_address()}

ip_pmtudisc() = want | dont | do | probe

ip_msfilter_mode() = include | exclude

ip_msfilter() =
    #{multiaddr := ip4_address(),
      interface := ip4_address(),
      mode := ip_msfilter_mode(),
      slist := [ip4_address()]}

ip_pktinfo() =
    #{ifindex := integer() >= 0,
      spec_dst := ip4_address(),
      addr := ip4_address()}

ipv6_mreq() =
#{multiaddr := ip6_address(), interface := integer() >= 0}

ipv6_pmtudisc() = ip_pmtudisc()

ipv6_pktinfo() = #{addr := ip6_address(), ifindex := integer()}

sctp_assoc_id() = int32()

sctp_sndrcvinfo() =
    #{stream := uint16(),
      ssn := uint16(),
      flags := uint16(),
      ppid := uint16(),
      context := uint16(),
      timetolive := uint16(),
      tsn := uint16(),
      cumtsn := uint16(),
      assoc_id := sctp_assoc_id()}

sctp_event_subscribe() =
    #{data_in := boolean(),
      association := boolean(),
      address := boolean(),
      send_failure := boolean(),
      peer_error := boolean(),
      shutdown := boolean(),
      partial_delivery := boolean(),
      adaptation_layer := boolean(),
      authentication := boolean(),
      sender_dry := boolean()}

sctp_assocparams() =
    #{assoc_id := sctp_assoc_id(),
      max_rxt := uint16(),
      num_peer_dests := uint16(),
      peer_rwnd := uint32(),
      local_rwnd := uint32(),
      cookie_life := uint32()}

sctp_initmsg() =
    #{num_outstreams := uint16(),
      max_instreams := uint16(),
      max_attempts := uint16(),
      max_init_timeo := uint16()}

sctp_rtoinfo() =
    #{assoc_id := sctp_assoc_id(),
      initial := uint32(),
      max := uint32(),
      min := uint32()}

msghdr_flag() = ctrunc | eor | errqueue | oob | trunc

msghdr_flags() = [msghdr_flag()]

msghdr() =
    #{addr := sockaddr(),
      iov := [binary()],
      ctrl := [cmsghdr_recv()] | [cmsghdr_send()],
      flags := msghdr_flags()}

cmsghdr_level() = socket | ip | ipv6 | integer()

cmsghdr_recv() =
    #{level := socket, type := timestamp, data := timeval()} |
    #{level := socket, type := rights, data := binary()} |
    #{level := socket, type := credentials, data := binary()} |
    #{level := socket, type := integer(), data := binary()} |
    #{level := ip, type := tos, data := ip_tos()} |
    #{level := ip, type := recvtos, data := ip_tos()} |
    #{level := ip, type := ttl, data := integer()} |
    #{level := ip, type := recvttl, data := integer()} |
    #{level := ip, type := pktinfo, data := ip_pktinfo()} |
    #{level := ip, type := origdstaddr, data := sockaddr_in4()} |
    #{level := ip,
      type := recverr,
      data := extended_err() | binary()} |
    #{level := ip, type := integer(), data := binary()} |
    #{level := ipv6, type := hoplevel, data := integer()} |
    #{level := ipv6, type := pktinfo, data := ipv6_pktinfo()} |
    #{level := ipv6,
      type := recverr,
      data := extended_err() | binary()} |
    #{level := ipv6, type := tclass, data := integer()} |
    #{level := ipv6, type := integer(), data := binary()} |
    #{level := integer(), type := integer(), data := binary()}

cmsghdr_send() =
    #{level := socket, type := timestamp, data := binary()} |
    #{level := socket, type := rights, data := binary()} |
    #{level := socket, type := credentials, data := binary()} |
    #{level := socket, type := integer(), data := binary()} |
    #{level := ip, type := tos, data := ip_tos() | binary()} |
    #{level := ip, type := ttl, data := integer() | binary()} |
    #{level := ip, type := integer(), data := binary()} |
    #{level := ipv6, type := tclass, data := integer()} |
    #{level := ipv6, type := integer(), data := binary()} |
    #{level := udp, type := integer(), data := binary()} |
    #{level := integer(), type := integer(), data := binary()}

ee_origin() = none | local | icmp | icmp6 | uint8()

extended_err() =
    #{error := term(),
      origin := icmp,
      type := dest_unreach,
      code := icmp_dest_unreach(),
      info := uint32(),
      data := uint32(),
      offender := undefined | sockaddr()} |
    #{error := term(),
      origin := icmp,
      type := time_exceeded | uint8(),
      code := uint8(),
      info := uint32(),
      data := uint32(),
      offender := undefined | sockaddr()} |
    #{error := term(),
      origin := icmp6,
      type := dest_unreach,
      code := icmpv6_dest_unreach(),
      info := uint32(),
      data := uint32(),
      offender := undefined | sockaddr()} |
    #{error := term(),
      origin := icmp6,
      type := pkt_toobig | time_exceeded | uint8(),
      code := uint8(),
      info := uint32(),
      data := uint32(),
      offender := undefined | sockaddr()} |
    #{error := term(),
      origin := ee_origin(),
      type := uint8(),
      code := uint8(),
      info := uint32(),
      data := uint32(),
      offender := undefined | sockaddr()}

uint8() = 0..255

uint16() = 0..65535

uint20() = 0..1048575

uint32() = 0..4294967295

int32() = -2147483648..2147483647

errcode() =
inet:posix() | exalloc | exmonitor | exselect | exself

The POSIX error codes are mostly come from the OS level socket interface, but this module may generate some appropriate POSIX codes.

The other values come from this module's lower levels and are all fairly fatal internal errors:

exalloc: Memory allocation failed
exmonitor: Failed to set a monitor on a process
exselect: Select operation failed
exself: Failed to get current process

Exports

accept(LSocket) -> {ok, Socket} | {error, Reason}

OTP 22.0

accept(LSocket, Timeout) -> {ok, Socket} | {error, Reason}

OTP 22.0

Types

LSocket = socket()

Timeout = timeout()

Socket = socket()

Reason = errcode() | closed | timeout

Accept a connection on a socket.

This call is used with connection-based socket types (stream or seqpacket). It extracs the first pending connection request for the listen socket and returns the (newly) connected socket.

accept(LSocket, Timeout :: nowait) ->
{ok, Socket} | {select, SelectInfo} | {error, Reason}

OTP 22.1

Types

LSocket = Socket = socket()

SelectInfo = select_info()

Reason = errcode() | closed

Accept a connection on a socket.

This call is used with connection-based socket types (stream or seqpacket). It extracs the first pending connection request for the listen socket and returns the (newly) connected socket.

In the case when there is no connections waiting, the function will return with the SelectInfo. The caller can then await a select message, {'$socket', Socket, select, Info} (where Info is the ref field from the SelectInfo), when a client connects (a subsequent call to accept will then return the socket).

bind(Socket, Addr) -> {ok, Port} | {error, Reason}

OTP 22.0

Types

Socket = socket()

Addr = sockaddr() | any | broadcast | loopback

Port = port_number()

Reason = inet:posix() | closed

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.

cancel(Socket, SelectInfo) -> ok | {error, Reason}

OTP 22.1

Types

Socket = socket()

SelectInfo = select_info()

Reason = einval | closed | exself

Cancel an asynchronous request.

Call this function in order to cancel a previous asynchronous call to, e.g. recv/3.

OTP 22.0

Types

Socket = socket()

Reason = errcode() | 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 shutdown function (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.

connect(Socket, SockAddr) -> ok | {error, Reason}

OTP 22.0

connect(Socket, SockAddr, Timeout) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

SockAddr = sockaddr()

Timeout = timeout()

Reason = errcode() | closed | timeout

This function connects the socket to the address specied by the SockAddr argument.

connect(Socket, SockAddr, Timeout :: nowait) ->
ok | {select, SelectInfo} | {error, Reason}

OTP 22.1

Types

Socket = socket()

SockAddr = sockaddr()

SelectInfo = select_info()

Reason = errcode() | closed

This function connects the socket to the address specied by the SockAddr argument.

In the case when its not possible to immediately establish a connection, the function will return with the SelectInfo. The caller can then await a select message, {'$socket', Socket, select, Info} (where Info is the ref field from the SelectInfo, a subsequent call to connect will then establish the connection).

getopt(Socket, Level :: otp, Key :: otp_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: socket, Key :: socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: ip, Key :: ip_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: ipv6, Key :: ipv6_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: tcp, Key :: tcp_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: udp, Key :: udp_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

getopt(Socket, Level :: sctp, Key :: sctp_socket_option()) ->
{ok, Value} | {error, Reason}

OTP 22.0

Types

Socket = socket()

Value = term()

Reason = inet:posix() | closed

Get an option on a socket.

What properties are valid depend both on Level and on what kind of socket it is (domain, type and protocol).

See the socket options chapter of the users guide for more info.

Note

Not all options are valid on all platforms. That is, even if "we" support an option, that does not mean that the underlying OS does.

getopt(Socket, Level, Key) -> ok | {ok, Value} | {error, Reason}

OTP 22.0

Types

Socket = socket()

Level = integer()

Key = {NativeOpt, ValueSize}

NativeOpt = integer()

ValueSize = int | bool | integer() >= 0

Value = term()

Reason = inet:posix() | closed

Get an option on a socket.

When specifying Level as an integer, and therefor using "native mode", it is *currently* up to the caller to know how to interpret the result.

For more info, see getopt above.

info(Socket) -> socket_info()

OTP 22.1

Types

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.

listen(Socket) -> ok | {error, Reason}

OTP 22.0

listen(Socket, Backlog) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

Backlog = integer()

Reason = inet:posix() | closed

Listen for connections on a socket.

number_of() -> integer() >= 0

OTP 22.3

Returns the number of active sockets.

OTP 23.0

Types

FD = integer()

Opts =
    #{domain => domain(),
      type => type(),
      protocol => protocol(),
      dup => boolean()}

Socket = socket()

Reason = errcode()

Create 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 in those cases it expects it in Opts.

The Opts argument is intended for providing extra information for the open call:

dup: boolean(): Shall the provided descriptor be duplicated (dup) or not.
Defaults to true.
debug: boolean(): Enable or disable debug during the open call.
Defaults to false.
domain: socket:domain(): Which domain is the descriptor of.
type: socket:type(): Which type is the descriptor of.
protocol: socket:protocol(): Which protocol is the descriptor of.

Note

This function should be used with care!

On some platforms its necessary to provide the protocol as its impossible to retrieve it.

OTP 22.0

Types

Domain = domain()

Type = type()

Protocol = default | protocol()

Opts = map()

Socket = socket()

Reason = errcode()

Creates an endpoint (socket) for communication.

For some types there is a default protocol, indicated by default, which it may be possible to specify. And for Domain = local, if a protocol is pecified, it must be default.

The Opts argument is intended for "other" options. Currently the only supported option(s) are netns, which is only supported on the linux platform and debug (controls debug printouts during the open call).

Note

It may not be possible to specify the default protocol (except when Domain = local). We need to be able to retreive the resulting protocol, which is not possble on all platforms.

peername(Socket) -> {ok, SockAddr} | {error, Reason}

OTP 22.0

Types

Socket = socket()

SockAddr = sockaddr()

Reason = inet:posix() | closed

Returns the address of the peer connected to the socket.

recv(Socket) -> {ok, Data} | {error, Reason}

OTP 22.0

recv(Socket, Length) -> {ok, Data} | {error, Reason}

OTP 22.0

recv(Socket, Length, Flags) -> {ok, Data} | {error, Reason}

OTP 22.0

recv(Socket, Length, Timeout) -> {ok, Data} | {error, Reason}

OTP 22.0

recv(Socket, Length, Flags, Timeout) ->
{ok, Data} | {error, Reason}

OTP 22.0

Types

Socket = socket()

Length = integer() >= 0

Flags = recv_flags()

Timeout = timeout()

Data = binary()

Reason =
    errcode() |
    closed | timeout |
    {errcode() | closed | timeout, Data :: binary()}

Receive a message from a socket.

There is a special case for the argument Length. If it is set to zero (0), it means "give me everything you currently have".

recv(Socket, Length, Timeout :: nowait) ->
        {ok, Data} |
        {ok, {Data, SelectInfo}} |
        {select, SelectInfo} |
        {error, Reason}

OTP 22.1

recv(Socket, Length, Flags, Timeout :: nowait) ->
        {ok, Data} |
        {ok, {Data, SelectInfo}} |
        {select, SelectInfo} |
        {error, Reason}

OTP 22.1

Types

Socket = socket()

Length = integer() >= 0

Flags = recv_flags()

Data = binary()

SelectInfo = select_info()

Reason =
errcode() | closed | {errcode() | closed, Data :: binary()}

Receive a message from a socket.

There is a special case for the argument Length. If it is set to zero (0), it means "give me everything you currently have".

In the case when there is no data waiting, the function will return with the SelectInfo. The caller can then await a select message, {'$socket', Socket, select, Info} (where Info is the ref field from the SelectInfo), when data has arrived (a subsequent call to recv will then return the data).

Note that if a length (> 0) is specified, and only part of that amount of data is available, the function will return with that data and the SelectInfo (if the caller don't want to wait for the remaining data, it must immediately call the cancel/2 function.)

recvfrom(Socket) -> {ok, {Source, Data}} | {error, Reason}

OTP 22.0

recvfrom(Socket, BufSz) -> {ok, {Source, Data}} | {error, Reason}

OTP 22.0

recvfrom(Socket, Flags, Timeout) ->
{ok, {Source, Data}} | {error, Reason}

OTP 22.0

recvfrom(Socket, BufSz, Flags) ->
{ok, {Source, Data}} | {error, Reason}

OTP 22.0

recvfrom(Socket, BufSz, Timeout) ->
{ok, {Source, Data}} | {error, Reason}

OTP 22.0

recvfrom(Socket, BufSz, Flags, Timeout) ->
{ok, {Source, Data}} | {error, Reason}

OTP 22.0

Types

Socket = socket()

BufSz = integer() >= 0

Flags = recv_flags()

Timeout = timeout()

Source = sockaddr() | undefined

Data = binary()

Reason = errcode() | closed | timeout

Receive a message from a socket.

This function reads "messages", which means that regardless of how much we want to read, it returns when we get a message (if the buffer size is too small, the message will be truncated).

The BufSz argument basically defines the size of the receive buffer. By setting the value to zero (0), the configured size (setopt with Level = otp and Key = rcvbuf) is used.

It may be impossible to know what (buffer) size is appropriate "in advance", and in those cases it may be convenient to use the (recv) 'peek' flag. When this flag is provided, the message is *not* "consumed" from the underlying buffers, so another recvfrom call is needed, possibly with a then adjusted buffer size.

recvfrom(Socket, Flags, Timeout :: nowait) ->
            {ok, {Source, Data}} |
            {select, SelectInfo} |
            {error, Reason}

OTP 22.1

recvfrom(Socket, BufSz, Timeout :: nowait) ->
            {ok, {Source, Data}} |
            {select, SelectInfo} |
            {error, Reason}

OTP 22.1

recvfrom(Socket, BufSz, Flags, Timeout :: nowait) ->
            {ok, {Source, Data}} |
            {select, SelectInfo} |
            {error, Reason}

OTP 22.1

Types

Socket = socket()

BufSz = integer() >= 0

Flags = recv_flags()

Source = sockaddr() | undefined

Data = binary()

SelectInfo = select_info()

Reason = errcode() | closed

Receive a message from a socket.

This function reads "messages", which means that regardless of how much we want to read, it returns when we get a message (if the buffer size is too small, the message will be truncated).

The BufSz argument basically defines the size of the receive buffer. By setting the value to zero (0), the configured size (setopt with Level = otp and Key = rcvbuf) is used.

recvmsg(Socket) -> {ok, MsgHdr} | {error, Reason}

OTP 22.0

recvmsg(Socket, Flags) -> {ok, MsgHdr} | {error, Reason}

OTP 22.0

recvmsg(Socket, Timeout) -> {ok, MsgHdr} | {error, Reason}

OTP 22.0

recvmsg(Socket, Flags, Timeout) -> {ok, MsgHdr} | {error, Reason}

OTP 22.0

recvmsg(Socket, BufSz, CtrlSz) -> {ok, MsgHdr} | {error, Reason}

OTP 22.0

recvmsg(Socket, BufSz, CtrlSz, Flags, Timeout) ->
{ok, MsgHdr} | {error, Reason}

OTP 22.0

Types

Socket = socket()

BufSz = CtrlSz = integer() >= 0

Flags = recv_flags()

Timeout = timeout()

MsgHdr = msghdr()

Reason = errcode() | closed | timeout

Receive a message from a socket.

This function reads "messages", which means that regardless of how much we want to read, it returns when we get a message.

The message will be delivered in the form of a msghdr(), which may contain the source address (if socket not connected), a list of cmsghdr_recv() (depends on what socket options have been set and what the protocol and platform supports) and also a set of flags, providing further info about the read.

The BufSz argument basically defines the size of the receive buffer. By setting the value to zero (0), the configured size (setopt with Level = otp and Key = rcvbuf) is used.

The CtrlSz argument basically defines the size of the receive buffer for the control messages. By setting the value to zero (0), the configured size (setopt with Level = otp) is used.

It may be impossible to know what (buffer) size is appropriate "in advance", and in those cases it may be convenient to use the (recv) 'peek' flag. When this flag is provided, the message is *not* "consumed" from the underlying buffers, so another recvmsg call is needed, possibly with a then adjusted buffer size.

recvmsg(Socket, Timeout :: nowait) ->
{ok, MsgHdr} | {select, SelectInfo} | {error, Reason}

OTP 22.1

recvmsg(Socket, Flags, Timeout :: nowait) ->
{ok, MsgHdr} | {select, SelectInfo} | {error, Reason}

OTP 22.1

recvmsg(Socket, BufSz, CtrlSz, Flags, Timeout :: nowait) ->
{ok, MsgHdr} | {select, SelectInfo} | {error, Reason}

OTP 22.1

Types

Socket = socket()

BufSz = CtrlSz = integer() >= 0

Flags = recv_flags()

MsgHdr = msghdr()

SelectInfo = select_info()

Reason = errcode() | closed

Receive a message from a socket.

This function reads "messages", which means that regardless of how much we want to read, it returns when we get a message.

The BufSz argument basically defines the size of the receive buffer. By setting the value to zero (0), the configured size (setopt with Level = otp and Key = rcvbuf) is used.

The CtrlSz argument basically defines the size of the receive buffer for the control messages. By setting the value to zero (0), the configured size (setopt with Level = otp) is used.

It may be impossible to know what (buffer) size is appropriate "in advance", and in those cases it may be convenient to use the (recv) 'peek' flag. When this flag is provided, the message is *not* "consumed" from the underlying buffers, so another recvmsg call is needed, possibly with a then adjusted buffer size.

send(Socket, Data) -> ok | {error, Reason}

OTP 22.0

send(Socket, Data, Flags) -> ok | {error, Reason}

OTP 22.0

send(Socket, Data, Timeout) -> ok | {error, Reason}

OTP 22.0

send(Socket, Data, Flags, Timeout) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

Data = iodata()

Flags = send_flags()

Timeout = timeout()

Reason =
{errcode() | closed | timeout, Remaining :: integer() >= 1}

Send a message on a connected socket.

send(Socket, Data, Timeout :: nowait) ->
        ok |
        {ok, {binary(), SelectInfo}} |
        {select, SelectInfo} |
        {ok, {RestData, SelectInfo}} |
        {error, Reason}

OTP 22.1

send(Socket, Data, Flags, Timeout :: nowait) ->
        ok |
        {select, SelectInfo} |
        {ok, {RestData, SelectInfo}} |
        {error, Reason}

OTP 22.1

Types

Socket = socket()

Data = iodata()

Flags = send_flags()

RestData = binary()

SelectInfo = select_info()

Reason = {errcode() | closed, Remaining :: integer() >= 1}

Send a message on a connected socket.

In the case when there is no room in the (system-) buffers, the function will return with the SelectInfo. The caller can then await a select message, {'$socket', Socket, select, Info} (where Info is the ref field from the SelectInfo), when there is room for more data (a subsequent call to send will then send the data).

Note that if not all the data was sent, the function will return with the remaining data and the SelectInfo (if the caller don't want to wait to be able to send the rest, it should immediately call the cancel/2 function.)

sendmsg(Socket, MsgHdr) -> ok | {ok, Remaining} | {error, Reason}

OTP 22.0

sendmsg(Socket, MsgHdr, Flags) -> ok | {error, Reason}

OTP 22.0

sendmsg(Socket, MsgHdr, Timeout) -> ok | {error, Reason}

OTP 22.0

sendmsg(Socket, MsgHdr, Flags, Timeout) ->
ok | {ok, Remaining} | {error, Reason}

OTP 22.0

Types

Socket = socket()

MsgHdr = msghdr()

Flags = send_flags()

Timeout = timeout()

Remaining = erlang:iovec()

Reason = errcode() | closed | timeout

Send a message on a socket. The destination, if needed (socket not connected) is provided in the MsgHdr, which also contains the message to send, The MsgHdr may also contain an list of optional cmsghdr_send() (depends on what the protocol and platform supports).

Unlike the send function, this one sends one message. This means that if, for whatever reason, its not possible to send the message in one go, the function will instead return with the remaining data ({ok, Remaining}). Thereby leaving it up to the caller to decide what to do (retry with the remaining data of give up).

sendmsg(Socket, MsgHdr, Timeout :: nowait) ->
ok | {ok, Remaining} | {error, Reason}

OTP 22.1

sendmsg(Socket, MsgHdr, Flags, Timeout :: nowait) ->
ok | {ok, Remaining} | {error, Reason}

OTP 22.1

Types

Socket = socket()

MsgHdr = msghdr()

Flags = send_flags()

Remaining = erlang:iovec()

Reason = errcode() | closed

sendto(Socket, Data, Dest) -> ok | {error, Reason}

OTP 22.0

sendto(Socket, Data, Dest, Flags) -> ok | {error, Reason}

OTP 22.0

sendto(Socket, Data, Dest, Timeout) -> ok | {error, Reason}

OTP 22.0

sendto(Socket, Data, Dest, Flags, Timeout) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

Data = binary()

Dest = sockaddr()

Flags = send_flags()

Timeout = timeout()

Reason =
{errcode() | closed | timeout, Remaining :: integer() >= 1}

Send a message on a socket, to the specified destination.

sendto(Socket, Data, Dest, Timeout :: nowait) ->
ok | {select, SelectInfo} | {error, Reason}

OTP 22.1

sendto(Socket, Data, Dest, Flags, Timeout :: nowait) ->
          ok |
          {ok, {binary(), SelectInfo}} |
          {select, SelectInfo} |
          {error, Reason}

OTP 22.1

Types

Socket = socket()

Data = binary()

Dest = sockaddr()

Flags = send_flags()

SelectInfo = select_info()

Reason = {errcode() | closed, Remaining :: integer() >= 1}

Send a message on a socket, to the specified destination.

setopt(Socket, Level :: otp, Key :: otp_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: socket, Key :: socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: ip, Key :: ip_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: ipv6, Key :: ipv6_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: tcp, Key :: tcp_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: udp, Key :: udp_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level :: sctp, Key :: sctp_socket_option(), Value) ->
ok | {error, Reason}

OTP 22.0

setopt(Socket, Level, Key, Value) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

Level = Key = integer() >= 0

Value = binary()

Reason = inet:posix() | closed

Set an option on a socket.

What options are valid depend both on Level and on what kind of socket it is (domain, type and protocol).

See the socket options chapter of the users guide for more info.

Note

Not all options are valid on all platforms. That is, even if "we" support an option, that does not mean that the underlying OS does.

Note

Sockets are set 'non-blocking' when created, so this option is *not* available (as it would adversely effect the Erlang VM to set a socket 'blocking').

setopt(Socket, Level, Key, Value) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

Level = Key = integer() >= 0

Value = binary()

Reason = inet:posix() | closed

Set options on a socket.

When specifying Level as an integer, and therefor using "native mode", it is *currently* up to the caller to know how to encode the Value.

For more info, see setopt above.

shutdown(Socket, How) -> ok | {error, Reason}

OTP 22.0

Types

Socket = socket()

How = shutdown_how()

Reason = inet:posix() | closed

Shut down all or part of a full-duplex connection.

sockname(Socket) -> {ok, SockAddr} | {error, Reason}

OTP 22.0

Types

Socket = socket()

SockAddr = sockaddr()

Reason = inet:posix() | closed

Returns the current address to which the socket is bound.

supports() -> Supports

OTP 22.0

supports(Key1 :: options) -> SupportsOptions

OTP 22.0

supports(Key1 :: send_flags) -> SupportsSendFlags

OTP 22.0

supports(Key1 :: recv_flags) -> SupportsRecvFlags

OTP 22.0

supports(Key1 :: options, Key2 :: socket) -> SupportsOptionsSocket

OTP 22.0

supports(Key1 :: options, Key2 :: ip) -> SupportsOptionsIP

OTP 22.0

supports(Key1 :: options, Key2 :: ipv6) -> SupportsOptionsIPv6

OTP 22.0

supports(Key1 :: options, Key2 :: tcp) -> SupportsOptionsTCP

OTP 22.0

supports(Key1 :: options, Key2 :: udp) -> SupportsOptionsUDP

OTP 22.0

supports(Key1 :: options, Key2 :: sctp) -> SupportsOptionsSCTP

OTP 22.0

Types

Supports :: [{Feature, boolean()} | {send_flags, SupportsSendFlags} | {recv_flags, SupportsRecvFlags} | {options, SupportsOptions}]

Feature :: sctp | ipv6 | local | netns

SupportsSendFlags :: [{send_flag(), boolean()}]

SupportsRecvFlags :: [{recv_flag(), boolean()}]

SupportsOptions :: [{socket, SupportsOptionsSocket} | {ip, SupportsOptionsIP} | {ipv6, SupportsOptionsIPv6} | {tcp, SupportsOptionsTCP} | {udp, SupportsOptionsUDP} | {sctp, SupportsOptionsSCTP}]

SupportsOptionsSocket :: [{socket_option(), boolean()}]

SupportsOptionsIP :: [{ip_socket_option(), boolean()}]

SupportsOptionsIPv6 :: [{ipv6_socket_option(), boolean()}]

SupportsOptionsTCP :: [{tcp_socket_option(), boolean()}]

SupportsOptionsUDP :: [{udp_socket_option(), boolean()}]

SupportsOptionsSCTP :: [{sctp_socket_option(), boolean()}]

This function retreives information about what the platform supports, such as if SCTP is supported, 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.

is_supported(Key1 :: sctp | ipv6 | local | netns) -> boolean()

OTP 23.0

is_supported(Key1 :: send_flags, Key2 :: SendFlag) -> boolean()

OTP 23.0

is_supported(Key1 :: recv_flags, Key2 :: RecvFlag) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: socket, Key3 :: SocketOption) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: ip, Key3 :: IPSocketOption) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: ipv6, Key3 :: IPv6SocketOption) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: tcp, Key3 :: TCPSocketOption) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: udp, Key3 :: UDPSocketOption) -> boolean()

OTP 23.0

is_supported(Key1 :: options, Key2 :: sctp, Key3 :: SCTPSocketOption) -> boolean()

OTP 23.0

Types

SocketOption :: socket_option()

IPSocketOption :: ip_socket_option()

IPv6SocketOption :: ipv6_socket_option()

TCPSocketOption :: tcp_socket_option()

UDPSocketOption :: udp_socket_option()

SCTPSocketOption :: sctp_socket_option()

This function retreives information about what the platform supports, such as if SCTP is supported, or which 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.

which_sockets() -> [socket()]

OTP 22.3

which_sockets(FilterRule) -> [socket()]

OTP 22.3

Types

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(): 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 a boolean() (true if the socket sould be included and false if should not).

Examples

client(Addr, SAddr, SPort) ->
   {ok, Sock} = socket:open(inet, stream, tcp),
   {ok, _} = socket:bind(Sock, #{family => inet,
                                 addr   => Addr}),
   ok = socket:connect(Sock, #{family => inet,
                               addr   => SAddr,
			       port   => SPort}),
   Msg = list_to_binary("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:shutdown(Sock, write),
   ok = socket:close(Sock),
   ok = socket:close(LSock).

Table of Contents

socket

Module

Module Summary

Since

Description

Data Types

Exports

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Types

Examples