res_http_websocket.c File Reference

WebSocket support for the Asterisk internal HTTP server. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/http.h"
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/file.h"
#include "asterisk/unaligned.h"
#include "asterisk/uri.h"
#include "asterisk/uuid.h"
#include "asterisk/http_websocket.h"

Include dependency graph for res_http_websocket.c:

Go to the source code of this file.

Data Structures
struct	ast_websocket
	Structure definition for session. More...
struct	ast_websocket_server
	Structure for a WebSocket server. More...
struct	websocket_client

Macros
#define	AST_API_MODULE
#define	CLIENT_KEY_SIZE   16
	Length of a websocket's client key.
#define	DEFAULT_RECONSTRUCTION_CEILING   AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE
	Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will start a payload.
#define	MAX_PROTOCOL_BUCKETS   7
	Number of buckets for registered protocols.
#define	MAX_WS_HDR_SZ   14
	Maximum size of a websocket frame header 1 byte flags and opcode 1 byte mask flag + payload len 8 bytes max extended length 4 bytes optional masking key ... payload follows ...
#define	MAXIMUM_RECONSTRUCTION_CEILING   AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE
	Maximum reconstruction size for multi-frame payload reconstruction.
#define	MIN_WS_HDR_SZ   2
#define	optional_header_spec   "%s%s%s"
#define	print_optional_header(test, name, value)
#define	WEBSOCKET_GUID   "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
	GUID used to compute the accept key, defined in the specifications.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
int AST_OPTIONAL_API_NAME()	ast_websocket_add_protocol (const char *name, ast_websocket_callback callback)
	Add a sub-protocol handler to the default /ws server.
int AST_OPTIONAL_API_NAME()	ast_websocket_add_protocol2 (struct ast_websocket_protocol *protocol)
	Add a sub-protocol handler to the default /ws server.
const char *AST_OPTIONAL_API_NAME()	ast_websocket_client_accept_protocol (struct ast_websocket *ws)
	Retrieve the server accepted sub-protocol on the client.
struct ast_websocket *AST_OPTIONAL_API_NAME()	ast_websocket_client_create (const char *uri, const char *protocols, struct ast_tls_config *tls_cfg, enum ast_websocket_result *result)
	Create, and connect, a websocket client.
struct ast_websocket *AST_OPTIONAL_API_NAME()	ast_websocket_client_create_with_options (struct ast_websocket_client_options *options, enum ast_websocket_result *result)
	Create, and connect, a websocket client using given options.
int AST_OPTIONAL_API_NAME()	ast_websocket_close (struct ast_websocket *session, uint16_t reason)
	Close function for websocket session.
int AST_OPTIONAL_API_NAME()	ast_websocket_fd (struct ast_websocket *session)
	Get the file descriptor for a WebSocket session.
int AST_OPTIONAL_API_NAME()	ast_websocket_is_secure (struct ast_websocket *session)
	Get whether the WebSocket session is using a secure transport or not.
struct ast_sockaddr *AST_OPTIONAL_API_NAME()	ast_websocket_local_address (struct ast_websocket *session)
	Get the local address for a WebSocket connection session.
int AST_OPTIONAL_API_NAME()	ast_websocket_read (struct ast_websocket *session, char **payload, uint64_t *payload_len, enum ast_websocket_opcode *opcode, int *fragmented)
	Read a WebSocket frame and handle it.
int AST_OPTIONAL_API_NAME()	ast_websocket_read_string (struct ast_websocket *ws, char **buf)
	Read a WebSocket frame containing string data.
void AST_OPTIONAL_API_NAME()	ast_websocket_reconstruct_disable (struct ast_websocket *session)
	Disable multi-frame reconstruction.
void AST_OPTIONAL_API_NAME()	ast_websocket_reconstruct_enable (struct ast_websocket *session, size_t bytes)
	Enable multi-frame reconstruction up to a certain number of bytes.
void AST_OPTIONAL_API_NAME()	ast_websocket_ref (struct ast_websocket *session)
	Increase the reference count for a WebSocket session.
struct ast_sockaddr *AST_OPTIONAL_API_NAME()	ast_websocket_remote_address (struct ast_websocket *session)
	Get the remote address for a WebSocket connected session.
int AST_OPTIONAL_API_NAME()	ast_websocket_remove_protocol (const char *name, ast_websocket_callback callback)
	Remove a sub-protocol handler from the default /ws server.
const char *AST_OPTIONAL_API_NAME()	ast_websocket_result_to_str (enum ast_websocket_result result)
	Convert a websocket result code to a string.
