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/sched.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	status_map
struct	websocket_client

Macros
#define	ARE_PINGPONGS_ENABLED(_session)   (_session && _session->client && _session->client->options->pingpongs && _session->client->ping_sched_timer >= 0)
#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	SAFE_STRDUP_WITH_ERROR_RTN(_clone, _str)
#define	WEBSOCKET_GUID   "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
	GUID used to compute the accept key, defined in the specifications.
#define	WS_PING_PAYLOAD   "WS_CLIENT_PING"
	WS_PING_PAYLOAD It's possible that a user of this API could be sending their own PINGs and expecting to see PONGs so we use the PING_PAYLOAD in the PINGs we send so we can detect that any PONGs we receive are from our own PINGs.
#define	WS_PING_PAYLOAD_LEN   14
#define	WS_SESSION_REMOTE(_session)   (_session ? (_session->client ? _session->client->options->uri : ast_sockaddr_stringify(&_session->remote_address)) : "NULL")

Enumerations
enum	ws_closed_by { WS_NOT_CLOSED = 0 , WS_CLOSED_BY_REMOTE , WS_CLOSED_BY_US }

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.
const char *AST_OPTIONAL_API_NAME()	ast_websocket_status_to_str (enum ast_websocket_status_code code)
	Convert a websocket status code to a string.
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 struct ast_websocket_client_options *	client_options_clone (struct ast_websocket_client_options *options)
static void	client_options_destroy (void *obj)
static const char *	closed_by_to_str (enum ws_closed_by closed_by)
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	ping_scheduler_callback (const void *obj)
static void	ping_scheduler_cancel (struct ast_websocket *session)
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 (struct ast_websocket *ws, struct ast_websocket_client_options *options, 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, struct ast_websocket_client_options *options)
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, int proxy)
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, int proxy)
static int	websocket_client_parse_uri (const char *uri, char **host, struct ast_str **path, char **userinfo, int proxy)
	Parse the given uri into a path and remote address.
static void	websocket_client_start_handshake_timer (struct websocket_client *client)
static void	websocket_client_stop_handshake_timer (struct websocket_client *client)
static int	websocket_close (struct ast_websocket *session, uint16_t reason, int force)
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 int	websocket_handled_pong_or_close (struct ast_websocket *session, char *payload, uint64_t payload_len, enum ast_websocket_opcode opcode)
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 enum ast_websocket_result	websocket_proxy_handshake (struct websocket_client *client)
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 *	closed_by_str []
static const char *	opcode_map []
static struct ast_sched_context *	ping_scheduler
const char *	websocket_result_string_map []
static const struct status_map	websocket_status_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

ARE_PINGPONGS_ENABLED

#define ARE_PINGPONGS_ENABLED

(

_session

)

(_session && _session->client && _session->client->options->pingpongs && _session->client->ping_sched_timer >= 0)

Definition at line 151 of file res_http_websocket.c.

AST_API_MODULE

#define AST_API_MODULE

Definition at line 42 of file res_http_websocket.c.

CLIENT_KEY_SIZE

#define CLIENT_KEY_SIZE   16

Length of a websocket's client key.

Definition at line 49 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 66 of file res_http_websocket.c.

MAX_PROTOCOL_BUCKETS

#define MAX_PROTOCOL_BUCKETS   7

Number of buckets for registered protocols.

Definition at line 52 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 79 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 69 of file res_http_websocket.c.

MIN_WS_HDR_SZ

#define MIN_WS_HDR_SZ   2

Definition at line 80 of file res_http_websocket.c.

optional_header_spec

#define optional_header_spec   "%s%s%s"

Definition at line 1741 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 1742 of file res_http_websocket.c.

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

SAFE_STRDUP_WITH_ERROR_RTN

#define SAFE_STRDUP_WITH_ERROR_RTN	(		_clone,
			_str
	)

Definition at line 1428 of file res_http_websocket.c.

 { \
    char *_duped = NULL; \
    if (_str) { \
        _duped = ast_strdup(_str); \
        if (!_duped) { \
            ao2_cleanup(_clone); \
            return NULL; \
        } \
    } \
    _duped; \
})

WEBSOCKET_GUID

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

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

Definition at line 46 of file res_http_websocket.c.

WS_PING_PAYLOAD

#define WS_PING_PAYLOAD   "WS_CLIENT_PING"

WS_PING_PAYLOAD It's possible that a user of this API could be sending their own PINGs and expecting to see PONGs so we use the PING_PAYLOAD in the PINGs we send so we can detect that any PONGs we receive are from our own PINGs.

Definition at line 87 of file res_http_websocket.c.

WS_PING_PAYLOAD_LEN

#define WS_PING_PAYLOAD_LEN   14

Definition at line 88 of file res_http_websocket.c.

WS_SESSION_REMOTE

#define WS_SESSION_REMOTE

(

_session

)

(_session ? (_session->client ? _session->client->options->uri : ast_sockaddr_stringify(&_session->remote_address)) : "NULL")

Definition at line 150 of file res_http_websocket.c.

Enumeration Type Documentation

ws_closed_by

enum ws_closed_by

Enumerator
WS_NOT_CLOSED
WS_CLOSED_BY_REMOTE
WS_CLOSED_BY_US

Definition at line 92 of file res_http_websocket.c.

                  {
    WS_NOT_CLOSED = 0,
    WS_CLOSED_BY_REMOTE,
    WS_CLOSED_BY_US,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2219 of file res_http_websocket.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 2219 of file res_http_websocket.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 2219 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 1242 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 1247 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 1563 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

Warning

The returned websocket must be closed with ast_websocket_close and its reference count decremented with ast_websocket_unref when it's no longer needed.

Definition at line 1914 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

Warning

The returned websocket must be closed with ast_websocket_close and its reference count decremented with ast_websocket_unref when it's no longer needed.

Definition at line 2006 of file res_http_websocket.c.

{
    struct ast_websocket *ws = NULL;
    SCOPE_ENTER(2, "%s: Creating client\n", options->uri);
 
    ws = websocket_client_create(options, result);
    if (!ws) {
        SCOPE_EXIT_LOG_RTN_VALUE(NULL, LOG_ERROR, "%s: Failed to create: %s\n", options->uri, ast_websocket_result_to_str(*result));
    }
 
    ast_trace(-1, "%s: Connecting\n", ws->client->options->uri);
 
    if ((*result = websocket_client_connect(ws, options)) != WS_OK) {
        ao2_ref(ws, -1);
        SCOPE_EXIT_RTN_VALUE(NULL, "%s: Failed to connect: %s\n", options->uri, ast_websocket_result_to_str(*result));
    }
    ast_trace(-1, "%s: Connected\n", ws->client->options->uri);
 
    if (ws->client->options->tcp_keepalives) {
        int sockfd = ast_iostream_get_fd(ws->stream);
        int enabled = 1;
 
        setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, &enabled, sizeof(enabled));
        setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &options->tcp_keepalive_time, sizeof(options->tcp_keepalive_time));
        setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &options->tcp_keepalive_interval, sizeof(&options->tcp_keepalive_interval));
        setsockopt(sockfd, IPPROTO_TCP, TCP_KEEPCNT, &options->tcp_keepalive_probes, sizeof(&options->tcp_keepalive_probes));
        ast_trace(-1, "%s: Enabled TCP keepalives\n", ws->client->options->uri);
    }
 
    if (ws->client->options->pingpongs) {
        ws->client->ping_sched_timer = ast_sched_add(ping_scheduler, ws->client->options->pingpong_interval * 1000,
            ping_scheduler_callback, ao2_bump(ws));
        if (ws->client->ping_sched_timer < 0) {
            ast_log(LOG_WARNING, "%s: Unable to schedule PING/PONG keepalives\n", ws->client->options->uri);
            ao2_ref(ws, -1);
        } else {
            ast_trace(-1, "%s: Enabled PING/PONG keepalives\n", ws->client->options->uri);
        }
    }
    SCOPE_EXIT_RTN_VALUE(ws, "%s: Client created and connected %p %p\n", options->uri, ws, ws->client);
}

