socket v0.3.9 Socket.SSL

This module allows usage of SSL sockets and promotion of TCP sockets to SSL sockets.

Options

When creating a socket you can pass a series of options to use for it.

  • :cert can either be an encoded certificate or [path: "path/to/certificate"]
  • :key can either be an encoded certificate, [path: "path/to/key"], [rsa: "rsa encoded"] or [dsa: "dsa encoded"] or [ec: "ec encoded"]
  • :authorities can iehter be an encoded authorities or [path: "path/to/authorities"]
  • :dh can either be an encoded dh or [path: "path/to/dh"]
  • :verify can either be false to disable peer certificate verification, or a keyword list containing a :function and an optional :data
  • :password the password to use to decrypt certificates
  • :renegotiation if it’s set to :secure renegotiation will be secured
  • :ciphers is a list of ciphers to allow
  • :advertised_protocols is a list of strings representing the advertised protocols for NPN
  • :preferred_protocols is a list of strings representing the preferred next protocols for NPN

You can also pass TCP options.

Smart garbage collection

Normally sockets in Erlang are closed when the controlling process exits, with smart garbage collection the controlling process will be the Socket.Manager and it will be closed when there are no more references to it.

Summary

Functions

Accept a connection from a listening SSL socket or start an SSL connection on the given client socket

Accept a connection from a listening SSL socket with the given options or start an SSL connection on the given client socket with the given options

Accept a connection from a listening SSL socket or start an SSL connection on the given client socket, raising if an error occurs

Accept a connection from a listening SSL socket with the given options or start an SSL connection on the given client socket with the given options, raising if an error occurs

Convert SSL options to :ssl.setopts compatible arguments

Get the certificate of the peer

Get the certificate of the peer, raising if an error occurs

Get the list of supported ciphers

Connect to the given address and port tuple or SSL connect the given socket

Connect to the given address and port tuple with the given options or SSL connect the given socket with the given options or connect to the given address and port

Connect to the given address and port with the given options

Connect to the given address and port tuple or SSL connect the given socket, raising if an error occurs

Connect to the given address and port tuple with the given options or SSL connect the given socket with the given options or connect to the given address and port, raising if an error occurs

Connect to the given address and port with the given options, raising if an error occurs

Return a proper error string for the given code or nil if it can’t be converted

Execute the handshake; useful if you want to delay the handshake to make it in another process

Execute the handshake, raising if an error occurs; useful if you want to delay the handshake to make it in another process

Get information about the SSL connection

Get information about the SSL connection, raising if an error occurs

Create an SSL socket listening on an OS chosen port, use local to know the port it was bound on

Create an SSL socket listening on an OS chosen port using the given options or listening on the given port

Create an SSL socket listening on the given port and using the given options

Create an SSL socket listening on an OS chosen port, use local to know the port it was bound on, raising in case of error

Create an SSL socket listening on an OS chosen port using the given options or listening on the given port, raising in case of error

Create an SSL socket listening on the given port and using the given options, raising in case of error

Get the negotiated protocol

Set options of the socket

Set options of the socket, raising if an error occurs

Set the process which will receive the messages

Set the process which will receive the messages, raising if an error occurs

Renegotiate the secure connection

Renegotiate the secure connection, raising if an error occurs

Get the list of supported SSL/TLS versions

Types

t()
t

Functions

accept(self)
accept(Socket.t | t) :: {:ok, t} | {:error, term}

Accept a connection from a listening SSL socket or start an SSL connection on the given client socket.

accept(sock, options)
accept(Socket.t, Keyword.t) :: {:ok, t} | {:error, term}

Accept a connection from a listening SSL socket with the given options or start an SSL connection on the given client socket with the given options.

accept!(socket)
accept!(Socket.t | t) :: t | no_return

Accept a connection from a listening SSL socket or start an SSL connection on the given client socket, raising if an error occurs.

accept!(socket, options)
accept!(Socket.t, t | Keyword.t) :: t | no_return

Accept a connection from a listening SSL socket with the given options or start an SSL connection on the given client socket with the given options, raising if an error occurs.

arguments(options)
arguments(Keyword.t) :: list

Convert SSL options to :ssl.setopts compatible arguments.

certificate(sock)
certificate(t) :: {:ok, String.t} | {:error, term}

Get the certificate of the peer.

certificate!(sock)
certificate!(t) :: String.t | no_return