int AST_OPTIONAL_API_NAME()	ast_websocket_server_add_protocol (struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
	Add a sub-protocol handler to the given server.
int AST_OPTIONAL_API_NAME()	ast_websocket_server_add_protocol2 (struct ast_websocket_server *server, struct ast_websocket_protocol *protocol)
	Add a sub-protocol handler to the given server.
struct ast_websocket_server *AST_OPTIONAL_API_NAME()	ast_websocket_server_create (void)
	Creates a ast_websocket_server.
int AST_OPTIONAL_API_NAME()	ast_websocket_server_remove_protocol (struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
	Remove a sub-protocol handler from the given server.
const char *AST_OPTIONAL_API_NAME()	ast_websocket_session_id (struct ast_websocket *session)
	Get the session ID for a WebSocket session.
int AST_OPTIONAL_API_NAME()	ast_websocket_set_nonblock (struct ast_websocket *session)
	Set the socket of a WebSocket session to be non-blocking.
int AST_OPTIONAL_API_NAME()	ast_websocket_set_timeout (struct ast_websocket *session, int timeout)
	Set the timeout on a non-blocking WebSocket session.
struct ast_websocket_protocol *AST_OPTIONAL_API_NAME()	ast_websocket_sub_protocol_alloc (const char *name)
	Allocate a websocket sub-protocol instance.
const char *	ast_websocket_type_to_str (enum ast_websocket_type type)
void AST_OPTIONAL_API_NAME()	ast_websocket_unref (struct ast_websocket *session)
	Decrease the reference count for a WebSocket session.
int AST_OPTIONAL_API_NAME()	ast_websocket_uri_cb (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_vars, struct ast_variable *headers)
	Callback suitable for use with a ast_http_uri.
int AST_OPTIONAL_API_NAME()	ast_websocket_wait_for_input (struct ast_websocket *session, int timeout)
	Wait for the WebSocket session to be ready to be read.
int AST_OPTIONAL_API_NAME()	ast_websocket_write (struct ast_websocket *session, enum ast_websocket_opcode opcode, char *payload, uint64_t payload_size)
	Write function for websocket traffic.
int AST_OPTIONAL_API_NAME()	ast_websocket_write_string (struct ast_websocket *ws, const char *buf)
	Construct and transmit a WebSocket frame containing string data.
static int	load_module (void)
static struct ast_websocket_protocol *	one_protocol (struct ast_websocket_server *server)
	If the server has exactly one configured protocol, return it.
static int	protocol_cmp_fn (void *obj, void *arg, int flags)
	Comparison function for protocols.
static void	protocol_destroy_fn (void *obj)
	Destructor function for protocols.
static int	protocol_hash_fn (const void *obj, const int flags)
	Hashing function for protocols.
static void	session_destroy_fn (void *obj)
	Destructor function for sessions.
static int	unload_module (void)
static int	websocket_add_protocol_internal (const char *name, ast_websocket_callback callback)
static void	websocket_bad_request (struct ast_tcptls_session_instance *ser)
static struct ast_tcptls_session_args *	websocket_client_args_create (const char *host, struct ast_tls_config *tls_cfg, enum ast_websocket_result *result)
static void	websocket_client_args_destroy (void *obj)
static enum ast_websocket_result	websocket_client_connect (struct ast_websocket *ws, int timeout)
static struct ast_websocket *	websocket_client_create (struct ast_websocket_client_options *options, enum ast_websocket_result *result)
static char *	websocket_client_create_key (void)
static void	websocket_client_destroy (void *obj)
static enum ast_websocket_result	websocket_client_handle_response_code (struct websocket_client *client, int response_code)
static enum ast_websocket_result	websocket_client_handshake (struct websocket_client *client)
static enum ast_websocket_result	websocket_client_handshake_get_response (struct websocket_client *client)
static int	websocket_client_parse_uri (const char *uri, char **host, struct ast_str **path, char **userinfo)
	Parse the given uri into a path and remote address.
static char *	websocket_combine_key (const char *key, char *res, int res_size)
static void	websocket_echo_callback (struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
	Simple echo implementation which echoes received text and binary frames.
static void	websocket_mask_payload (struct ast_websocket *session, char *frame, char *payload, uint64_t payload_size)
	Perform payload masking for client sessions.
static const char *	websocket_opcode2str (enum ast_websocket_opcode opcode)
static int	websocket_remove_protocol_internal (const char *name, ast_websocket_callback callback)
static struct ast_websocket_server *	websocket_server_create_impl (void)
static void	websocket_server_dtor (void *obj)
static struct ast_websocket_server *	websocket_server_internal_create (void)
static int	ws_safe_read (struct ast_websocket *session, char *buf, size_t len, enum ast_websocket_opcode *opcode)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "HTTP WebSocket Support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "http", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char *	opcode_map []
const char *	websocket_result_string_map []
static struct ast_http_uri	websocketuri

Detailed Description

WebSocket support for the Asterisk internal HTTP server.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file res_http_websocket.c.

Macro Definition Documentation

AST_API_MODULE

#define AST_API_MODULE

Definition at line 41 of file res_http_websocket.c.

CLIENT_KEY_SIZE

#define CLIENT_KEY_SIZE   16

Length of a websocket's client key.

Definition at line 48 of file res_http_websocket.c.

DEFAULT_RECONSTRUCTION_CEILING

#define DEFAULT_RECONSTRUCTION_CEILING   AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE

Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will start a payload.

Definition at line 65 of file res_http_websocket.c.

MAX_PROTOCOL_BUCKETS

#define MAX_PROTOCOL_BUCKETS   7

Number of buckets for registered protocols.

Definition at line 51 of file res_http_websocket.c.

MAX_WS_HDR_SZ

#define MAX_WS_HDR_SZ   14

Maximum size of a websocket frame header 1 byte flags and opcode 1 byte mask flag + payload len 8 bytes max extended length 4 bytes optional masking key ... payload follows ...

Definition at line 78 of file res_http_websocket.c.

MAXIMUM_RECONSTRUCTION_CEILING

#define MAXIMUM_RECONSTRUCTION_CEILING   AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE

Maximum reconstruction size for multi-frame payload reconstruction.

Definition at line 68 of file res_http_websocket.c.

MIN_WS_HDR_SZ

#define MIN_WS_HDR_SZ   2

Definition at line 79 of file res_http_websocket.c.

optional_header_spec

#define optional_header_spec   "%s%s%s"

Definition at line 1442 of file res_http_websocket.c.

print_optional_header

#define print_optional_header	(		test,
			name,
			value
	)

Value:

    test ? name : "", \
    test ? value : "", \
    test ? "\r\n" : ""

Definition at line 1443 of file res_http_websocket.c.

                : "", \
    test ? value : "", \
    test ? "\r\n" : ""

WEBSOCKET_GUID

#define WEBSOCKET_GUID   "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"

GUID used to compute the accept key, defined in the specifications.

Definition at line 45 of file res_http_websocket.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1663 of file res_http_websocket.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1663 of file res_http_websocket.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 1663 of file res_http_websocket.c.

ast_websocket_add_protocol()

int AST_OPTIONAL_API_NAME() ast_websocket_add_protocol	(	const char *	name,
		ast_websocket_callback	callback
	)

Add a sub-protocol handler to the default /ws server.

Parameters

name	Name of the sub-protocol to register
callback	Callback called when a new connection requesting the sub-protocol is established

Return values

0	success
-1	if sub-protocol handler could not be registered

Definition at line 1068 of file res_http_websocket.c.

{
    return websocket_add_protocol_internal(name, callback);
}

References callback(), name, and websocket_add_protocol_internal().

Referenced by AST_TEST_DEFINE(), and load_module().

ast_websocket_add_protocol2()

int AST_OPTIONAL_API_NAME() ast_websocket_add_protocol2

(

struct ast_websocket_protocol *

protocol

)

Add a sub-protocol handler to the default /ws server.

Parameters

protocol

The sub-protocol to register. Note that this must be allocated using /ref ast_websocket_sub_protocol_alloc.

Note

This method is reference stealing. It will steal the reference to protocol on success.

Return values

0	success
-1	if sub-protocol handler could not be registered

Since

13.5.0

Definition at line 1073 of file res_http_websocket.c.

{
    struct ast_websocket_server *ws_server = websocketuri.data;
 
    if (!ws_server) {
        return -1;
    }
 
    if (ast_websocket_server_add_protocol2(ws_server, protocol)) {
        return -1;
    }
 
    return 0;
}

References ast_websocket_server_add_protocol2(), ast_http_uri::data, and websocketuri.

ast_websocket_client_accept_protocol()

const char *AST_OPTIONAL_API_NAME() ast_websocket_client_accept_protocol

(

struct ast_websocket *

ws

)

Retrieve the server accepted sub-protocol on the client.

Parameters

ws	the websocket client

Returns

the accepted client sub-protocol.

Since

13

Definition at line 1318 of file res_http_websocket.c.

{
    return ws->client->accept_protocol;
}

References websocket_client::accept_protocol, and ast_websocket::client.

Referenced by AST_TEST_DEFINE().

ast_websocket_client_create()

struct ast_websocket *AST_OPTIONAL_API_NAME() ast_websocket_client_create	(	const char *	uri,
		const char *	protocols,
		struct ast_tls_config *	tls_cfg,
		enum ast_websocket_result *	result
	)

Create, and connect, a websocket client.

If the client websocket successfully connects, then the accepted protocol can be checked via a call to ast_websocket_client_accept_protocol.

Note

While connecting this will block until a response is received from the remote host.

Expected uri form:

ws[s]://<address>[:port][/<path>] 

The address (can be a host name) and port are parsed out and used to connect to the remote server. If multiple IPs are returned during address resolution then the first one is chosen.

Parameters

uri	uri to connect to
protocols	a comma separated string of supported protocols
tls_cfg	secure websocket credentials
result	result code set on client failure

Returns

a client websocket.

Return values

NULL	if object could not be created or connected

Since

13

Definition at line 1515 of file res_http_websocket.c.

{
    struct ast_websocket_client_options options = {
        .uri = uri,
        .protocols = protocols,
        .timeout = -1,
        .tls_cfg = tls_cfg,
    };
 
    return ast_websocket_client_create_with_options(&options, result);
}

References ast_websocket_client_create_with_options(), options, ast_websocket_client_options::protocols, result, ast_websocket_client_options::tls_cfg, and ast_websocket_client_options::uri.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and AST_TEST_DEFINE().

ast_websocket_client_create_with_options()

struct ast_websocket *AST_OPTIONAL_API_NAME() ast_websocket_client_create_with_options	(	struct ast_websocket_client_options *	options,
		enum ast_websocket_result *	result
	)

Create, and connect, a websocket client using given options.

If the client websocket successfully connects, then the accepted protocol can be checked via a call to ast_websocket_client_accept_protocol.

Note

While connecting this will block until a response is received from the remote host, or the connection timeout is reached

Parameters

options	Websocket client options
result	result code set on client failure

Returns

a client websocket.

Return values

NULL	if object could not be created or connected

Definition at line 1529 of file res_http_websocket.c.

{
    struct ast_websocket *ws = websocket_client_create(options, result);
 
    if (!ws) {
        return NULL;
    }
 
    if ((*result = websocket_client_connect(ws, options->timeout)) != WS_OK) {
        ao2_ref(ws, -1);
        return NULL;
    }
 
    return ws;
}

References ao2_ref, NULL, options, result, websocket_client_connect(), websocket_client_create(), and WS_OK.

Referenced by ast_websocket_client_connect(), ast_websocket_client_create(), and websocket_connect().

ast_websocket_close()

int AST_OPTIONAL_API_NAME() ast_websocket_close	(	struct ast_websocket *	session,
		uint16_t	reason
	)

Close function for websocket session.

Close a WebSocket session by sending a message with the CLOSE opcode and an optional code.

Definition at line 324 of file res_http_websocket.c.

{
    enum ast_websocket_opcode opcode = AST_WEBSOCKET_OPCODE_CLOSE;
    /* The header is either 2 or 6 bytes and the
     * reason code takes up another 2 bytes */
    char frame[8] = { 0, };
    int header_size, fsize, res;
 
    if (session->close_sent) {
        return 0;
    }
 
    /* clients need space for an additional 4 byte masking key */
    header_size = session->client ? 6 : 2;
    fsize = header_size + 2;
 
    frame[0] = opcode | 0x80;
    frame[1] = 2; /* The reason code is always 2 bytes */
 
    /* If no reason has been specified assume 1000 which is normal closure */
    put_unaligned_uint16(&frame[header_size], htons(reason ? reason : 1000));
 
    websocket_mask_payload(session, frame, &frame[header_size], 2);
 
    session->closing = 1;
    session->close_sent = 1;
 
    ao2_lock(session);
    ast_iostream_set_timeout_inactivity(session->stream, session->timeout);
    res = ast_iostream_write(session->stream, frame, fsize);
    ast_iostream_set_timeout_disable(session->stream);
 
    /* If an error occurred when trying to close this connection explicitly terminate it now.
     * Doing so will cause the thread polling on it to wake up and terminate.
     */
    if (res != fsize) {
        ast_iostream_close(session->stream);
        session->stream = NULL;
        ast_verb(2, "WebSocket connection %s '%s' forcefully closed due to fatal write error\n",
            session->client ? "to" : "from", ast_sockaddr_stringify(&session->remote_address));
    }
 
    ao2_unlock(session);
    return res == sizeof(frame);
}

References ao2_lock, ao2_unlock, ast_iostream_close(), ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_inactivity(), ast_iostream_write(), ast_sockaddr_stringify(), ast_verb, AST_WEBSOCKET_OPCODE_CLOSE, NULL, ast_websocket::opcode, put_unaligned_uint16(), session, and websocket_mask_payload().

Referenced by ast_websocket_read(), ast_websocket_write(), incoming_ws_established_cb(), outbound_session_apply_config(), outbound_session_handler_thread(), outbound_session_pc_close_thread(), outbound_sessions_load(), session_destroy_fn(), session_shutdown_cb(), webchan_hangup(), and ws_shutdown().

ast_websocket_fd()

int AST_OPTIONAL_API_NAME() ast_websocket_fd

(

struct ast_websocket *

session

)

Get the file descriptor for a WebSocket session.

Returns

file descriptor

Note

You must not directly read from or write to this file descriptor. It should only be used for polling.

Definition at line 477 of file res_http_websocket.c.

{
    return session->closing ? -1 : ast_iostream_get_fd(session->stream);
}

References ast_iostream_get_fd(), and session.

Referenced by incoming_ws_established_cb(), read_from_ws_and_queue(), session_read(), speech_test_server_cb(), webchan_call(), websocket_echo_callback(), websocket_read(), and ws_shutdown().

ast_websocket_is_secure()

int AST_OPTIONAL_API_NAME() ast_websocket_is_secure

(

struct ast_websocket *

session

)

Get whether the WebSocket session is using a secure transport or not.

Return values

0	if unsecure
1	if secure

Definition at line 497 of file res_http_websocket.c.

{
    return session->secure;
}

References session.

Referenced by transport_create().

ast_websocket_local_address()

struct ast_sockaddr *AST_OPTIONAL_API_NAME() ast_websocket_local_address

(

struct ast_websocket *

session

)

Get the local address for a WebSocket connection session.

Returns

Local address

Since

13.19.0

Definition at line 492 of file res_http_websocket.c.

{
    return &session->local_address;
}

References session.

Referenced by transport_create().

ast_websocket_read()

int AST_OPTIONAL_API_NAME() ast_websocket_read	(	struct ast_websocket *	session,
		char **	payload,
		uint64_t *	payload_len,
		enum ast_websocket_opcode *	opcode,
		int *	fragmented
	)

Read a WebSocket frame and handle it.

Parameters

session	Pointer to the WebSocket session
payload	Pointer to a char* which will be populated with a pointer to the payload if present
payload_len	Pointer to a uint64_t which will be populated with the length of the payload if present
opcode	Pointer to an enum which will be populated with the opcode of the frame
fragmented	Pointer to an int which is set to 1 if payload is fragmented and 0 if not

Return values

-1	on error
0	on success

Note

Once an AST_WEBSOCKET_OPCODE_CLOSE opcode is received the socket will be closed

Definition at line 618 of file res_http_websocket.c.

{
    int fin = 0;
    int mask_present = 0;
    char *mask = NULL, *new_payload = NULL;
    size_t options_len = 0, frame_size = 0;
 
    *payload = NULL;
    *payload_len = 0;
    *fragmented = 0;
 
    if (ws_safe_read(session, &session->buf[0], MIN_WS_HDR_SZ, opcode)) {
        return -1;
    }
    frame_size += MIN_WS_HDR_SZ;
 
    /* ok, now we have the first 2 bytes, so we know some flags, opcode and payload length (or whether payload length extension will be required) */
    *opcode = session->buf[0] & 0xf;
    *payload_len = session->buf[1] & 0x7f;
    if (*opcode == AST_WEBSOCKET_OPCODE_TEXT || *opcode == AST_WEBSOCKET_OPCODE_BINARY || *opcode == AST_WEBSOCKET_OPCODE_CONTINUATION ||
        *opcode == AST_WEBSOCKET_OPCODE_PING || *opcode == AST_WEBSOCKET_OPCODE_PONG  || *opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
        fin = (session->buf[0] >> 7) & 1;
        mask_present = (session->buf[1] >> 7) & 1;
 
        /* Based on the mask flag and payload length, determine how much more we need to read before start parsing the rest of the header */
        options_len += mask_present ? 4 : 0;
        options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
        if (options_len) {
            /* read the rest of the header options */
            if (ws_safe_read(session, &session->buf[frame_size], options_len, opcode)) {
                return -1;
            }
            frame_size += options_len;
        }
 
        if (*payload_len == 126) {
            /* Grab the 2-byte payload length  */
            *payload_len = ntohs(get_unaligned_uint16(&session->buf[2]));
            mask = &session->buf[4];
        } else if (*payload_len == 127) {
            /* Grab the 8-byte payload length  */
            *payload_len = ntohll(get_unaligned_uint64(&session->buf[2]));
            mask = &session->buf[10];
        } else {
            /* Just set the mask after the small 2-byte header */
            mask = &session->buf[2];
        }
 
        /* Now read the rest of the payload */
        *payload = &session->buf[frame_size]; /* payload will start here, at the end of the options, if any */
        frame_size = frame_size + (*payload_len); /* final frame size is header + optional headers + payload data */
        if (frame_size > AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE) {
            ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zu bytes\n", frame_size);
            /* The frame won't fit :-( */
            ast_websocket_close(session, 1009);
            return -1;
        }
 
        if (*payload_len) {
            if (ws_safe_read(session, *payload, *payload_len, opcode)) {
                return -1;
            }
        }
 
        /* If a mask is present unmask the payload */
        if (mask_present) {
            unsigned int pos;
            for (pos = 0; pos < *payload_len; pos++) {
                (*payload)[pos] ^= mask[pos % 4];
            }
        }
 
        /* Per the RFC for PING we need to send back an opcode with the application data as received */
        if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
            if (ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len)) {
                ast_websocket_close(session, 1009);
            }
            *payload_len = 0;
            return 0;
        }
 
        /* Stop PONG processing here */
        if (*opcode == AST_WEBSOCKET_OPCODE_PONG) {
            *payload_len = 0;
            return 0;
        }
 
        /* Save the CLOSE status code which will be sent in our own CLOSE in the destructor */
        if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
            session->closing = 1;
            if (*payload_len >= 2) {
                session->close_status_code = ntohs(get_unaligned_uint16(*payload));
            }
            *payload_len = 0;
            return 0;
        }
 
        /* Below this point we are handling TEXT, BINARY or CONTINUATION opcodes */
        if (*payload_len) {
            if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
                ast_log(LOG_WARNING, "Failed allocation: %p, %zu, %"PRIu64"\n",
                    session->payload, session->payload_len, *payload_len);
                *payload_len = 0;
                ast_websocket_close(session, 1009);
                return -1;
            }
 
            session->payload = new_payload;
            memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
            session->payload_len += *payload_len;
        } else if (!session->payload_len && session->payload) {
            ast_free(session->payload);
            session->payload = NULL;
        }
 
        if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
            /* If this is not a final message we need to defer returning it until later */
            if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
                session->opcode = *opcode;
            }
            *opcode = AST_WEBSOCKET_OPCODE_CONTINUATION;
            *payload_len = 0;
            *payload = NULL;
        } else {
            if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
                if (!fin) {
                    /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
                    *fragmented = 1;
                } else {
                    /* Final frame in multi-frame so push up the actual opcode */
                    *opcode = session->opcode;
                }
            }
            *payload_len = session->payload_len;
            *payload = session->payload;
            session->payload_len = 0;
        }
    } else {
        ast_log(LOG_WARNING, "WebSocket unknown opcode %u\n", *opcode);
        /* We received an opcode that we don't understand, the RFC states that 1003 is for a type of data that can't be accepted... opcodes
         * fit that, I think. */
        ast_websocket_close(session, 1003);
    }
 
    return 0;
}