References ao2_bump, ao2_ref, ast_iostream_get_fd(), ast_log, ast_sched_add(), ast_trace, ast_websocket_result_to_str(), ast_websocket::client, enabled, LOG_ERROR, LOG_WARNING, NULL, websocket_client::options, options, websocket_client::ping_sched_timer, ping_scheduler, ping_scheduler_callback(), ast_websocket_client_options::pingpong_interval, ast_websocket_client_options::pingpongs, result, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, ast_websocket::stream, ast_websocket_client_options::tcp_keepalives, ast_websocket_client_options::uri, 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 553 of file res_http_websocket.c.

{
    if (session->closed_by == WS_NOT_CLOSED) {
        session->closed_by = WS_CLOSED_BY_US;
    }
 
    return websocket_close(session, reason, 0);
}

References session, websocket_close(), WS_CLOSED_BY_US, and WS_NOT_CLOSED.

Referenced by ast_websocket_read(), 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(), websocket_disconnect(), websocket_established_cb(), 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 662 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 session_read(), speech_test_server_cb(), websocket_echo_callback(), websocket_handoff_to_channel(), 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 682 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 677 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 803 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;
    SCOPE_ENTER(4, "%s: Reading\n", WS_SESSION_REMOTE(session));
 
    *payload = NULL;
    *payload_len = 0;
    *fragmented = 0;
 
    if (ws_safe_read(session, &session->buf[0], MIN_WS_HDR_SZ, opcode)) {
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Initial ws_safe_read failed\n", WS_SESSION_REMOTE(session));
    }
    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)) {
                SCOPE_EXIT_RTN_VALUE(-1, "%s: ws_safe_read of options failed\n", WS_SESSION_REMOTE(session));
            }
            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) {
            /* The frame won't fit :-( */
            ast_websocket_close(session, 1009);
            SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Cannot fit huge websocket frame of %zu bytes\n",
                WS_SESSION_REMOTE(session), frame_size);
        }
 
        if (*payload_len) {
            if (ws_safe_read(session, *payload, *payload_len, opcode)) {
                SCOPE_EXIT_RTN_VALUE(-1, "%s: ws_safe_read of payload failed\n", WS_SESSION_REMOTE(session));
            }
        }
 
        /* 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;
            SCOPE_EXIT_RTN_VALUE(0, "%s: PING received.  Sent PONG\n", WS_SESSION_REMOTE(session));
        }
 
        if (websocket_handled_pong_or_close(session, *payload, *payload_len, *opcode)) {
            SCOPE_EXIT_RTN_VALUE(0, "%s: Handled PONG or CLOSE\n", WS_SESSION_REMOTE(session));
        }
 
        /* 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)))) {
                *payload_len = 0;
                ast_websocket_close(session, 1009);
                SCOPE_EXIT_LOG_RTN_VALUE(-1, LOG_WARNING, "%s: Failed allocation: %p, %zu, %"PRIu64"\n",
                    WS_SESSION_REMOTE(session), session->payload, session->payload_len, *payload_len);
            }
 
            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);
    }
 
    SCOPE_EXIT_RTN_VALUE(0, "%s: Read complete.  Opcode: %s  Length: %"PRIu64"\n",
        WS_SESSION_REMOTE(session), websocket_opcode2str(*opcode), *payload_len);
}

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, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, session, websocket_handled_pong_or_close(), websocket_opcode2str(), ws_safe_read(), and WS_SESSION_REMOTE.

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 2049 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 638 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 633 of file res_http_websocket.c.

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

References MAXIMUM_RECONSTRUCTION_CEILING, MIN, and session.

Referenced by websocket_handoff_to_channel().

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 643 of file res_http_websocket.c.

{
    char *id = ast_strdupa(WS_SESSION_REMOTE(session));
    int refcount = session ? ao2_ref(session, 0) : 0;
    SCOPE_ENTER(2, "%s: Reffing.  Refcount: %d\n", id, refcount);
    ao2_ref(session, +1);
    SCOPE_EXIT("%s: Reffed.  Refcount: %d\n", id, session ? refcount - 1 : 0);
}

References ao2_ref, ast_strdupa, SCOPE_ENTER, SCOPE_EXIT, session, and WS_SESSION_REMOTE.

Referenced by session_update(), and 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 672 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(), websocket_established_cb(), and websocket_handoff_to_channel().

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 1271 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 2129 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(), ast_websocket_client_create_with_options(), webchan_call(), websocket_client_handshake(), websocket_client_handshake_get_response(), and websocket_proxy_handshake().

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 295 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 317 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 250 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 351 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 701 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 687 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 694 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_status_to_str()

const char *AST_OPTIONAL_API_NAME() ast_websocket_status_to_str

(

enum ast_websocket_status_code

code

)

Convert a websocket status code to a string.

Parameters

code	The code to convert

Returns

A string representation of the code

Definition at line 2162 of file res_http_websocket.c.

{
    int i;
 
    for (i = 0; i < ARRAY_LEN(websocket_status_map); i++) {
        if (websocket_status_map[i].code == code)
            return websocket_status_map[i].desc;
    }
 
    return "Unknown";
}

References ARRAY_LEN, status_map::code, status_map::desc, and websocket_status_map.

Referenced by _websocket_request_hangup(), websocket_close(), and websocket_handled_pong_or_close().

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 276 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 167 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.

Referenced by session_cleanup().

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 652 of file res_http_websocket.c.

{
    char *id = ast_strdupa(WS_SESSION_REMOTE(session));
    int refcount = session ? ao2_ref(session, 0) : 0;
    SCOPE_ENTER(2, "%s: Unreffing.  Refcount: %d\n", id, refcount);
 
    ao2_cleanup(session);
    SCOPE_EXIT("%s: Unreffed.  Refcount: %d\n", id, session ? refcount - 1 : 0);
}

References ao2_cleanup, ao2_ref, ast_strdupa, SCOPE_ENTER, SCOPE_EXIT, session, and WS_SESSION_REMOTE.

Referenced by incoming_ws_established_cb(), outbound_session_handler_thread(), session_dtor(), speech_test_server_cb(), transport_dtor(), webchan_hangup(), websocket_cb(), websocket_destroy(), websocket_destructor(), 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 980 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 667 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 563 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;
    SCOPE_ENTER(4, "%s: Opcode: %s Length: %"PRIu64"\n",
        WS_SESSION_REMOTE(session), 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);
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Websocket already closing\n", WS_SESSION_REMOTE(session));
    }
 
    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_trace(-1, "%s: Closing WS with 1011 because we can't fulfill a write request\n",
            WS_SESSION_REMOTE(session));
        websocket_close(session, 1011, 1);
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Closed WS with 1011 because we couldn't fulfill a write request\n",
            WS_SESSION_REMOTE(session));
    }
 
    ast_iostream_set_timeout_disable(session->stream);
    ao2_unlock(session);
 
    SCOPE_EXIT_RTN_VALUE(0, "%s: Wrote opcode: %s length: %"PRIu64"\n",
        WS_SESSION_REMOTE(session), websocket_opcode2str(opcode), payload_size);
}

References ao2_lock, ao2_unlock, ast_alloca, ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_sequence(), ast_iostream_write(), ast_trace, ast_tvnow(), frame_size, htonll(), ast_websocket::opcode, ast_websocket::payload, put_unaligned_uint16(), put_unaligned_uint64(), SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, websocket_close(), websocket_mask_payload(), websocket_opcode2str(), and WS_SESSION_REMOTE.

Referenced by ast_websocket_read(), ast_websocket_write_string(), ping_scheduler_callback(), 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 2093 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(), session_write(), and speech_test_server_handle_request().

client_options_clone()

static struct ast_websocket_client_options * client_options_clone ( struct ast_websocket_client_options *  options )

static

Definition at line 1441 of file res_http_websocket.c.

{
    struct ast_websocket_client_options *clone = NULL;
 
    clone = ao2_alloc(sizeof(*clone), client_options_destroy);
    if (!clone) {
        ast_log(LOG_ERROR, "Unable to clone client options\n");
        return NULL;
    }
 
    memcpy(clone, options, sizeof(*options));
    clone->uri = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->uri);
    clone->protocols = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->protocols);
    clone->username = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->username);
    clone->password = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->password);
    clone->proxy_host = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->proxy_host);
    clone->proxy_username = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->proxy_username);
    clone->proxy_password = SAFE_STRDUP_WITH_ERROR_RTN(clone, options->proxy_password);
    if (options->tls_cfg) {
        clone->tls_cfg = ast_calloc(1, sizeof(*options->tls_cfg));
        if (!clone->tls_cfg) {
            ao2_cleanup(clone);
            return NULL;
        }
        memcpy(clone->tls_cfg, options->tls_cfg, sizeof(*options->tls_cfg));
    }
 
    return clone;
}

References ao2_alloc, ao2_cleanup, ast_calloc, ast_log, client_options_destroy(), LOG_ERROR, NULL, options, ast_websocket_client_options::password, ast_websocket_client_options::protocols, ast_websocket_client_options::proxy_host, ast_websocket_client_options::proxy_password, ast_websocket_client_options::proxy_username, SAFE_STRDUP_WITH_ERROR_RTN, ast_websocket_client_options::tls_cfg, ast_websocket_client_options::uri, and ast_websocket_client_options::username.

Referenced by websocket_client_create().

client_options_destroy()

static void client_options_destroy ( void *  obj )

static

Definition at line 1415 of file res_http_websocket.c.

{
    struct ast_websocket_client_options *clone = obj;
    ast_free((char *)clone->uri);
    ast_free((char *)clone->protocols);
    ast_free((char *)clone->username);
    ast_free((char *)clone->password);
    ast_free((char *)clone->proxy_host);
    ast_free((char *)clone->proxy_username);
    ast_free((char *)clone->proxy_password);
    ast_free(clone->tls_cfg);
}

References ast_free, ast_websocket_client_options::password, ast_websocket_client_options::protocols, ast_websocket_client_options::proxy_host, ast_websocket_client_options::proxy_password, ast_websocket_client_options::proxy_username, ast_websocket_client_options::tls_cfg, ast_websocket_client_options::uri, and ast_websocket_client_options::username.

Referenced by client_options_clone().

closed_by_to_str()

static const char * closed_by_to_str ( enum ws_closed_by  closed_by )

static

Definition at line 159 of file res_http_websocket.c.

{
    if (!ARRAY_IN_BOUNDS(closed_by, closed_by_str)) {
        return "unknown";
    }
    return closed_by_str[closed_by];
}

References ARRAY_IN_BOUNDS, and closed_by_str.

Referenced by websocket_close().

load_module()

static int load_module ( void  )

static

Definition at line 2190 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);
 
    ping_scheduler = ast_sched_context_create();
    if (!ping_scheduler) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (ast_sched_start_thread(ping_scheduler)) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return 0;
}

References ast_http_uri_link(), AST_MODULE_LOAD_DECLINE, ast_sched_context_create(), ast_sched_start_thread(), ast_http_uri::data, ping_scheduler, unload_module(), 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 942 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().

ping_scheduler_callback()

static int ping_scheduler_callback ( const void *  obj )

static

Definition at line 1928 of file res_http_websocket.c.

{
    struct ast_websocket *session = (struct ast_websocket *)obj;
 
    if (!session->client) {
        /*
         * We should never get here because we can only start pingpongs from a client
         * but just in case...
         */
        return 0;
    }
 
    ao2_lock(session);
    if (session->closing) {
        ao2_unlock(session);
        return 0;
    }
 
    if (session->client->missed_pong_count > 1) {
        ast_debug(2, "%s: Missed PONG count is now %d\n", WS_SESSION_REMOTE(session),
            session->client->missed_pong_count);
    }
 
    if (session->client->missed_pong_count >= session->client->options->pingpong_probes) {
        ao2_unlock(session);
        ast_log(LOG_WARNING, "%s: %d missed PONGs. Closing connection.\n",
            WS_SESSION_REMOTE(session), session->client->missed_pong_count);
        session->client->ping_sched_timer = -1;
        websocket_close(session, AST_WEBSOCKET_STATUS_GOING_AWAY, 1);
        return 0;
    }
 
    ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PING, WS_PING_PAYLOAD, WS_PING_PAYLOAD_LEN);
    session->client->missed_pong_count++;
 
    ao2_unlock(session);
    return session->client->options->pingpong_interval * 1000;
}