Get the certificate of the peer, raising if an error occurs.

ciphers()
ciphers() :: [:ssl.erl_cipher_suite]

Get the list of supported ciphers.

connect(socket)
connect(Socket.t | {Socket.t, :inet.port_number}) ::
  {:ok, t} |
  {:error, term}

Connect to the given address and port tuple or SSL connect the given socket.

connect(wrap, options)
connect({Socket.Address.t, :inet.port_number} | Socket.t | Socket.Address.t, Keyword.t | :inet.port_number) ::
  {:ok, t} |
  {:error, term}

Connect to the given address and port tuple with the given options or SSL connect the given socket with the given options or connect to the given address and port.

connect(address, port, options)
connect(Socket.Address.t, :inet.port_number, Keyword.t) ::
  {:ok, t} |
  {:error, term}

Connect to the given address and port with the given options.

connect!(socket_or_descriptor)
connect!(Socket.t | {Socket.t, :inet.port_number}) ::
  t |
  no_return

Connect to the given address and port tuple or SSL connect the given socket, raising if an error occurs.

connect!(descriptor, options)
connect!({Socket.Address.t, :inet.port_number} | Socket.t | Socket.Address.t, Keyword.t | :inet.port_number) ::
  t |
  no_return

Connect to the given address and port tuple with the given options or SSL connect the given socket with the given options or connect to the given address and port, raising if an error occurs.

connect!(address, port, options)
connect!(Socket.Address.t, :inet.port_number, Keyword.t) ::
  t |
  no_return

Connect to the given address and port with the given options, raising if an error occurs.

error(code)
error(term) :: String.t

Return a proper error string for the given code or nil if it can’t be converted.

handshake(sock, options \\ [])
handshake(t, Keyword.t) :: :ok | {:error, term}

Execute the handshake; useful if you want to delay the handshake to make it in another process.

handshake!(sock)
handshake!(t) :: :ok | no_return

Execute the handshake, raising if an error occurs; useful if you want to delay the handshake to make it in another process.

handshake!(sock, options)
handshake!(t, Keyword.t) :: :ok | no_return
info(sock)
info(t) :: {:ok, list} | {:error, term}

Get information about the SSL connection.

info!(sock)
info!(t) :: list | no_return

Get information about the SSL connection, raising if an error occurs.

listen()
listen() :: {:ok, t} | {:error, term}

Create an SSL socket listening on an OS chosen port, use local to know the port it was bound on.

listen(port)
listen(:inet.port_number | Keyword.t) ::
  {:ok, t} |
  {:error, term}

Create an SSL socket listening on an OS chosen port using the given options or listening on the given port.

listen(port, options)
listen(:inet.port_number, Keyword.t) ::
  {:ok, t} |
  {:error, term}

Create an SSL socket listening on the given port and using the given options.

listen!()
listen!() :: t | no_return

Create an SSL socket listening on an OS chosen port, use local to know the port it was bound on, raising in case of error.

listen!(port_or_options)
listen!(:inet.port_number | Keyword.t) :: t | no_return

Create an SSL socket listening on an OS chosen port using the given options or listening on the given port, raising in case of error.

listen!(port, options)
listen!(:inet.port_number, Keyword.t) :: t | no_return

Create an SSL socket listening on the given port and using the given options, raising in case of error.

negotiated_protocol(sock)
negotiated_protocol(t) :: String.t | nil

Get the negotiated protocol.

options(socket, options)
options(t | :ssl.sslsocket, Keyword.t) ::
  :ok |
  {:error, Socket.Error.t}

Set options of the socket.

options!(socket, options)
options!(t | Socket.SSL.t | port, Keyword.t) ::
  :ok |
  no_return

Set options of the socket, raising if an error occurs.

process(sock, pid)
process(t | port, pid) ::
  :ok |
  {:error, :closed | :not_owner | Error.t}

Set the process which will receive the messages.

process!(sock, pid)
process!(t | port, pid) :: :ok | no_return

Set the process which will receive the messages, raising if an error occurs.

renegotiate(sock)
renegotiate(t) :: :ok | {:error, term}

Renegotiate the secure connection.

renegotiate!(sock)
renegotiate!(t) :: :ok | no_return

Renegotiate the secure connection, raising if an error occurs.

versions()
versions() :: [tuple]

Get the list of supported SSL/TLS versions.