References ast_free, ast_log, ast_realloc, ast_websocket_close(), AST_WEBSOCKET_MAX_RX_PAYLOAD_SIZE, AST_WEBSOCKET_OPCODE_BINARY, AST_WEBSOCKET_OPCODE_CLOSE, AST_WEBSOCKET_OPCODE_CONTINUATION, AST_WEBSOCKET_OPCODE_PING, AST_WEBSOCKET_OPCODE_PONG, AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_write(), frame_size, get_unaligned_uint16(), get_unaligned_uint64(), LOG_WARNING, MIN_WS_HDR_SZ, ntohll(), NULL, ast_websocket::opcode, ast_websocket::payload, ast_websocket::payload_len, session, and ws_safe_read().

Referenced by ast_websocket_read_string(), read_from_ws_and_queue(), session_read(), speech_test_server_cb(), websocket_cb(), websocket_echo_callback(), and websocket_read().

ast_websocket_read_string()

int AST_OPTIONAL_API_NAME() ast_websocket_read_string	(	struct ast_websocket *	ws,
		char **	buf
	)

Read a WebSocket frame containing string data.

Note

The caller is responsible for freeing the output "buf".

Parameters

ws	pointer to the websocket
buf	string buffer to populate with data read from socket

Return values

-1

on error

Returns

number of bytes read on success

Note

Once an AST_WEBSOCKET_OPCODE_CLOSE opcode is received the socket will be closed

Definition at line 1546 of file res_http_websocket.c.

{
    char *payload;
    uint64_t payload_len;
    enum ast_websocket_opcode opcode;
    int fragmented = 1;
 
    while (fragmented) {
        if (ast_websocket_read(ws, &payload, &payload_len,
                       &opcode, &fragmented)) {
            ast_log(LOG_ERROR, "Client WebSocket string read - "
                "error reading string data\n");
            return -1;
        }
 
        if (opcode == AST_WEBSOCKET_OPCODE_PING) {
            /* Try read again, we have sent pong already */
            fragmented = 1;
            continue;
        }
 
        if (opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
            continue;
        }
 
        if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
            return -1;
        }
 
        if (opcode != AST_WEBSOCKET_OPCODE_TEXT) {
            ast_log(LOG_ERROR, "Client WebSocket string read - "
                "non string data received\n");
            return -1;
        }
    }
 
    if (!(*buf = ast_strndup(payload, payload_len))) {
        return -1;
    }
 
    return payload_len + 1;
}

References ast_log, ast_strndup, AST_WEBSOCKET_OPCODE_CLOSE, AST_WEBSOCKET_OPCODE_CONTINUATION, AST_WEBSOCKET_OPCODE_PING, AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_read(), buf, LOG_ERROR, ast_websocket::opcode, ast_websocket::payload, and ast_websocket::payload_len.

Referenced by AST_TEST_DEFINE().

ast_websocket_reconstruct_disable()

void AST_OPTIONAL_API_NAME() ast_websocket_reconstruct_disable

(

struct ast_websocket *

session

)

Disable multi-frame reconstruction.

Parameters

session

Pointer to the WebSocket session

Note

If reconstruction is disabled each message that is part of a multi-frame message will be sent up to the user when ast_websocket_read is called.

Definition at line 462 of file res_http_websocket.c.

{
    session->reconstruct = 0;
}

References session.

ast_websocket_reconstruct_enable()

void AST_OPTIONAL_API_NAME() ast_websocket_reconstruct_enable	(	struct ast_websocket *	session,
		size_t	bytes
	)

Enable multi-frame reconstruction up to a certain number of bytes.

Parameters

session	Pointer to the WebSocket session
bytes	If a reconstructed payload exceeds the specified number of bytes the payload will be returned and upon reception of the next multi-frame a new reconstructed payload will begin.

Definition at line 457 of file res_http_websocket.c.

{
    session->reconstruct = MIN(bytes, MAXIMUM_RECONSTRUCTION_CEILING);
}

References MAXIMUM_RECONSTRUCTION_CEILING, MIN, and session.

ast_websocket_ref()

void AST_OPTIONAL_API_NAME() ast_websocket_ref

(

struct ast_websocket *

session

)

Increase the reference count for a WebSocket session.

Parameters

session

Pointer to the WebSocket session

Definition at line 467 of file res_http_websocket.c.

{
    ao2_ref(session, +1);
}

References ao2_ref, and session.

Referenced by transport_create().

ast_websocket_remote_address()

struct ast_sockaddr *AST_OPTIONAL_API_NAME() ast_websocket_remote_address

(

struct ast_websocket *

session

)

Get the remote address for a WebSocket connected session.

Returns

Remote address

Definition at line 487 of file res_http_websocket.c.

{
    return &session->remote_address;
}

References session.

Referenced by ari_websocket_send_event(), session_update(), session_write(), transport_create(), transport_read(), and websocket_established_cb().

ast_websocket_remove_protocol()

int AST_OPTIONAL_API_NAME() ast_websocket_remove_protocol	(	const char *	name,
		ast_websocket_callback	callback
	)

Remove a sub-protocol handler from the default /ws server.

Parameters

name	Name of the sub-protocol to unregister
callback	Session Established callback that was previously registered with the sub-protocol

Return values

0	success
-1	if sub-protocol was not found or if callback did not match

Definition at line 1097 of file res_http_websocket.c.

{
    return websocket_remove_protocol_internal(name, callback);
}

References callback(), name, and websocket_remove_protocol_internal().

Referenced by AST_TEST_DEFINE(), and unload_module().

ast_websocket_result_to_str()

const char *AST_OPTIONAL_API_NAME() ast_websocket_result_to_str

(

enum ast_websocket_result

result

)

Convert a websocket result code to a string.

Parameters

result

The result code to convert

Returns

A string representation of the result code

Definition at line 1626 of file res_http_websocket.c.

{
    if (!ARRAY_IN_BOUNDS(result, websocket_result_string_map)) {
        return "unknown";
    }
    return websocket_result_string_map[result];
}

References ARRAY_IN_BOUNDS, result, and websocket_result_string_map.

Referenced by ast_websocket_client_connect(), and webchan_call().

ast_websocket_server_add_protocol()

int AST_OPTIONAL_API_NAME() ast_websocket_server_add_protocol	(	struct ast_websocket_server *	server,
		const char *	name,
		ast_websocket_callback	callback
	)

Add a sub-protocol handler to the given server.

Parameters

server	The server to add the sub-protocol to
name	Name of the sub-protocol to register
callback	Callback called when a new connection requesting the sub-protocol is established

Return values

0	success
-1	if sub-protocol handler could not be registered

Since

12

Definition at line 226 of file res_http_websocket.c.

{
    struct ast_websocket_protocol *protocol;
 
    if (!server->protocols) {
        return -1;
    }
 
    protocol = ast_websocket_sub_protocol_alloc(name);
    if (!protocol) {
        return -1;
    }
    protocol->session_established = callback;
 
    if (ast_websocket_server_add_protocol2(server, protocol)) {
        ao2_ref(protocol, -1);
        return -1;
    }
 
    return 0;
}

References ao2_ref, ast_websocket_server_add_protocol2(), ast_websocket_sub_protocol_alloc(), callback(), name, ast_websocket_server::protocols, and ast_websocket_protocol::session_established.