References ao2_lock, ao2_unlock, ast_debug, ast_log, AST_WEBSOCKET_OPCODE_PING, AST_WEBSOCKET_STATUS_GOING_AWAY, ast_websocket_write(), LOG_WARNING, session, websocket_close(), WS_PING_PAYLOAD, WS_PING_PAYLOAD_LEN, and WS_SESSION_REMOTE.

Referenced by ast_websocket_client_create_with_options().

ping_scheduler_cancel()

static void ping_scheduler_cancel ( struct ast_websocket *  session )

static

Definition at line 408 of file res_http_websocket.c.

{
    int enabled = ARE_PINGPONGS_ENABLED(session);
    SCOPE_ENTER(2, "%s: Cancelling PING/PONG keepalives\n", WS_SESSION_REMOTE(session));
 
    if (!enabled) {
        SCOPE_EXIT_RTN("%s: Not enabled, cancel not needed\n", WS_SESSION_REMOTE(session));
    }
    AST_SCHED_DEL(ping_scheduler, session->client->ping_sched_timer);
    ao2_ref(session, -1);
    SCOPE_EXIT_RTN("%s: Cancelled PING/PONG keepalives\n", WS_SESSION_REMOTE(session));
}

References ao2_ref, ARE_PINGPONGS_ENABLED, AST_SCHED_DEL, enabled, ping_scheduler, SCOPE_ENTER, SCOPE_EXIT_RTN, session, and WS_SESSION_REMOTE.

