socket

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

OTP 22.0

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

OTP 22.0

Types

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

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

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

Cancel an asynchronous request.

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

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

OTP 22.0

Types

Closes the socket.

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

OTP 22.0

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

OTP 22.0

Types

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

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

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.

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

OTP 22.0

Types

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

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.

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

OTP 22.0

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

OTP 22.0

Types

Listen for connections on a socket.

number_of() -> integer() >= 0

OTP 22.3

Returns the number of active sockets.

open(Domain, Type) -> {ok, Socket} | {error, Reason}

OTP 22.0

open(Domain, Type, Protocol) -> {ok, Socket} | {error, Reason}

OTP 22.0

open(Domain, Type, Protocol, Extra) -> {ok, Socket} | {error, Reason}

OTP 22.0

Types

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 Extra argument is intended for "obscure" options. Currently the only supported option is netns, which is only supported on the linux platform.

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

OTP 22.0

Types

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

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} | {select, SelectInfo} | {ok, {Data, SelectInfo}} | {error, Reason}

OTP 22.1

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

OTP 22.1

Types

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

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

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.

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 recvfrom will then return the data).

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

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

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.

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 recvmsg will then return the data).

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

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

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

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

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

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 sendmsg will then send the data).

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

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

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

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 sendto will then send the data).

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

Types

Set options 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.

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

OTP 22.0

Types

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

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

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

OTP 22.0

Types

Returns the current address to which the socket is bound.

supports() -> [{options, supports_options()} | {sctp, boolean()} | {ipv6, boolean()} | {local, boolean()} | {send_flags, supports_send_flags()} | {recv_flags, supports_recv_flags()}]

OTP 22.0

supports(Key1 :: options) -> supports_options()

OTP 22.0

supports(Key1 :: sctp) -> boolean()

OTP 22.0

supports(Key1 :: ipv6) -> boolean()

OTP 22.0

supports(Key1 :: local) -> boolean()

OTP 22.0

supports(Key1 :: send_flags) -> supports_send_flags()

OTP 22.3

supports(Key1 :: recv_flags) -> supports_recv_flags()

OTP 22.3

supports(Key1) -> false

OTP 22.0

supports(Key1 :: options, Level :: socket) -> supports_options_socket()

OTP 22.0

supports(Key1 :: options, Level :: ip) -> supports_options_ip()

OTP 22.0

supports(Key1 :: options, Level :: ipv6) -> supports_options_ipv6()

OTP 22.0

supports(Key1 :: options, Level :: tcp) -> supports_options_tcp()

OTP 22.0

supports(Key1 :: options, Level :: udp) -> supports_options_udp()

OTP 22.0

supports(Key1 :: options, Level :: sctp) -> supports_options_sctp()

OTP 22.0

supports(Key1 :: send_flags, SendFlag :: send_flag()) -> boolean()

OTP 22.3

supports(Key1 :: recv_flags, RecvFlag :: recv_flag()) -> boolean()

OTP 22.3

supports(Key1, Key2) -> false

OTP 22.0

supports(Key1 :: options, Level :: socket, Opt :: socket_option()) -> boolean()

OTP 22.0

supports(Key1 :: options, Level :: ip, Opt :: ip_socket_option()) -> boolean()

OTP 22.0

supports(Key1 :: options, Level :: ipv6, Opt :: ipv6_socket_option()) -> boolean()

OTP 22.0

supports(Key1 :: options, Level :: tcp, Opt :: tcp_socket_option()) -> boolean()

OTP 22.0

supports(Key1 :: options, Level :: udp, Opt :: udp_socket_option()) -> boolean()

OTP 22.0

supports(Key1 :: options, Level :: sctp, Opt :: sctp_socket_option()) -> boolean()

OTP 22.0

supports(Key1, Key2, Key3) -> false

OTP 22.0

Types

This function intends to retreive information about what the platform supports. Such as if SCTP is supported. Or which socket options are supported.

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

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