Referenced by websocket_add_protocol_internal().

ast_websocket_server_add_protocol2()

int AST_OPTIONAL_API_NAME() ast_websocket_server_add_protocol2	(	struct ast_websocket_server *	server,
		struct ast_websocket_protocol *	protocol
	)

Add a sub-protocol handler to the given server.

Parameters

server	The server to add the sub-protocol to.
protocol	The sub-protocol to register. Note that this must be allocated using /ref ast_websocket_sub_protocol_alloc.

Note

This method is reference stealing. It will steal the reference to protocol on success.

Return values

0	success
-1	if sub-protocol handler could not be registered

Since

13.5.0

Definition at line 248 of file res_http_websocket.c.

{
    struct ast_websocket_protocol *existing;
 
    if (!server->protocols) {
        return -1;
    }
 
    if (protocol->version != AST_WEBSOCKET_PROTOCOL_VERSION) {
        ast_log(LOG_WARNING, "WebSocket could not register sub-protocol '%s': "
            "expected version '%u', got version '%u'\n",
            protocol->name, AST_WEBSOCKET_PROTOCOL_VERSION, protocol->version);
        return -1;
    }
 
    ao2_lock(server->protocols);
 
    /* Ensure a second protocol handler is not registered for the same protocol */
    existing = ao2_find(server->protocols, protocol->name, OBJ_KEY | OBJ_NOLOCK);
    if (existing) {
        ao2_ref(existing, -1);
        ao2_unlock(server->protocols);
        return -1;
    }
 
    ao2_link_flags(server->protocols, protocol, OBJ_NOLOCK);
    ao2_unlock(server->protocols);
 
    ast_debug(1, "WebSocket registered sub-protocol '%s'\n", protocol->name);
    ao2_ref(protocol, -1);
 
    return 0;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_log, AST_WEBSOCKET_PROTOCOL_VERSION, LOG_WARNING, OBJ_KEY, OBJ_NOLOCK, and ast_websocket_server::protocols.

Referenced by ari_websocket_load_module(), ast_websocket_add_protocol2(), ast_websocket_server_add_protocol(), and load_module().

ast_websocket_server_create()

struct ast_websocket_server *AST_OPTIONAL_API_NAME() ast_websocket_server_create

(

void

)

Creates a ast_websocket_server.

Returns

New ast_websocket_server instance

Return values

NULL

on error

Since

12

Definition at line 183 of file res_http_websocket.c.

{
    return websocket_server_create_impl();
}

References websocket_server_create_impl().

Referenced by ari_websocket_load_module(), and load_module().

ast_websocket_server_remove_protocol()

int AST_OPTIONAL_API_NAME() ast_websocket_server_remove_protocol	(	struct ast_websocket_server *	server,
		const char *	name,
		ast_websocket_callback	callback
	)

Remove a sub-protocol handler from the given server.

Parameters

server	The server to unregister the sub-protocol from
name	Name of the sub-protocol to unregister
callback	Callback that was previously registered with the sub-protocol

Return values

0	success
-1	if sub-protocol was not found or if callback did not match

Since

12

Definition at line 282 of file res_http_websocket.c.

{
    struct ast_websocket_protocol *protocol;
 
    if (!(protocol = ao2_find(server->protocols, name, OBJ_KEY))) {
        return -1;
    }
 
    if (protocol->session_established != callback) {
        ao2_ref(protocol, -1);
        return -1;
    }
 
    ao2_unlink(server->protocols, protocol);
    ao2_ref(protocol, -1);
 
    ast_debug(1, "WebSocket unregistered sub-protocol '%s'\n", name);
 
    return 0;
}

References ao2_find, ao2_ref, ao2_unlink, ast_debug, callback(), name, OBJ_KEY, ast_websocket_server::protocols, and ast_websocket_protocol::session_established.

Referenced by websocket_remove_protocol_internal().

ast_websocket_session_id()

const char *AST_OPTIONAL_API_NAME() ast_websocket_session_id

(

struct ast_websocket *

session

)

Get the session ID for a WebSocket session.

Returns

session id

Definition at line 516 of file res_http_websocket.c.

{
    return session->session_id;
}

References session.

Referenced by websocket_established_cb().

ast_websocket_set_nonblock()

int AST_OPTIONAL_API_NAME() ast_websocket_set_nonblock

(

struct ast_websocket *

session

)

Set the socket of a WebSocket session to be non-blocking.

Return values

0	on success
-1	on failure

Definition at line 502 of file res_http_websocket.c.

{
    ast_iostream_nonblock(session->stream);
    ast_iostream_set_exclusive_input(session->stream, 0);
    return 0;
}

References ast_iostream_nonblock(), ast_iostream_set_exclusive_input(), and session.

Referenced by session_update(), and websocket_cb().

ast_websocket_set_timeout()

int AST_OPTIONAL_API_NAME() ast_websocket_set_timeout	(	struct ast_websocket *	session,
		int	timeout
	)

Set the timeout on a non-blocking WebSocket session.

Since

11.11.0

12.4.0

Return values

0	on success
-1	on failure

Definition at line 509 of file res_http_websocket.c.

{
    session->timeout = timeout;
 
    return 0;
}

References session, and ast_websocket::timeout.

Referenced by session_update(), and websocket_cb().

ast_websocket_sub_protocol_alloc()

struct ast_websocket_protocol *AST_OPTIONAL_API_NAME() ast_websocket_sub_protocol_alloc

(

const char *

name

)

Allocate a websocket sub-protocol instance.

Returns

An instance of ast_websocket_protocol on success

Return values

NULL

on error

Since

13.5.0

Definition at line 207 of file res_http_websocket.c.

{
    struct ast_websocket_protocol *protocol;
 
    protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn);
    if (!protocol) {
        return NULL;
    }
 
    protocol->name = ast_strdup(name);
    if (!protocol->name) {
        ao2_ref(protocol, -1);
        return NULL;
    }
    protocol->version = AST_WEBSOCKET_PROTOCOL_VERSION;
 
    return protocol;
}

References ao2_alloc, ao2_ref, ast_strdup, AST_WEBSOCKET_PROTOCOL_VERSION, name, ast_websocket_protocol::name, NULL, protocol_destroy_fn(), and ast_websocket_protocol::version.

Referenced by ari_websocket_load_module(), ast_websocket_server_add_protocol(), and load_module().

ast_websocket_type_to_str()

const char * ast_websocket_type_to_str

(

enum ast_websocket_type

type

)

Definition at line 100 of file res_http_websocket.c.

{
    switch (type) {
    case AST_WS_TYPE_CLIENT_PERSISTENT:
        return "persistent";
    case AST_WS_TYPE_CLIENT_PER_CALL:
        return "per_call";
    case AST_WS_TYPE_CLIENT_PER_CALL_CONFIG:
        return "per_call_config";
    case AST_WS_TYPE_CLIENT:
        return "client";
    case AST_WS_TYPE_INBOUND:
        return "inbound";
    case AST_WS_TYPE_SERVER:
        return "server";
    case AST_WS_TYPE_ANY:
        return "any";
    default:
        return "unknown";
    }
}

References AST_WS_TYPE_ANY, AST_WS_TYPE_CLIENT, AST_WS_TYPE_CLIENT_PER_CALL, AST_WS_TYPE_CLIENT_PER_CALL_CONFIG, AST_WS_TYPE_CLIENT_PERSISTENT, AST_WS_TYPE_INBOUND, AST_WS_TYPE_SERVER, and type.

ast_websocket_unref()

void AST_OPTIONAL_API_NAME() ast_websocket_unref

(

struct ast_websocket *

session

)

Decrease the reference count for a WebSocket session.

Parameters

session

Pointer to the WebSocket session

Definition at line 472 of file res_http_websocket.c.

{
    ao2_cleanup(session);
}

References ao2_cleanup, and session.

Referenced by incoming_ws_established_cb(), outbound_session_handler_thread(), session_dtor(), speech_test_server_cb(), transport_dtor(), webchan_hangup(), websocket_cb(), websocket_destructor(), websocket_disconnect(), websocket_echo_callback(), and websocket_established_cb().

ast_websocket_uri_cb()

int AST_OPTIONAL_API_NAME() ast_websocket_uri_cb	(	struct ast_tcptls_session_instance *	ser,
		const struct ast_http_uri *	urih,
		const char *	uri,
		enum ast_http_method	method,
		struct ast_variable *	get_vars,
		struct ast_variable *	headers
	)

Callback suitable for use with a ast_http_uri.

Set the data field of the ast_http_uri to ast_websocket_server.

Since

12

Definition at line 806 of file res_http_websocket.c.