Referenced by websocket_close().

protocol_cmp_fn()

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

static

Comparison function for protocols.

Definition at line 199 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 208 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 190 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 256 of file res_http_websocket.c.

{
    struct ast_websocket *session = obj;
    char *id = ast_strdupa(WS_SESSION_REMOTE(session));
    SCOPE_ENTER(2, "%s: Session %p destructor\n", id, obj);
 
    if (session->stream) {
        ast_websocket_close(session, session->close_status_code);
        if (session->stream) {
            ast_iostream_close(session->stream);
            session->stream = NULL;
            ast_trace(-1, "%s: WebSocket connection closed\n", WS_SESSION_REMOTE(session));
        }
    }
 
    ao2_cleanup(session->client);
    ast_free(session->payload);
    SCOPE_EXIT_RTN("%s; Session %p destructor complete\n", id, obj);
}

References ao2_cleanup, ast_free, ast_iostream_close(), ast_strdupa, ast_trace, ast_websocket_close(), NULL, SCOPE_ENTER, SCOPE_EXIT_RTN, session, and WS_SESSION_REMOTE.

Referenced by ast_websocket_uri_cb(), and websocket_client_create().

unload_module()

static int unload_module ( void  )

static

Definition at line 2175 of file res_http_websocket.c.

{
    if (ping_scheduler) {
        ast_sched_context_destroy(ping_scheduler);
        ping_scheduler = NULL;
    }
 
    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_sched_context_destroy(), ast_http_uri::data, NULL, ping_scheduler, websocket_echo_callback(), websocket_remove_protocol_internal(), and websocketuri.

Referenced by load_module().

websocket_add_protocol_internal()

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

static

Definition at line 1233 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 967 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 ( struct ast_websocket *  ws, struct ast_websocket_client_options *  options, enum ast_websocket_result *  result  )

static

Definition at line 1331 of file res_http_websocket.c.

{
    struct ast_sockaddr *addr;
    struct ast_tcptls_session_args *args = ao2_alloc(
        sizeof(*args), websocket_client_args_destroy);
    const char *resolve_host = NULL;
 
    if (!args) {
        *result = WS_ALLOCATE_ERROR;
        return NULL;
    }
 
    args->accept_fd = -1;
    args->tls_cfg = options->tls_cfg;
    args->name = "websocket client";
 
    if (!ast_strlen_zero(ws->client->options->proxy_host)) {
        resolve_host = ws->client->options->proxy_host;
    } else {
        resolve_host = ws->client->host;
    }
    if (!ast_sockaddr_resolve(&addr, resolve_host, 0, 0)) {
        ast_log(LOG_ERROR, "Unable to resolve address %s\n",
            resolve_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(ws->client->host, ":"), ws->client->host);
 
    return args;
}

References ao2_alloc, ao2_ref, args, ast_free, ast_log, ast_sockaddr_copy(), ast_sockaddr_resolve(), ast_strlen_zero(), ast_websocket::client, websocket_client::host, LOG_ERROR, NULL, websocket_client::options, options, ast_websocket_client_options::proxy_host, result, 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 1315 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, struct ast_websocket_client_options *  options  )

static

Definition at line 1838 of file res_http_websocket.c.

{
    enum ast_websocket_result res;
    int original_tls_enabled = ws->client->args->tls_cfg ? ws->client->args->tls_cfg->enabled : 0;
    int proxy = !ast_strlen_zero(ws->client->options->proxy_host);
    SCOPE_ENTER(2, "%s: proxy: %s  tls_enabled: %s\n", options->uri, S_OR(ws->client->options->proxy_host, "N/A"),
        AST_YESNO(original_tls_enabled));
 
 
    /* create and connect the client - note client_start
       releases the session instance on failure */
 
    if (proxy && original_tls_enabled ) {
        ast_trace(-1, "%s: Disabling TLS while handshaking with proxy\n", options->uri);
        if (ws->client->args->tls_cfg) {
            ws->client->args->tls_cfg->enabled = 0;
        }
    }
 
    ast_trace(-1, "%s: Creating tcptls client\n", options->uri);
    ws->client->ser = ast_tcptls_client_create(ws->client->args);
    if (!ws->client->ser) {
        SCOPE_EXIT_LOG_RTN_VALUE(WS_CLIENT_START_ERROR, LOG_ERROR, "%s: Unable to create tcptls client\n", options->uri);
    }
 
    ast_trace(-1, "%s: Connecting%s%s\n", options->uri, proxy ? " via proxy " : "", S_OR(ws->client->options->proxy_host, ""));
    if (!ast_tcptls_client_start_timeout(ws->client->ser, options->timeout)) {
        ws->client->ser = NULL;
        SCOPE_EXIT_LOG_RTN_VALUE(WS_CLIENT_START_ERROR, LOG_ERROR, "%s: Unable to connect%s%s\n", options->uri,
            proxy ? " via proxy " : "", S_OR(ws->client->options->proxy_host, ""));
    }
 
    ast_trace(-1, "%s: Connected%s%s\n", options->uri, proxy ? " via proxy " : "", S_OR(ws->client->options->proxy_host, ""));
    if (proxy) {
        res = websocket_proxy_handshake(ws->client);
        if (res != WS_OK) {
            ao2_ref(ws->client->ser, -1);
            ws->client->ser = NULL;
            SCOPE_EXIT_LOG_RTN_VALUE(res, LOG_ERROR, "%s: Unable to perform proxy handshake with %s\n", options->uri,
                ws->client->options->proxy_host);
        }
    }
 
    if (proxy && original_tls_enabled && !ws->client->args->tls_cfg->enabled) {
        int rc = 0;
        ast_trace(-1, "%s: Re-enabling TLS after handshaking with proxy %s\n", options->uri, ws->client->options->proxy_host);
        ws->client->args->tls_cfg->enabled = 1;
        rc = ast_ssl_setup_client(ws->client->args->tls_cfg);
        if (rc != 1) {
            ao2_cleanup(ws->client->ser);
            ws->client->ser = NULL;
            SCOPE_EXIT_LOG_RTN_VALUE(WS_TLS_ERROR, LOG_ERROR, "%s: TLS context setup failed after handshake with %s\n",
                options->uri, ws->client->options->proxy_host);
        }
        if (!ast_tcptls_start_tls(ws->client->ser)) {
            ws->client->ser = NULL;
            SCOPE_EXIT_LOG_RTN_VALUE(WS_TLS_ERROR, LOG_ERROR, "%s: TLS with websocket server failed after handshake with %s\n",
                options->uri, ws->client->options->proxy_host);
        }
    }
 
    if ((res = websocket_client_handshake(ws->client)) != WS_OK) {
        ao2_ref(ws->client->ser, -1);
        ws->client->ser = NULL;
        SCOPE_EXIT_LOG_RTN_VALUE(res, LOG_ERROR, "%s: Unable to perform websocket handshake\n", options->uri);
    }
 
    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);
 
    SCOPE_EXIT_RTN_VALUE(WS_OK, "%s: Handshake complete\n", options->uri);
}