{
    struct ast_variable *v;
    const char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL;
    char *requested_protocols = NULL, *protocol = NULL;
    int version = 0, flags = 1;
    struct ast_websocket_protocol *protocol_handler = NULL;
    struct ast_websocket *session;
    struct ast_websocket_server *server;
 
    SCOPED_MODULE_USE(ast_module_info->self);
 
    /* Upgrade requests are only permitted on GET methods */
    if (method != AST_HTTP_GET) {
        ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
        return 0;
    }
 
    server = urih->data;
 
    /* Get the minimum headers required to satisfy our needs */
    for (v = headers; v; v = v->next) {
        if (!strcasecmp(v->name, "Upgrade")) {
            upgrade = v->value;
        } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
            key = v->value;
        } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
            key1 = v->value;
        } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
            key2 = v->value;
        } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
            protos = v->value;
        } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
            if (sscanf(v->value, "%30d", &version) != 1) {
                version = 0;
            }
        }
    }
 
    /* If this is not a websocket upgrade abort */
    if (!upgrade || strcasecmp(upgrade, "websocket")) {
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
            ast_sockaddr_stringify(&ser->remote_address));
        ast_http_error(ser, 426, "Upgrade Required", NULL);
        return 0;
    } else if (ast_strlen_zero(protos)) {
        /* If there's only a single protocol registered, and the
         * client doesn't specify what protocol it's using, go ahead
         * and accept the connection */
        protocol_handler = one_protocol(server);
        if (!protocol_handler) {
            /* Multiple registered subprotocols; client must specify */
            ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
                ast_sockaddr_stringify(&ser->remote_address));
            websocket_bad_request(ser);
            return 0;
        }
    } else if (key1 && key2) {
        /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
         * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
            ast_sockaddr_stringify(&ser->remote_address));
        websocket_bad_request(ser);
        return 0;
    }
 
    if (!protocol_handler && protos) {
        requested_protocols = ast_strdupa(protos);
        /* Iterate through the requested protocols trying to find one that we have a handler for */
        while (!protocol_handler && (protocol = strsep(&requested_protocols, ","))) {
            protocol_handler = ao2_find(server->protocols, ast_strip(protocol), OBJ_KEY);
        }
    }
 
    /* If no protocol handler exists bump this back to the requester */
    if (!protocol_handler) {
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
            ast_sockaddr_stringify(&ser->remote_address), protos);
        websocket_bad_request(ser);
        return 0;
    }
 
    /* Determine how to respond depending on the version */
    if (version == 7 || version == 8 || version == 13) {
        char base64[64];
 
        if (!key || strlen(key) + strlen(WEBSOCKET_GUID) + 1 > 8192) { /* no stack overflows please */
            websocket_bad_request(ser);
            ao2_ref(protocol_handler, -1);
            return 0;
        }
 
        if (ast_http_body_discard(ser)) {
            websocket_bad_request(ser);
            ao2_ref(protocol_handler, -1);
            return 0;
        }
 
        if (!(session = ao2_alloc(sizeof(*session) + AST_UUID_STR_LEN + 1, session_destroy_fn))) {
            ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
                ast_sockaddr_stringify(&ser->remote_address));
            websocket_bad_request(ser);
            ao2_ref(protocol_handler, -1);
            return 0;
        }
        session->timeout = AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT;
 
        /* Generate the session id */
        if (!ast_uuid_generate_str(session->session_id, sizeof(session->session_id))) {
            ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to generate a session id\n",
                ast_sockaddr_stringify(&ser->remote_address));
            ast_http_error(ser, 500, "Internal Server Error", "Allocation failed");
            ao2_ref(protocol_handler, -1);
            return 0;
        }
 
        if (protocol_handler->session_attempted
            && protocol_handler->session_attempted(ser, get_vars, headers, session->session_id)) {
            ast_debug(3, "WebSocket connection from '%s' rejected by protocol handler '%s'\n",
                ast_sockaddr_stringify(&ser->remote_address), protocol_handler->name);
            websocket_bad_request(ser);
            ao2_ref(protocol_handler, -1);
            return 0;
        }
 
        /* RFC 6455, Section 4.1:
         *
         * 6. If the response includes a |Sec-WebSocket-Protocol| header
         *    field and this header field indicates the use of a
         *    subprotocol that was not present in the client's handshake
         *    (the server has indicated a subprotocol not requested by
         *    the client), the client MUST _Fail the WebSocket
         *    Connection_.
         */
        if (protocol) {
            ast_iostream_printf(ser->stream,
                "HTTP/1.1 101 Switching Protocols\r\n"
                "Upgrade: %s\r\n"
                "Connection: Upgrade\r\n"
                "Sec-WebSocket-Accept: %s\r\n"
                "Sec-WebSocket-Protocol: %s\r\n\r\n",
                upgrade,
                websocket_combine_key(key, base64, sizeof(base64)),
                protocol);
        } else {
            ast_iostream_printf(ser->stream,
                "HTTP/1.1 101 Switching Protocols\r\n"
                "Upgrade: %s\r\n"
                "Connection: Upgrade\r\n"
                "Sec-WebSocket-Accept: %s\r\n\r\n",
                upgrade,
                websocket_combine_key(key, base64, sizeof(base64)));
        }
    } else {
 
        /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
            ast_sockaddr_stringify(&ser->remote_address), version ? version : 75);
        websocket_bad_request(ser);
        ao2_ref(protocol_handler, -1);
        return 0;
    }
 
    /* Enable keepalive on all sessions so the underlying user does not have to */
    if (setsockopt(ast_iostream_get_fd(ser->stream), SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
            ast_sockaddr_stringify(&ser->remote_address));
        websocket_bad_request(ser);
        ao2_ref(session, -1);
        ao2_ref(protocol_handler, -1);
        return 0;
    }
 
    /* Get our local address for the connected socket */
    if (ast_getsockname(ast_iostream_get_fd(ser->stream), &session->local_address)) {
        ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to get local address\n",
            ast_sockaddr_stringify(&ser->remote_address));
        websocket_bad_request(ser);
        ao2_ref(session, -1);
        ao2_ref(protocol_handler, -1);
        return 0;
    }
 
    ast_debug(3, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol ? : "", version);
 
    /* Populate the session with all the needed details */
    session->stream = ser->stream;
    ast_sockaddr_copy(&session->remote_address, &ser->remote_address);
    session->opcode = -1;
    session->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
    session->secure = ast_iostream_get_ssl(ser->stream) ? 1 : 0;
 
    /* Give up ownership of the socket and pass it to the protocol handler */
    ast_iostream_set_exclusive_input(session->stream, 0);
    protocol_handler->session_established(session, get_vars, headers);
    ao2_ref(protocol_handler, -1);
 
    /*
     * By dropping the stream from the session the connection
     * won't get closed when the HTTP server cleans up because we
     * passed the connection to the protocol handler.
     */
    ser->stream = NULL;
 
    return 0;
}

References ao2_alloc, ao2_find, ao2_ref, ast_debug, AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT, ast_getsockname(), ast_http_body_discard(), ast_http_error(), AST_HTTP_GET, ast_iostream_get_fd(), ast_iostream_get_ssl(), ast_iostream_printf(), ast_iostream_set_exclusive_input(), ast_log, ast_sockaddr_copy(), ast_sockaddr_stringify(), ast_strdupa, ast_strip(), ast_strlen_zero(), ast_uuid_generate_str(), AST_UUID_STR_LEN, base64, ast_http_uri::data, DEFAULT_RECONSTRUCTION_CEILING, LOG_WARNING, method, ast_variable::name, ast_websocket_protocol::name, ast_variable::next, NULL, OBJ_KEY, one_protocol(), ast_websocket_server::protocols, ast_tcptls_session_instance::remote_address, SCOPED_MODULE_USE, ast_module_info::self, session, ast_websocket_protocol::session_attempted, session_destroy_fn(), ast_websocket_protocol::session_established, ast_tcptls_session_instance::stream, strsep(), ast_variable::value, version, websocket_bad_request(), websocket_combine_key(), and WEBSOCKET_GUID.

Referenced by ari_handle_websocket(), and incoming_ws_http_callback().

ast_websocket_wait_for_input()

int AST_OPTIONAL_API_NAME() ast_websocket_wait_for_input	(	struct ast_websocket *	session,
		int	timeout
	)

Wait for the WebSocket session to be ready to be read.

Since

16.8.0

17.2.0

Parameters

session	Pointer to the WebSocket session
timeout	the number of milliseconds to wait

Return values

-1	if error occurred
0	if the timeout expired
1	if the WebSocket session is ready for reading

Definition at line 482 of file res_http_websocket.c.

{
    return session->closing ? -1 : ast_iostream_wait_for_input(session->stream, timeout);
}

References ast_iostream_wait_for_input(), session, and ast_websocket::timeout.

Referenced by speech_test_server_cb(), websocket_cb(), websocket_echo_callback(), and websocket_read().

ast_websocket_write()

int AST_OPTIONAL_API_NAME() ast_websocket_write	(	struct ast_websocket *	session,
		enum ast_websocket_opcode	opcode,
		char *	payload,
		uint64_t	payload_size
	)

Write function for websocket traffic.

Construct and transmit a WebSocket frame.

Definition at line 390 of file res_http_websocket.c.

{
    size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
    char *frame;
    uint64_t length;
    uint64_t frame_size;
 
    ast_debug(3, "Writing websocket %s frame, length %" PRIu64 "\n",
            websocket_opcode2str(opcode), payload_size);
 
    if (payload_size < 126) {
        length = payload_size;
    } else if (payload_size < (1 << 16)) {
        length = 126;
        /* We need an additional 2 bytes to store the extended length */
        header_size += 2;
    } else {
        length = 127;
        /* We need an additional 8 bytes to store the really really extended length */
        header_size += 8;
    }
 
    if (session->client) {
        /* Additional 4 bytes for the client masking key */
        header_size += 4;
    }
 
    frame_size = header_size + payload_size;
 
    frame = ast_alloca(frame_size + 1);
    memset(frame, 0, frame_size + 1);
 
    frame[0] = opcode | 0x80;
    frame[1] = length;
 
    /* Use the additional available bytes to store the length */
    if (length == 126) {
        put_unaligned_uint16(&frame[2], htons(payload_size));
    } else if (length == 127) {
        put_unaligned_uint64(&frame[2], htonll(payload_size));
    }
 
    memcpy(&frame[header_size], payload, payload_size);
 
    websocket_mask_payload(session, frame, &frame[header_size], payload_size);
 
    ao2_lock(session);
    if (session->closing) {
        ao2_unlock(session);
        return -1;
    }
 
    ast_iostream_set_timeout_sequence(session->stream, ast_tvnow(), session->timeout);
    if (ast_iostream_write(session->stream, frame, frame_size) != frame_size) {
        ao2_unlock(session);
        /* 1011 - server terminating connection due to not being able to fulfill the request */
        ast_debug(1, "Closing WS with 1011 because we can't fulfill a write request\n");
        ast_websocket_close(session, 1011);
        return -1;
    }
 
    ast_iostream_set_timeout_disable(session->stream);
    ao2_unlock(session);
 
    return 0;
}

References ao2_lock, ao2_unlock, ast_alloca, ast_debug, ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_sequence(), ast_iostream_write(), ast_tvnow(), ast_websocket_close(), frame_size, htonll(), ast_websocket::opcode, ast_websocket::payload, put_unaligned_uint16(), put_unaligned_uint64(), session, websocket_mask_payload(), and websocket_opcode2str().

Referenced by ast_websocket_read(), ast_websocket_write_string(), speech_test_server_cb(), webchan_write(), websocket_echo_callback(), websocket_write(), and ws_send_msg().

ast_websocket_write_string()

int AST_OPTIONAL_API_NAME() ast_websocket_write_string	(	struct ast_websocket *	ws,
		const char *	buf
	)

Construct and transmit a WebSocket frame containing string data.

Parameters

ws	pointer to the websocket
buf	string data to write to socket

Return values

0	if successfully written
-1	if error occurred

Definition at line 1590 of file res_http_websocket.c.

{
    uint64_t len = strlen(buf);
 
    ast_debug(3, "Writing websocket string of length %" PRIu64 "\n", len);
 
    /* We do not pass strlen(buf) to ast_websocket_write() directly because the
     * size_t returned by strlen() may not require the same storage size
     * as the uint64_t that ast_websocket_write() uses. This normally
     * would not cause a problem, but since ast_websocket_write() uses
     * the optional API, this function call goes through a series of macros
     * that may cause a 32-bit to 64-bit conversion to go awry.
     */
    return ast_websocket_write(ws, AST_WEBSOCKET_OPCODE_TEXT,
                   (char *)buf, len);
}

References ast_debug, AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_write(), buf, and len().

Referenced by AST_TEST_DEFINE(), dequeue_frame(), process_text_message(), queue_frame_from_buffer(), read_thread_handler(), session_write(), speech_test_server_handle_request(), and webchan_send_dtmf_text().

load_module()

static int load_module ( void  )

static

Definition at line 1635 of file res_http_websocket.c.

{
    websocketuri.data = websocket_server_internal_create();
    if (!websocketuri.data) {
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_http_uri_link(&websocketuri);
    websocket_add_protocol_internal("echo", websocket_echo_callback);
 
    return 0;
}

References ast_http_uri_link(), AST_MODULE_LOAD_DECLINE, ast_http_uri::data, websocket_add_protocol_internal(), websocket_echo_callback(), websocket_server_internal_create(), and websocketuri.

one_protocol()

static struct ast_websocket_protocol * one_protocol ( struct ast_websocket_server *  server )

static

If the server has exactly one configured protocol, return it.

Definition at line 768 of file res_http_websocket.c.

{
    SCOPED_AO2LOCK(lock, server->protocols);
 
    if (ao2_container_count(server->protocols) != 1) {
        return NULL;
    }
 
    return ao2_callback(server->protocols, OBJ_NOLOCK, NULL, NULL);
}

References ao2_callback, ao2_container_count(), lock, NULL, OBJ_NOLOCK, ast_websocket_server::protocols, and SCOPED_AO2LOCK.

Referenced by ast_websocket_uri_cb().

protocol_cmp_fn()

static int protocol_cmp_fn ( void *  obj, void *  arg, int  flags  )

static

Comparison function for protocols.

Definition at line 132 of file res_http_websocket.c.

{
    const struct ast_websocket_protocol *protocol1 = obj, *protocol2 = arg;
    const char *protocol = arg;
 
    return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
}

References CMP_MATCH, CMP_STOP, ast_websocket_protocol::name, and OBJ_KEY.

Referenced by websocket_server_create_impl().

protocol_destroy_fn()

static void protocol_destroy_fn ( void *  obj )

static

Destructor function for protocols.

Definition at line 141 of file res_http_websocket.c.

{
    struct ast_websocket_protocol *protocol = obj;
    ast_free(protocol->name);
}

References ast_free, and ast_websocket_protocol::name.

Referenced by ast_websocket_sub_protocol_alloc().

protocol_hash_fn()

static int protocol_hash_fn ( const void *  obj, const int  flags  )

static

Hashing function for protocols.

Definition at line 123 of file res_http_websocket.c.

{
    const struct ast_websocket_protocol *protocol = obj;
    const char *name = obj;
 
    return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
}

References ast_str_case_hash(), name, ast_websocket_protocol::name, and OBJ_KEY.

Referenced by websocket_server_create_impl().

session_destroy_fn()

static void session_destroy_fn ( void *  obj )

static

Destructor function for sessions.

Definition at line 189 of file res_http_websocket.c.

{
    struct ast_websocket *session = obj;
 
    if (session->stream) {
        ast_websocket_close(session, session->close_status_code);
        if (session->stream) {
            ast_iostream_close(session->stream);
            session->stream = NULL;
            ast_debug(3, "WebSocket connection %s '%s' closed\n", session->client ? "to" : "from",
                ast_sockaddr_stringify(&session->remote_address));
        }
    }
 
    ao2_cleanup(session->client);
    ast_free(session->payload);
}

References ao2_cleanup, ast_debug, ast_free, ast_iostream_close(), ast_sockaddr_stringify(), ast_websocket_close(), NULL, and session.

Referenced by ast_websocket_uri_cb(), and websocket_client_create().

unload_module()

static int unload_module ( void  )

static

Definition at line 1647 of file res_http_websocket.c.

{
    websocket_remove_protocol_internal("echo", websocket_echo_callback);
    ast_http_uri_unlink(&websocketuri);
    ao2_ref(websocketuri.data, -1);
    websocketuri.data = NULL;
 
    return 0;
}

References ao2_ref, ast_http_uri_unlink(), ast_http_uri::data, NULL, websocket_echo_callback(), websocket_remove_protocol_internal(), and websocketuri.

websocket_add_protocol_internal()

static int websocket_add_protocol_internal ( const char *  name, ast_websocket_callback  callback  )

static

Definition at line 1059 of file res_http_websocket.c.

{
    struct ast_websocket_server *ws_server = websocketuri.data;
    if (!ws_server) {
        return -1;
    }
    return ast_websocket_server_add_protocol(ws_server, name, callback);
}

References ast_websocket_server_add_protocol(), callback(), ast_http_uri::data, name, and websocketuri.

Referenced by ast_websocket_add_protocol(), and load_module().

websocket_bad_request()

static void websocket_bad_request ( struct ast_tcptls_session_instance *  ser )

static

Definition at line 793 of file res_http_websocket.c.

{
    struct ast_str *http_header = ast_str_create(64);
 
    if (!http_header) {
        ast_http_request_close_on_completion(ser);
        ast_http_error(ser, 500, "Server Error", "Out of memory");
        return;
    }
    ast_str_set(&http_header, 0, "Sec-WebSocket-Version: 7, 8, 13\r\n");
    ast_http_send(ser, AST_HTTP_UNKNOWN, 400, "Bad Request", http_header, NULL, 0, 0);
}

References ast_http_error(), ast_http_request_close_on_completion(), ast_http_send(), AST_HTTP_UNKNOWN, ast_str_create, ast_str_set(), and NULL.

Referenced by ast_websocket_uri_cb().

websocket_client_args_create()

static struct ast_tcptls_session_args * websocket_client_args_create ( const char *  host, struct ast_tls_config *  tls_cfg, enum ast_websocket_result *  result  )

static

Definition at line 1158 of file res_http_websocket.c.

{
    struct ast_sockaddr *addr;
    struct ast_tcptls_session_args *args = ao2_alloc(
        sizeof(*args), websocket_client_args_destroy);
 
    if (!args) {
        *result = WS_ALLOCATE_ERROR;
        return NULL;
    }
 
    args->accept_fd = -1;
    args->tls_cfg = tls_cfg;
    args->name = "websocket client";
 
    if (!ast_sockaddr_resolve(&addr, host, 0, 0)) {
        ast_log(LOG_ERROR, "Unable to resolve address %s\n",
            host);
        ao2_ref(args, -1);
        *result = WS_URI_RESOLVE_ERROR;
        return NULL;
    }
    ast_sockaddr_copy(&args->remote_address, addr);
    ast_free(addr);
 
    /* We need to save off the hostname but it may contain a port spec */
    snprintf(args->hostname, sizeof(args->hostname),
        "%.*s",
        (int) strcspn(host, ":"), host);
 
    return args;
}

References ao2_alloc, ao2_ref, args, ast_free, ast_log, ast_sockaddr_copy(), ast_sockaddr_resolve(), LOG_ERROR, NULL, result, ast_tcptls_session_args::tls_cfg, websocket_client_args_destroy(), WS_ALLOCATE_ERROR, and WS_URI_RESOLVE_ERROR.

Referenced by websocket_client_create().

websocket_client_args_destroy()

static void websocket_client_args_destroy ( void *  obj )

static

Definition at line 1142 of file res_http_websocket.c.

{
    struct ast_tcptls_session_args *args = obj;
 
    if (args->tls_cfg) {
        ast_free(args->tls_cfg->certfile);
        ast_free(args->tls_cfg->pvtfile);
        ast_free(args->tls_cfg->cipher);
        ast_free(args->tls_cfg->cafile);
        ast_free(args->tls_cfg->capath);
 
        ast_ssl_teardown(args->tls_cfg);
    }
    ast_free(args->tls_cfg);
}

References args, ast_free, and ast_ssl_teardown().

Referenced by websocket_client_args_create().

websocket_client_connect()

static enum ast_websocket_result websocket_client_connect ( struct ast_websocket *  ws, int  timeout  )

static

Definition at line 1492 of file res_http_websocket.c.

{
    enum ast_websocket_result res;
    /* create and connect the client - note client_start
       releases the session instance on failure */
    if (!(ws->client->ser = ast_tcptls_client_start_timeout(
              ast_tcptls_client_create(ws->client->args), timeout))) {
        return WS_CLIENT_START_ERROR;
    }
 
    if ((res = websocket_client_handshake(ws->client)) != WS_OK) {
        ao2_ref(ws->client->ser, -1);
        ws->client->ser = NULL;
        return res;
    }
 
    ws->stream = ws->client->ser->stream;
    ws->secure = ast_iostream_get_ssl(ws->stream) ? 1 : 0;
    ws->client->ser->stream = NULL;
    ast_sockaddr_copy(&ws->remote_address, &ws->client->ser->remote_address);
    return WS_OK;
}

References ao2_ref, websocket_client::args, ast_iostream_get_ssl(), ast_sockaddr_copy(), ast_tcptls_client_create(), ast_tcptls_client_start_timeout(), ast_websocket::client, NULL, ast_tcptls_session_instance::remote_address, ast_websocket::remote_address, ast_websocket::secure, websocket_client::ser, ast_tcptls_session_instance::stream, ast_websocket::stream, websocket_client_handshake(), WS_CLIENT_START_ERROR, and WS_OK.

Referenced by ast_websocket_client_create_with_options().

websocket_client_create()

static struct ast_websocket * websocket_client_create ( struct ast_websocket_client_options *  options, enum ast_websocket_result *  result  )

static

Definition at line 1254 of file res_http_websocket.c.

{
    struct ast_websocket *ws = ao2_alloc(sizeof(*ws), session_destroy_fn);
 
    if (!ws) {
        ast_log(LOG_ERROR, "Unable to allocate websocket\n");
        *result = WS_ALLOCATE_ERROR;
        return NULL;
    }
 
    if (!ast_uuid_generate_str(ws->session_id, sizeof(ws->session_id))) {
        ast_log(LOG_ERROR, "Unable to allocate websocket session_id\n");
        ao2_ref(ws, -1);
        *result = WS_ALLOCATE_ERROR;
        return NULL;
    }
 
    if (!(ws->client = ao2_alloc(
              sizeof(*ws->client), websocket_client_destroy))) {
        ast_log(LOG_ERROR, "Unable to allocate websocket client\n");
        ao2_ref(ws, -1);
        *result = WS_ALLOCATE_ERROR;
        return NULL;
    }
 
    if (!(ws->client->key = websocket_client_create_key())) {
        ao2_ref(ws, -1);
        *result = WS_KEY_ERROR;
        return NULL;
    }
 
    if (websocket_client_parse_uri(
            options->uri, &ws->client->host, &ws->client->resource_name,
            &ws->client->userinfo)) {
        ao2_ref(ws, -1);
        *result = WS_URI_PARSE_ERROR;
        return NULL;
    }
 
    if (ast_strlen_zero(ws->client->userinfo)
        && !ast_strlen_zero(options->username)
        && !ast_strlen_zero(options->password)) {
        ast_asprintf(&ws->client->userinfo, "%s:%s", options->username,
            options->password);
    }
 
    if (!(ws->client->args = websocket_client_args_create(
              ws->client->host, options->tls_cfg, result))) {
        ao2_ref(ws, -1);
        return NULL;
    }
 
    ws->client->suppress_connection_msgs = options->suppress_connection_msgs;
    ws->client->args->suppress_connection_msgs = options->suppress_connection_msgs;
    ws->client->protocols = ast_strdup(options->protocols);
    ws->client->version = 13;
    ws->opcode = -1;
    ws->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
    ws->timeout = options->timeout;
 
    return ws;
}

References ao2_alloc, ao2_ref, websocket_client::args, ast_asprintf, ast_log, ast_strdup, ast_strlen_zero(), ast_uuid_generate_str(), ast_websocket::client, DEFAULT_RECONSTRUCTION_CEILING, websocket_client::host, websocket_client::key, LOG_ERROR, NULL, ast_websocket::opcode, options, websocket_client::protocols, ast_websocket::reconstruct, websocket_client::resource_name, result, session_destroy_fn(), ast_websocket::session_id, ast_tcptls_session_args::suppress_connection_msgs, websocket_client::suppress_connection_msgs, ast_websocket::timeout, websocket_client::userinfo, websocket_client::version, websocket_client_args_create(), websocket_client_create_key(), websocket_client_destroy(), websocket_client_parse_uri(), WS_ALLOCATE_ERROR, WS_KEY_ERROR, and WS_URI_PARSE_ERROR.

Referenced by ast_websocket_client_create_with_options().

websocket_client_create_key()

static char * websocket_client_create_key ( void  )

static

Definition at line 1193 of file res_http_websocket.c.

{
    static int encoded_size = CLIENT_KEY_SIZE * 2 * sizeof(char) + 1;
    /* key is randomly selected 16-byte base64 encoded value */
    unsigned char key[CLIENT_KEY_SIZE + sizeof(long) - 1];
    char *encoded = ast_malloc(encoded_size);
    long i = 0;
 
    if (!encoded) {
        ast_log(LOG_ERROR, "Unable to allocate client websocket key\n");
        return NULL;
    }
 
    while (i < CLIENT_KEY_SIZE) {
        long num = ast_random();
        memcpy(key + i, &num, sizeof(long));
        i += sizeof(long);
    }
 
    ast_base64encode(encoded, key, CLIENT_KEY_SIZE, encoded_size);
    return encoded;
}

References ast_base64encode(), ast_log, ast_malloc, ast_random(), CLIENT_KEY_SIZE, LOG_ERROR, and NULL.

Referenced by websocket_client_create().

websocket_client_destroy()

static void websocket_client_destroy ( void *  obj )

static

Definition at line 1239 of file res_http_websocket.c.

{
    struct websocket_client *client = obj;
 
    ao2_cleanup(client->ser);
    ao2_cleanup(client->args);
 
    ast_free(client->accept_protocol);
    ast_free(client->protocols);
    ast_free(client->key);
    ast_free(client->resource_name);
    ast_free(client->host);
    ast_free(client->userinfo);
}

References websocket_client::accept_protocol, ao2_cleanup, websocket_client::args, ast_free, websocket_client::host, websocket_client::key, websocket_client::protocols, websocket_client::resource_name, websocket_client::ser, and websocket_client::userinfo.

Referenced by websocket_client_create().

websocket_client_handle_response_code()

static enum ast_websocket_result websocket_client_handle_response_code ( struct websocket_client *  client, int  response_code  )

static

Definition at line 1324 of file res_http_websocket.c.

{
    if (response_code <= 0) {
        return WS_INVALID_RESPONSE;
    }
 
    switch (response_code) {
    case 101:
        return 0;
    case 400:
        if (!client->suppress_connection_msgs) {
            ast_log(LOG_ERROR, "Received response 400 - Bad Request "
                "- from %s\n", client->host);
        }
        return WS_BAD_REQUEST;
    case 401:
        if (!client->suppress_connection_msgs) {
            ast_log(LOG_ERROR, "Received response 401 - Unauthorized "
                "- from %s\n", client->host);
        }
        return WS_UNAUTHORIZED;
    case 404:
        if (!client->suppress_connection_msgs) {
            ast_log(LOG_ERROR, "Received response 404 - Request URL not "
                "found - from %s\n", client->host);
        }
        return WS_URL_NOT_FOUND;
    }
 
    if (!client->suppress_connection_msgs) {
        ast_log(LOG_ERROR, "Invalid HTTP response code %d from %s\n",
            response_code, client->host);
    }
    return WS_INVALID_RESPONSE;
}

References ast_log, ast_websocket::client, websocket_client::host, LOG_ERROR, websocket_client::suppress_connection_msgs, WS_BAD_REQUEST, WS_INVALID_RESPONSE, WS_UNAUTHORIZED, and WS_URL_NOT_FOUND.

Referenced by websocket_client_handshake_get_response().

websocket_client_handshake()

static enum ast_websocket_result websocket_client_handshake ( struct websocket_client *  client )

static

Definition at line 1448 of file res_http_websocket.c.

{
    size_t protocols_len = 0;
    struct ast_variable *auth_header = NULL;
    size_t res;
 
    if (!ast_strlen_zero(client->userinfo)) {
        auth_header = ast_http_create_basic_auth_header(client->userinfo, NULL);
        if (!auth_header) {
            ast_log(LOG_ERROR, "Unable to allocate client websocket userinfo\n");
            return WS_ALLOCATE_ERROR;
        }
    }
 
    protocols_len = client->protocols ? strlen(client->protocols) : 0;
 
    res = ast_iostream_printf(client->ser->stream,
        "GET /%s HTTP/1.1\r\n"
        "Sec-WebSocket-Version: %d\r\n"
        "Upgrade: websocket\r\n"
        "Connection: Upgrade\r\n"
        "Host: %s\r\n"
        optional_header_spec
        optional_header_spec
        "Sec-WebSocket-Key: %s\r\n"
        "\r\n",
        client->resource_name ? ast_str_buffer(client->resource_name) : "",
        client->version,
        client->host,
        print_optional_header(auth_header, "Authorization: ", auth_header->value),
        print_optional_header(protocols_len, "Sec-WebSocket-Protocol: ", client->protocols),
        client->key
    );
 
    ast_variables_destroy(auth_header);
    if (res < 0) {
        ast_log(LOG_ERROR, "Failed to send handshake.\n");
        return WS_WRITE_ERROR;
    }
    /* wait for a response before doing anything else */
    return websocket_client_handshake_get_response(client);
}

References ast_http_create_basic_auth_header(), ast_iostream_printf(), ast_log, ast_str_buffer(), ast_strlen_zero(), ast_variables_destroy(), websocket_client::host, websocket_client::key, LOG_ERROR, NULL, optional_header_spec, print_optional_header, websocket_client::protocols, websocket_client::resource_name, websocket_client::ser, ast_tcptls_session_instance::stream, websocket_client::userinfo, ast_variable::value, websocket_client::version, websocket_client_handshake_get_response(), WS_ALLOCATE_ERROR, and WS_WRITE_ERROR.

Referenced by websocket_client_connect().

websocket_client_handshake_get_response()

static enum ast_websocket_result websocket_client_handshake_get_response ( struct websocket_client *  client )

static

Definition at line 1361 of file res_http_websocket.c.

{
    enum ast_websocket_result res;
    char buf[4096];
    char base64[64];
    int has_upgrade = 0;
    int has_connection = 0;
    int has_accept = 0;
    int has_protocol = 0;
 
    while (ast_iostream_gets(client->ser->stream, buf, sizeof(buf)) <= 0) {
        if (errno == EINTR || errno == EAGAIN) {
            continue;
        }
 
        ast_log(LOG_ERROR, "Unable to retrieve HTTP status line.");
        return WS_BAD_STATUS;
    }
 
    if ((res = websocket_client_handle_response_code(client,
            ast_http_response_status_line(
                buf, "HTTP/1.1", 101))) != WS_OK) {
        return res;
    }
 
    /* Ignoring line folding - assuming header field values are contained
       within a single line */
    while (1) {
        ssize_t len = ast_iostream_gets(client->ser->stream, buf, sizeof(buf));
        char *name, *value;
        int parsed;
 
        if (len <= 0) {
            if (errno == EINTR || errno == EAGAIN) {
                continue;
            }
            break;
        }
 
        parsed = ast_http_header_parse(buf, &name, &value);
        if (parsed < 0) {
            break;
        }
 
        if (parsed > 0) {
            continue;
        }
 
        if (!has_upgrade &&
            (has_upgrade = ast_http_header_match(
                name, "upgrade", value, "websocket")) < 0) {
            return WS_HEADER_MISMATCH;
        } else if (!has_connection &&
               (has_connection = ast_http_header_match(
                   name, "connection", value, "upgrade")) < 0) {
            return WS_HEADER_MISMATCH;
        } else if (!has_accept &&
               (has_accept = ast_http_header_match(
                   name, "sec-websocket-accept", value,
                websocket_combine_key(
                    client->key, base64, sizeof(base64)))) < 0) {
            return WS_HEADER_MISMATCH;
        } else if (!has_protocol &&
               (has_protocol = ast_http_header_match_in(
                   name, "sec-websocket-protocol", value, client->protocols))) {
            if (has_protocol < 0) {
                return WS_HEADER_MISMATCH;
            }
            client->accept_protocol = ast_strdup(value);
        } else if (!strcasecmp(name, "sec-websocket-extensions")) {
            ast_log(LOG_ERROR, "Extensions received, but not "
                "supported by client\n");
            return WS_NOT_SUPPORTED;
        }
    }
 
    return has_upgrade && has_connection && has_accept ?
        WS_OK : WS_HEADER_MISSING;
}

References websocket_client::accept_protocol, ast_http_header_match(), ast_http_header_match_in(), ast_http_header_parse(), ast_http_response_status_line(), ast_iostream_gets(), ast_log, ast_strdup, base64, buf, ast_websocket::client, errno, websocket_client::key, len(), LOG_ERROR, name, websocket_client::protocols, websocket_client::ser, ast_tcptls_session_instance::stream, value, websocket_client_handle_response_code(), websocket_combine_key(), WS_BAD_STATUS, WS_HEADER_MISMATCH, WS_HEADER_MISSING, WS_NOT_SUPPORTED, and WS_OK.

Referenced by websocket_client_handshake().

websocket_client_parse_uri()

static int websocket_client_parse_uri ( const char *  uri, char **  host, struct ast_str **  path, char **  userinfo  )

static

Parse the given uri into a path and remote address.

Expected uri form:

[ws[s]]://<host>[:port][/<path>] 

The returned host will contain the address and optional port while path will contain everything after the address/port if included.

Definition at line 1110 of file res_http_websocket.c.

{
    struct ast_uri *parsed_uri = ast_uri_parse_websocket(uri);
 
    if (!parsed_uri) {
        return -1;
    }
 
    *host = ast_uri_make_host_with_port(parsed_uri);
    *userinfo = ast_strdup(ast_uri_user_info(parsed_uri));
 
    if (ast_uri_path(parsed_uri) || ast_uri_query(parsed_uri)) {
        *path = ast_str_create(64);
        if (!*path) {
            ao2_ref(parsed_uri, -1);
            return -1;
        }
 
        if (ast_uri_path(parsed_uri)) {
            ast_str_set(path, 0, "%s", ast_uri_path(parsed_uri));
        }
 
        if (ast_uri_query(parsed_uri)) {
            ast_str_append(path, 0, "?%s", ast_uri_query(parsed_uri));
        }
    }
 
    ao2_ref(parsed_uri, -1);
    return 0;
}

References ao2_ref, ast_str_append(), ast_str_create, ast_str_set(), ast_strdup, ast_uri_make_host_with_port(), ast_uri_parse_websocket(), ast_uri_path(), ast_uri_query(), ast_uri_user_info(), ast_uri::host, ast_uri::path, and ast_uri::uri.

Referenced by websocket_client_create().

websocket_combine_key()

static char * websocket_combine_key ( const char *  key, char *  res, int  res_size  )

static

Definition at line 780 of file res_http_websocket.c.

{
    char *combined;
    unsigned combined_length = strlen(key) + strlen(WEBSOCKET_GUID) + 1;
    uint8_t sha[20];
 
    combined = ast_alloca(combined_length);
    snprintf(combined, combined_length, "%s%s", key, WEBSOCKET_GUID);
    ast_sha1_hash_uint(sha, combined);
    ast_base64encode(res, (const unsigned char*)sha, 20, res_size);
    return res;
}

References ast_alloca, ast_base64encode(), ast_sha1_hash_uint(), and WEBSOCKET_GUID.

Referenced by ast_websocket_uri_cb(), and websocket_client_handshake_get_response().

websocket_echo_callback()

static void websocket_echo_callback ( struct ast_websocket *  session, struct ast_variable *  parameters, struct ast_variable *  headers  )

static

Simple echo implementation which echoes received text and binary frames.

Definition at line 1023 of file res_http_websocket.c.

{
    int res;
 
    ast_debug(1, "Entering WebSocket echo loop\n");
 
    if (ast_fd_set_flags(ast_websocket_fd(session), O_NONBLOCK)) {
        goto end;
    }
 
    while ((res = ast_websocket_wait_for_input(session, -1)) > 0) {
        char *payload;
        uint64_t payload_len;
        enum ast_websocket_opcode opcode;
        int fragmented;
 
        if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
            /* We err on the side of caution and terminate the session if any error occurs */
            ast_log(LOG_WARNING, "Read failure during WebSocket echo loop\n");
            break;
        }
 
        if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
            ast_websocket_write(session, opcode, payload, payload_len);
        } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
            break;
        } else {
            ast_debug(1, "Ignored WebSocket opcode %u\n", opcode);
        }
    }
 