References ao2_cleanup, ao2_ref, websocket_client::args, ast_iostream_get_ssl(), ast_sockaddr_copy(), ast_ssl_setup_client(), ast_strlen_zero(), ast_tcptls_client_create(), ast_tcptls_client_start_timeout(), ast_tcptls_start_tls(), ast_trace, AST_YESNO, ast_websocket::client, ast_tls_config::enabled, LOG_ERROR, NULL, websocket_client::options, options, ast_websocket_client_options::proxy_host, ast_tcptls_session_instance::remote_address, ast_websocket::remote_address, S_OR, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, ast_websocket::secure, websocket_client::ser, ast_tcptls_session_instance::stream, ast_websocket::stream, ast_tcptls_session_args::tls_cfg, websocket_client_handshake(), websocket_proxy_handshake(), WS_CLIENT_START_ERROR, WS_OK, and WS_TLS_ERROR.

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 1472 of file res_http_websocket.c.

{
    struct ast_websocket *ws = NULL;
 
    ast_debug(2, "%s: Creating client\n", options->uri);
 
    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;
    }
    ws->client->ping_sched_timer = -1;
 
    ws->client->options = client_options_clone(options);
    if (!ws->client->options) {
        ast_log(LOG_ERROR, "Unable to clone client options\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, 0)) {
        ao2_ref(ws, -1);
        *result = WS_URI_PARSE_ERROR;
        return NULL;
    }
    ast_debug(2, "%s: host: %s resource: %s userinfo: %s\n", options->uri, ws->client->host,
        ws->client->resource_name ? ast_str_buffer(ws->client->resource_name) : "",
        ws->client->userinfo);
 
    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 (!ast_strlen_zero(options->proxy_host)) {
        ast_debug(2, "%s: Proxy host: %s userinfo: %s\n", options->uri, ws->client->options->proxy_host,
            ws->client->proxy_userinfo);
 
        if (ast_strlen_zero(ws->client->proxy_userinfo)
            && !ast_strlen_zero(options->proxy_username)
            && !ast_strlen_zero(options->proxy_password)) {
            ast_asprintf(&ws->client->proxy_userinfo, "%s:%s", options->proxy_username,
                options->proxy_password);
        }
 
    }
 
    if (!(ws->client->args = websocket_client_args_create(ws, options, 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_debug, ast_log, ast_str_buffer(), ast_strdup, ast_strlen_zero(), ast_uuid_generate_str(), ast_websocket::client, client_options_clone(), DEFAULT_RECONSTRUCTION_CEILING, websocket_client::host, websocket_client::key, LOG_ERROR, NULL, ast_websocket::opcode, websocket_client::options, options, websocket_client::ping_sched_timer, websocket_client::protocols, ast_websocket_client_options::proxy_host, websocket_client::proxy_userinfo, 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 1371 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 1394 of file res_http_websocket.c.

{
    struct websocket_client *client = obj;
    char *id = ast_strdupa(client->options->uri);
    SCOPE_ENTER(2, "%s: Client destructor %p\n", id, obj);
 
    ao2_cleanup(client->options);
    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);
    ast_free(client->proxy_userinfo);
 
    SCOPE_EXIT_RTN("%s: Client destructor complete\n", id);
}

References websocket_client::accept_protocol, ao2_cleanup, websocket_client::args, ast_free, ast_strdupa, websocket_client::host, websocket_client::key, websocket_client::options, websocket_client::protocols, websocket_client::proxy_userinfo, websocket_client::resource_name, SCOPE_ENTER, SCOPE_EXIT_RTN, websocket_client::ser, ast_websocket_client_options::uri, 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, int  proxy  )

static

Definition at line 1569 of file res_http_websocket.c.

{
    if (response_code <= 0) {
        return WS_INVALID_RESPONSE;
    }
 
    switch (response_code) {
    case 101:
        if (!proxy) {
            return WS_OK;
        }
        break;
    case 200:
        if (proxy) {
            return WS_OK;
        }
        break;
    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, proxy ? client->options->proxy_host : client->host);
    }
    return WS_INVALID_RESPONSE;
}

References ast_log, ast_websocket::client, websocket_client::host, LOG_ERROR, websocket_client::options, ast_websocket_client_options::proxy_host, websocket_client::suppress_connection_msgs, WS_BAD_REQUEST, WS_INVALID_RESPONSE, WS_OK, 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 1788 of file res_http_websocket.c.

{
    size_t protocols_len = 0;
    struct ast_variable *auth_header = NULL;
    size_t res;
    SCOPE_ENTER(2, "%s: Handshaking with server\n", client->options->uri);
 
    if (!ast_strlen_zero(client->userinfo)) {
        auth_header = ast_http_create_basic_auth_header(client->userinfo, NULL);
        if (!auth_header) {
            SCOPE_EXIT_LOG_RTN_VALUE(WS_ALLOCATE_ERROR, LOG_ERROR, "Unable to allocate client websocket userinfo\n");
        }
    }
 
    protocols_len = client->protocols ? strlen(client->protocols) : 0;
 
    websocket_client_start_handshake_timer(client);
 
    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) {
        websocket_client_stop_handshake_timer(client);
        SCOPE_EXIT_LOG_RTN_VALUE(WS_WRITE_ERROR, LOG_ERROR, "Failed to send handshake\n");
    }
 
    /* wait for a response before doing anything else */
    res = websocket_client_handshake_get_response(client, 0);
    websocket_client_stop_handshake_timer(client);
 
    SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_websocket_result_to_str(res));
}