end:
    ast_debug(1, "Exiting WebSocket echo loop\n");
    ast_websocket_unref(session);
}

References ast_debug, ast_fd_set_flags, ast_log, ast_websocket_fd(), AST_WEBSOCKET_OPCODE_BINARY, AST_WEBSOCKET_OPCODE_CLOSE, AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_read(), ast_websocket_unref(), ast_websocket_wait_for_input(), ast_websocket_write(), end, LOG_WARNING, and session.

Referenced by load_module(), and unload_module().

websocket_mask_payload()

static void websocket_mask_payload ( struct ast_websocket *  session, char *  frame, char *  payload, uint64_t  payload_size  )

static

Perform payload masking for client sessions.

Definition at line 304 of file res_http_websocket.c.

{
    /* RFC 6455 5.1 - clients MUST mask frame data */
    if (session->client) {
        uint64_t i;
        uint8_t mask_key_idx;
        uint32_t mask_key = ast_random();
        uint8_t length = frame[1] & 0x7f;
        frame[1] |= 0x80; /* set mask bit to 1 */
        /* The mask key octet position depends on the length */
        mask_key_idx = length == 126 ? 4 : length == 127 ? 10 : 2;
        put_unaligned_uint32(&frame[mask_key_idx], mask_key);
        for (i = 0; i < payload_size; i++) {
            payload[i] ^= ((char *)&mask_key)[i % 4];
        }
    }
}