References ast_http_create_basic_auth_header(), ast_iostream_printf(), ast_str_buffer(), ast_strlen_zero(), ast_variables_destroy(), ast_websocket_result_to_str(), websocket_client::host, websocket_client::key, LOG_ERROR, NULL, optional_header_spec, websocket_client::options, print_optional_header, websocket_client::protocols, websocket_client::resource_name, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, websocket_client::ser, ast_tcptls_session_instance::stream, ast_websocket_client_options::uri, websocket_client::userinfo, ast_variable::value, websocket_client::version, websocket_client_handshake_get_response(), websocket_client_start_handshake_timer(), websocket_client_stop_handshake_timer(), 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, int  proxy  )

static

Definition at line 1614 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;
    int status_code = 0;
    SCOPE_ENTER(2, "%s: Proxy? %s  Proxy host: %s\n", client->options->uri, AST_YESNO(proxy),
        S_OR(client->options->proxy_host, "N/A"));
 
    while (ast_iostream_gets(client->ser->stream, buf, sizeof(buf)) <= 0) {
        SCOPE_EXIT_LOG_RTN_VALUE((errno == EINTR || errno == EAGAIN) ? WS_CLIENT_START_ERROR : WS_BAD_STATUS,
            LOG_ERROR, "%s: %s waiting for HTTP status line", client->options->uri,
            (errno == EINTR || errno == EAGAIN) ? "Timeout" : "Error");
    }
 
    status_code = ast_http_response_status_line(buf, "HTTP/1.1", 101);
    ast_trace(-1, "%s: Status code: %d\n", client->options->uri, status_code);
 
    res = websocket_client_handle_response_code(client, status_code, proxy);
    if (res != WS_OK) {
        SCOPE_EXIT_RTN_VALUE(res, "%s: HTTP status line result: %d/%s", client->options->uri,
            res, ast_websocket_result_to_str(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) {
                SCOPE_EXIT_LOG_RTN_VALUE((errno == EINTR || errno == EAGAIN) ? WS_CLIENT_START_ERROR : WS_BAD_STATUS,
                    LOG_ERROR, "%s: %s waiting for HTTP header", client->options->uri,
                    (errno == EINTR || errno == EAGAIN) ? "Timeout" : "Error");
            } else {
                ast_trace(-1, "%s: Blank line received\n", client->options->uri);
            }
            break;
        }
 
        parsed = ast_http_header_parse(buf, &name, &value);
        if (parsed < 0) {
            break;
        }
 
        if (proxy || parsed > 0) {
            continue;
        }
 
        if (!has_upgrade &&
            (has_upgrade = ast_http_header_match(
                name, "upgrade", value, "websocket")) < 0) {
            SCOPE_EXIT_RTN_VALUE(WS_HEADER_MISMATCH);
        } else if (!has_connection &&
               (has_connection = ast_http_header_match(
                   name, "connection", value, "upgrade")) < 0) {
            SCOPE_EXIT_RTN_VALUE(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) {
            SCOPE_EXIT_RTN_VALUE(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) {
                SCOPE_EXIT_RTN_VALUE(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");
            SCOPE_EXIT_RTN_VALUE(WS_NOT_SUPPORTED);
        }
    }
 
    if (status_code == 408) {
        res = WS_CLIENT_START_ERROR;
    } else {
        if (proxy) {
            res = WS_OK;
        } else {
            res = has_upgrade && has_connection && has_accept ?
                WS_OK : WS_HEADER_MISSING;
        }
    }
 
    SCOPE_EXIT_RTN_VALUE(res, "%s: Status code: %d\n", client->options->uri, status_code);
}

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, ast_trace, ast_websocket_result_to_str(), AST_YESNO, base64, buf, ast_websocket::client, errno, websocket_client::key, len(), LOG_ERROR, name, websocket_client::options, websocket_client::protocols, ast_websocket_client_options::proxy_host, S_OR, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, websocket_client::ser, ast_tcptls_session_instance::stream, ast_websocket_client_options::uri, value, websocket_client_handle_response_code(), websocket_combine_key(), WS_BAD_STATUS, WS_CLIENT_START_ERROR, WS_HEADER_MISMATCH, WS_HEADER_MISSING, WS_NOT_SUPPORTED, and WS_OK.

Referenced by websocket_client_handshake(), and websocket_proxy_handshake().

websocket_client_parse_uri()

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

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 1284 of file res_http_websocket.c.

{
    struct ast_uri *parsed_uri = proxy ? ast_uri_parse_http(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_http(), 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_client_start_handshake_timer()

static void websocket_client_start_handshake_timer ( struct websocket_client *  client )

static

Definition at line 1712 of file res_http_websocket.c.

{
    /*
     * ast_iostream_gets (called above in websocket_client_handshake_get_response) is
     * a blocking call which means that if the TCP/TLS connection succeeds but the remote doesn't
     * actually respond to the proxy CONNECT (if proxy is configured) or GET requests, the process
     * can hang indefinitely and escalate to a deadlock.  To get ast_iostream_gets to timeout,
     * we need to make the following 3 calls on the iostream.
     *
     * Since the write of the CONNECT and/or GET request is included in the timeout, we'll
     * double the timeout set in the websocket client's "connect_timeout" parameter to give
     * the server enough time to respond.
     */
    ast_iostream_nonblock(client->ser->stream);
    ast_iostream_set_exclusive_input(client->ser->stream, 1);
    ast_iostream_set_timeout_sequence(client->ser->stream, ast_tvnow(), client->options->timeout * 2);
}

References ast_iostream_nonblock(), ast_iostream_set_exclusive_input(), ast_iostream_set_timeout_sequence(), ast_tvnow(), ast_websocket::client, websocket_client::options, websocket_client::ser, ast_tcptls_session_instance::stream, and ast_websocket_client_options::timeout.

Referenced by websocket_client_handshake(), and websocket_proxy_handshake().

websocket_client_stop_handshake_timer()

static void websocket_client_stop_handshake_timer ( struct websocket_client *  client )

static

Definition at line 1730 of file res_http_websocket.c.

{
    /*
     * Once the handshake is complete, we need to undo what we did in
     * websocket_client_start_handshake_timer.
     */
    ast_iostream_set_timeout_disable(client->ser->stream);
    ast_iostream_set_exclusive_input(client->ser->stream, 0);
    ast_iostream_blocking(client->ser->stream);
}

References ast_iostream_blocking(), ast_iostream_set_exclusive_input(), ast_iostream_set_timeout_disable(), ast_websocket::client, websocket_client::ser, and ast_tcptls_session_instance::stream.

Referenced by websocket_client_handshake(), and websocket_proxy_handshake().

websocket_close()

static int websocket_close ( struct ast_websocket *  session, uint16_t  reason, int  force  )

static

Definition at line 421 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 = 0;
    int fd = session->stream ? ast_iostream_get_fd(session->stream) : -1;
    SCOPE_ENTER(2, "%s: Close requested.  Reason: %s (%d) Closed by: %s Force: %s\n", WS_SESSION_REMOTE(session),
        ast_websocket_status_to_str(reason), reason, closed_by_to_str(session->closed_by), AST_YESNO(force));
 
    ping_scheduler_cancel(session);
 
    ao2_lock(session);
    if (session->closing) {
        ao2_unlock(session);
        SCOPE_EXIT_RTN_VALUE(0, "%s: Close already sent\n", WS_SESSION_REMOTE(session));
    }
 
    session->closing = 1;
 
    if (!session->stream) {
        ao2_unlock(session);
        SCOPE_EXIT_RTN_VALUE(-1, "%s: WebSocket stream already closed\n", WS_SESSION_REMOTE(session));
    }
 
    if (force) {
        ast_trace(-1, "%s: Forcing close. Handle: %p FD: %d\n", WS_SESSION_REMOTE(session),
            session->stream, fd);
        ast_iostream_close(session->stream);
        session->stream = NULL;
        ao2_unlock(session);
        SCOPE_EXIT_RTN_VALUE(-1, "%s: Forced close\n", WS_SESSION_REMOTE(session));
    }
 
    /* clients need space for an additional 4 byte masking key */
    header_size = session->client ? 6 : 2;
    fsize = header_size + 2;
    session->close_sent = 1;
 
    frame[0] = opcode | 0x80;
    frame[1] = 2; /* The reason code is always 2 bytes */
 
    /*
     * If the remote initiated the close we should respond with the same
     * reason code they sent.
     */
    if (session->closed_by == WS_CLOSED_BY_REMOTE) {
        reason = session->close_status_code;
    }
 
    /* 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);
    ast_trace(-1, "%s: Writing %sCLOSE frame with reason %s (%d).  fd: %d\n", WS_SESSION_REMOTE(session),
        session->closed_by == WS_CLOSED_BY_REMOTE ? "reply " : "", ast_websocket_status_to_str(reason), reason, fd);
 
    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 the remote initiated the close or we failed to send,
     * we can close the socket.  If we just sent a CLOSE of our own, we need to wait
     * until we get the close reply from the remote.
     */
    if (session->closed_by == WS_CLOSED_BY_REMOTE || res != fsize) {
        ast_trace(-1, "%s: %s Closing socket.  fd: %d\n",
            session->closed_by == WS_CLOSED_BY_REMOTE ? "Wrote CLOSE reply." : "Writing CLOSE failed.",
            WS_SESSION_REMOTE(session), fd);
 
        ast_iostream_close(session->stream);
        session->stream = NULL;
        ao2_unlock(session);
        SCOPE_EXIT_RTN_VALUE(0, "%s: Socket closed after %s\n", WS_SESSION_REMOTE(session),
            session->closed_by == WS_CLOSED_BY_REMOTE ? "reply" : "write failure");
    }
 
    ao2_unlock(session);
    SCOPE_EXIT_RTN_VALUE(res == sizeof(frame), "%s: Close done\n", WS_SESSION_REMOTE(session));
}

References ao2_lock, ao2_unlock, ast_iostream_close(), ast_iostream_get_fd(), ast_iostream_set_timeout_disable(), ast_iostream_set_timeout_inactivity(), ast_iostream_write(), ast_trace, AST_WEBSOCKET_OPCODE_CLOSE, ast_websocket_status_to_str(), AST_YESNO, closed_by_to_str(), NULL, ping_scheduler_cancel(), put_unaligned_uint16(), SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, websocket_mask_payload(), WS_CLOSED_BY_REMOTE, and WS_SESSION_REMOTE.

Referenced by ast_websocket_close(), ast_websocket_write(), ping_scheduler_callback(), and websocket_handled_pong_or_close().

websocket_combine_key()

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

static

Definition at line 954 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 1197 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_handled_pong_or_close()

static int websocket_handled_pong_or_close ( struct ast_websocket *  session, char *  payload, uint64_t  payload_len, enum ast_websocket_opcode  opcode  )

static

Definition at line 504 of file res_http_websocket.c.

{
    SCOPE_ENTER(4, "%s: Opcode: %s\n", WS_SESSION_REMOTE(session), websocket_opcode2str(opcode));
 
    if (opcode == AST_WEBSOCKET_OPCODE_PONG) {
        /*
         * If it's from our own PING, reset the missed count.
         */
        if (session->client->missed_pong_count
            && payload_len == WS_PING_PAYLOAD_LEN
            && strncmp(payload, WS_PING_PAYLOAD, payload_len) == 0) {
            int mpc = session->client->missed_pong_count;
 
            session->client->missed_pong_count = 0;
            SCOPE_EXIT_RTN_VALUE(1, "%s: Received PONG from our own PING. Missed count was: %d.  Cleared.\n",
                WS_SESSION_REMOTE(session), mpc);
        } else {
            SCOPE_EXIT_RTN_VALUE(0, "%s: Received PONG.  Passing up to client.\n", WS_SESSION_REMOTE(session));
 
        }
    }
 
    if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
        if (payload_len >= 2) {
            session->close_status_code = ntohs(get_unaligned_uint16(payload));
        }
        if (session->closed_by == WS_NOT_CLOSED) {
            session->closed_by = WS_CLOSED_BY_REMOTE;
            SCOPE_EXIT_RTN_VALUE(1, "%s: Handled CLOSE request by remote with reason %s (%d)\n", WS_SESSION_REMOTE(session),
                ast_websocket_status_to_str(session->close_status_code), session->close_status_code);
        }
 
        ast_trace(-1, "%s: Received CLOSE response from remote with reason: %s (%d)\n",
                WS_SESSION_REMOTE(session), ast_websocket_status_to_str(session->close_status_code),
                session->close_status_code);
        /*
         * We got the close response so we can now clean up the socket.
         */
        websocket_close(session, session->close_status_code, 1);
 
 
        SCOPE_EXIT_RTN_VALUE(1, "%s: Handled CLOSE\n", WS_SESSION_REMOTE(session));
    }
 
    SCOPE_EXIT_RTN_VALUE(0, "%s: Unhandled %s opcode\n", WS_SESSION_REMOTE(session), websocket_opcode2str(opcode));
}

References ast_trace, AST_WEBSOCKET_OPCODE_CLOSE, AST_WEBSOCKET_OPCODE_PONG, ast_websocket_status_to_str(), get_unaligned_uint16(), SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, session, websocket_close(), websocket_opcode2str(), WS_CLOSED_BY_REMOTE, WS_NOT_CLOSED, WS_PING_PAYLOAD, WS_PING_PAYLOAD_LEN, and WS_SESSION_REMOTE.

Referenced by ast_websocket_read().

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 373 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_write(), and websocket_close().

websocket_opcode2str()

static const char * websocket_opcode2str ( enum ast_websocket_opcode  opcode )

static

Definition at line 400 of file res_http_websocket.c.

{
    if (!ARRAY_IN_BOUNDS(opcode, opcode_map)) {
        return "<unknown>";
    }
    return opcode_map[opcode];
}

References ARRAY_IN_BOUNDS, and opcode_map.

Referenced by ast_websocket_read(), ast_websocket_write(), and websocket_handled_pong_or_close().

websocket_proxy_handshake()

static enum ast_websocket_result websocket_proxy_handshake ( struct websocket_client *  client )

static

Definition at line 1747 of file res_http_websocket.c.

{
    struct ast_variable *auth_header = NULL;
    enum ast_websocket_result res = WS_OK;
    size_t bytes_written = 0;
    SCOPE_ENTER(2, "%s: Handshaking with proxy %s\n", client->options->uri, client->options->proxy_host);
 
    if (!ast_strlen_zero(client->proxy_userinfo)) {
        auth_header = ast_http_create_basic_auth_header(client->proxy_userinfo, NULL);
        if (!auth_header) {
            SCOPE_EXIT_LOG_RTN_VALUE(WS_ALLOCATE_ERROR, LOG_ERROR, "Unable to allocate client websocket userinfo\n");
        }
    }
 
    websocket_client_start_handshake_timer(client);
 
    bytes_written = ast_iostream_printf(client->ser->stream,
        "CONNECT %s HTTP/1.1\r\n"
        "Host: %s\r\n"
        optional_header_spec
        "Proxy-Connection: Keep-Alive\r\n"
        "\r\n",
        client->host,
        client->host,
        print_optional_header(auth_header, "Proxy-Authorization: ", auth_header->value)
    );
 
    ast_variables_destroy(auth_header);
    if (bytes_written < 0) {
        websocket_client_stop_handshake_timer(client);
        SCOPE_EXIT_LOG_RTN_VALUE(WS_WRITE_ERROR, LOG_ERROR, "Failed to send handshake\n");
    }
 
    /* wait for a response before doing anything else */
    res = websocket_client_handshake_get_response(client, 1);
    websocket_client_stop_handshake_timer(client);
 
    SCOPE_EXIT_RTN_VALUE(res, "%s\n", ast_websocket_result_to_str(res));
}

References ast_http_create_basic_auth_header(), ast_iostream_printf(), ast_strlen_zero(), ast_variables_destroy(), ast_websocket_result_to_str(), websocket_client::host, LOG_ERROR, NULL, optional_header_spec, websocket_client::options, print_optional_header, ast_websocket_client_options::proxy_host, websocket_client::proxy_userinfo, SCOPE_ENTER, SCOPE_EXIT_LOG_RTN_VALUE, SCOPE_EXIT_RTN_VALUE, websocket_client::ser, ast_tcptls_session_instance::stream, ast_websocket_client_options::uri, ast_variable::value, websocket_client_handshake_get_response(), websocket_client_start_handshake_timer(), websocket_client_stop_handshake_timer(), WS_ALLOCATE_ERROR, WS_OK, and WS_WRITE_ERROR.

Referenced by websocket_client_connect().

websocket_remove_protocol_internal()

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

static

Definition at line 1262 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 226 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 219 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 245 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 735 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 2219 of file res_http_websocket.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2219 of file res_http_websocket.c.

closed_by_str

const char* closed_by_str[]

static

Initial value:

= {
    [WS_NOT_CLOSED] = "not closed",
    [WS_CLOSED_BY_REMOTE] = "remote",
    [WS_CLOSED_BY_US] = "local"
}

Definition at line 153 of file res_http_websocket.c.

                                     {
    [WS_NOT_CLOSED] = "not closed",
    [WS_CLOSED_BY_REMOTE] = "remote",
    [WS_CLOSED_BY_US] = "local"
};

Referenced by closed_by_to_str().

opcode_map

const char* opcode_map[]

static

Definition at line 391 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().

ping_scheduler

struct ast_sched_context* ping_scheduler

static

Definition at line 90 of file res_http_websocket.c.

Referenced by ast_websocket_client_create_with_options(), load_module(), ping_scheduler_cancel(), and unload_module().

websocket_result_string_map

const char* websocket_result_string_map[]

Definition at line 2111 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().

websocket_status_map

const struct status_map websocket_status_map[]

static

Definition at line 2143 of file res_http_websocket.c.

                                                        {
    { AST_WEBSOCKET_STATUS_NORMAL, "Normal" },
    { AST_WEBSOCKET_STATUS_GOING_AWAY, "Going away" },
    { AST_WEBSOCKET_STATUS_PROTOCOL_ERROR, "Protocol error" },
    { AST_WEBSOCKET_STATUS_UNSUPPORTED_DATA, "Unsupported data" },
    { AST_WEBSOCKET_STATUS_RESERVED_1004, "reserved 1004" },
    { AST_WEBSOCKET_STATUS_RESERVED_1005, "reserved 1005" },
    { AST_WEBSOCKET_STATUS_RESERVED_1006, "reserved 1006" },
    { AST_WEBSOCKET_STATUS_INVALID_FRAME, "Invalid frame" },
    { AST_WEBSOCKET_STATUS_POLICY_VIOLATION, "Policy violation" },
    { AST_WEBSOCKET_STATUS_TOO_BIG, "Data too big" },
    { AST_WEBSOCKET_STATUS_MANDATORY_EXT, "Mandatory extension" },
    { AST_WEBSOCKET_STATUS_INTERNAL_ERROR, "Internal error" },
    { AST_WEBSOCKET_STATUS_RESERVED_1012, "reserved 1012" },
    { AST_WEBSOCKET_STATUS_RESERVED_1013, "reserved 1013" },
    { AST_WEBSOCKET_STATUS_BAD_GATEWAY, "Bad gateway" },
    { AST_WEBSOCKET_STATUS_RESERVED_1015, "reserved 1015" },
};

Referenced by ast_websocket_status_to_str().

websocketuri

struct ast_http_uri websocketuri

static

Definition at line 1187 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().