References ast_random(), put_unaligned_uint32(), and session.

Referenced by ast_websocket_close(), and ast_websocket_write().

websocket_opcode2str()

static const char * websocket_opcode2str ( enum ast_websocket_opcode  opcode )

static

Definition at line 379 of file res_http_websocket.c.

{
    if (opcode < AST_WEBSOCKET_OPCODE_CONTINUATION ||
            opcode > AST_WEBSOCKET_OPCODE_PONG) {
        return "<unknown>";
    } else {
        return opcode_map[opcode];
    }
}

References AST_WEBSOCKET_OPCODE_CONTINUATION, AST_WEBSOCKET_OPCODE_PONG, ast_websocket::opcode, and opcode_map.

Referenced by ast_websocket_write().

websocket_remove_protocol_internal()

static int websocket_remove_protocol_internal ( const char *  name, ast_websocket_callback  callback  )

static

Definition at line 1088 of file res_http_websocket.c.

{
    struct ast_websocket_server *ws_server = websocketuri.data;
    if (!ws_server) {
        return -1;
    }
    return ast_websocket_server_remove_protocol(ws_server, name, callback);
}

References ast_websocket_server_remove_protocol(), callback(), ast_http_uri::data, name, and websocketuri.

Referenced by ast_websocket_remove_protocol(), and unload_module().

websocket_server_create_impl()

static struct ast_websocket_server * websocket_server_create_impl ( void  )

static

Definition at line 159 of file res_http_websocket.c.

{
    RAII_VAR(struct ast_websocket_server *, server, NULL, ao2_cleanup);
 
    server = ao2_alloc(sizeof(*server), websocket_server_dtor);
    if (!server) {
        return NULL;
    }
 
    server->protocols = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        MAX_PROTOCOL_BUCKETS, protocol_hash_fn, NULL, protocol_cmp_fn);
    if (!server->protocols) {
        return NULL;
    }
 
    ao2_ref(server, +1);
    return server;
}

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_hash, ao2_ref, MAX_PROTOCOL_BUCKETS, NULL, protocol_cmp_fn(), protocol_hash_fn(), RAII_VAR, and websocket_server_dtor().

Referenced by ast_websocket_server_create(), and websocket_server_internal_create().

websocket_server_dtor()

static void websocket_server_dtor ( void *  obj )

static

Definition at line 152 of file res_http_websocket.c.

{
    struct ast_websocket_server *server = obj;
    ao2_cleanup(server->protocols);
    server->protocols = NULL;
}

References ao2_cleanup, NULL, and ast_websocket_server::protocols.

Referenced by websocket_server_create_impl().

websocket_server_internal_create()

static struct ast_websocket_server * websocket_server_internal_create ( void  )

static

Definition at line 178 of file res_http_websocket.c.

{
    return websocket_server_create_impl();
}

References websocket_server_create_impl().

Referenced by load_module().

ws_safe_read()

static int ws_safe_read ( struct ast_websocket *  session, char *  buf, size_t  len, enum ast_websocket_opcode *  opcode  )

inlinestatic

Definition at line 550 of file res_http_websocket.c.

{
    ssize_t rlen;
    int xlen = len;
    char *rbuf = buf;
    int sanity = 10;
 
    ast_assert(len > 0);
 
    if (!len) {
        errno = EINVAL;
        return -1;
    }
 
    ao2_lock(session);
    if (!session->stream) {
        ao2_unlock(session);
        errno = ECONNABORTED;
        return -1;
    }
 
    for (;;) {
        rlen = ast_iostream_read(session->stream, rbuf, xlen);
        if (rlen != xlen) {
            if (rlen == 0) {
                ast_log(LOG_WARNING, "Web socket closed abruptly\n");
                *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
                session->closing = 1;
                ao2_unlock(session);
                return -1;
            }
 
            if (rlen < 0 && errno != EAGAIN) {
                ast_log(LOG_ERROR, "Error reading from web socket: %s\n", strerror(errno));
                *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
                session->closing = 1;
                ao2_unlock(session);
                return -1;
            }
 
            if (!--sanity) {
                ast_log(LOG_WARNING, "Websocket seems unresponsive, disconnecting ...\n");
                *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
                session->closing = 1;
                ao2_unlock(session);
                return -1;
            }
        }
        if (rlen > 0) {
            xlen = xlen - rlen;
            rbuf = rbuf + rlen;
            if (!xlen) {
                break;
            }
        }
        if (ast_iostream_wait_for_input(session->stream, 1000) < 0) {
            ast_log(LOG_ERROR, "ast_iostream_wait_for_input returned err: %s\n", strerror(errno));
            *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
            session->closing = 1;
            ao2_unlock(session);
            return -1;
        }
    }
 
    ao2_unlock(session);
    return 0;
}

References ao2_lock, ao2_unlock, ast_assert, ast_iostream_read(), ast_iostream_wait_for_input(), ast_log, AST_WEBSOCKET_OPCODE_CLOSE, buf, errno, len(), LOG_ERROR, LOG_WARNING, ast_websocket::opcode, and session.

Referenced by ast_websocket_read().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "HTTP WebSocket Support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "http", }

static

Definition at line 1663 of file res_http_websocket.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1663 of file res_http_websocket.c.

opcode_map

const char* opcode_map[]

static

Definition at line 370 of file res_http_websocket.c.

                                  {
    [AST_WEBSOCKET_OPCODE_CONTINUATION] = "continuation",
    [AST_WEBSOCKET_OPCODE_TEXT] = "text",
    [AST_WEBSOCKET_OPCODE_BINARY] = "binary",
    [AST_WEBSOCKET_OPCODE_CLOSE] = "close",
    [AST_WEBSOCKET_OPCODE_PING] = "ping",
    [AST_WEBSOCKET_OPCODE_PONG] = "pong",
};

Referenced by websocket_opcode2str().

websocket_result_string_map

const char* websocket_result_string_map[]

Definition at line 1608 of file res_http_websocket.c.

                                            {
    [WS_OK] = "OK",
    [WS_ALLOCATE_ERROR] = "Allocation error",
    [WS_KEY_ERROR] = "Key error",
    [WS_URI_PARSE_ERROR] = "URI parse error",
    [WS_URI_RESOLVE_ERROR] = "URI resolve error",
    [WS_BAD_STATUS] = "Bad status line",
    [WS_INVALID_RESPONSE] = "Invalid response code",
    [WS_BAD_REQUEST] = "Bad request",
    [WS_URL_NOT_FOUND] = "URL not found",
    [WS_HEADER_MISMATCH] = "Header mismatch",
    [WS_HEADER_MISSING] = "Header missing",
    [WS_NOT_SUPPORTED] = "Not supported",
    [WS_WRITE_ERROR] = "Write error",
    [WS_CLIENT_START_ERROR] = "Client start error",
    [WS_UNAUTHORIZED] = "Unauthorized"
};

Referenced by ast_websocket_result_to_str().

websocketuri

struct ast_http_uri websocketuri

static

Definition at line 1013 of file res_http_websocket.c.

                                          {
    .callback = AST_OPTIONAL_API_NAME(ast_websocket_uri_cb),
    .description = "Asterisk HTTP WebSocket",
    .uri = "ws",
    .has_subtree = 0,
    .data = NULL,
    .key = __FILE__,
};

Referenced by ast_websocket_add_protocol2(), load_module(), unload_module(), websocket_add_protocol_internal(), and websocket_remove_protocol_internal().