Asterisk - The Open Source Telephony Project GIT-master-f3e88d3
Data Structures | Macros | Functions | Variables
res_http_websocket.c File Reference

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

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/http.h"
#include "asterisk/astobj2.h"
#include "asterisk/strings.h"
#include "asterisk/file.h"
#include "asterisk/unaligned.h"
#include "asterisk/uri.h"
#include "asterisk/uuid.h"
#include "asterisk/http_websocket.h"
Include dependency graph for res_http_websocket.c:

Go to the source code of this file.

Data Structures

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

Macros

#define AST_API_MODULE
 
#define CLIENT_KEY_SIZE   16
 Length of a websocket's client key. More...
 
#define DEFAULT_RECONSTRUCTION_CEILING   MAXIMUM_FRAME_SIZE
 Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will start a payload. More...
 
#define MAX_PROTOCOL_BUCKETS   7
 Number of buckets for registered protocols. More...
 
#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 ... More...
 
#define MAXIMUM_FRAME_SIZE   65535
 Size of the pre-determined buffer for WebSocket frames. More...
 
#define MAXIMUM_RECONSTRUCTION_CEILING   MAXIMUM_FRAME_SIZE
 Maximum reconstruction size for multi-frame payload reconstruction. More...
 
#define MIN_WS_HDR_SZ   2
 
#define WEBSOCKET_GUID   "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
 GUID used to compute the accept key, defined in the specifications. More...
 

Functions

static void __reg_module (void)
 
static void __unreg_module (void)
 
struct ast_moduleAST_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. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_add_protocol2 (struct ast_websocket_protocol *protocol)
 Add a sub-protocol handler to the default /ws server. More...
 
const char *AST_OPTIONAL_API_NAME() ast_websocket_client_accept_protocol (struct ast_websocket *ws)
 Retrieve the server accepted sub-protocol on the client. More...
 
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. More...
 
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. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_close (struct ast_websocket *session, uint16_t reason)
 Close function for websocket session. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_fd (struct ast_websocket *session)
 Get the file descriptor for a WebSocket session. More...
 
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. More...
 
struct ast_sockaddr *AST_OPTIONAL_API_NAME() ast_websocket_local_address (struct ast_websocket *session)
 Get the local address for a WebSocket connection session. More...
 
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. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_read_string (struct ast_websocket *ws, char **buf)
 Read a WebSocket frame containing string data. More...
 
void AST_OPTIONAL_API_NAME() ast_websocket_reconstruct_disable (struct ast_websocket *session)
 Disable multi-frame reconstruction. More...
 
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. More...
 
void AST_OPTIONAL_API_NAME() ast_websocket_ref (struct ast_websocket *session)
 Increase the reference count for a WebSocket session. More...
 
struct ast_sockaddr *AST_OPTIONAL_API_NAME() ast_websocket_remote_address (struct ast_websocket *session)
 Get the remote address for a WebSocket connected session. More...
 
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. More...
 
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. More...
 
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. More...
 
struct ast_websocket_server *AST_OPTIONAL_API_NAME() ast_websocket_server_create (void)
 Creates a ast_websocket_server. More...
 
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. More...
 
const char *AST_OPTIONAL_API_NAME() ast_websocket_session_id (struct ast_websocket *session)
 Get the session ID for a WebSocket session. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_set_nonblock (struct ast_websocket *session)
 Set the socket of a WebSocket session to be non-blocking. More...
 
int AST_OPTIONAL_API_NAME() ast_websocket_set_timeout (struct ast_websocket *session, int timeout)
 Set the timeout on a non-blocking WebSocket session. More...
 
struct ast_websocket_protocol *AST_OPTIONAL_API_NAME() ast_websocket_sub_protocol_alloc (const char *name)
 Allocate a websocket sub-protocol instance. More...
 
void AST_OPTIONAL_API_NAME() ast_websocket_unref (struct ast_websocket *session)
 Decrease the reference count for a WebSocket session. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
static int load_module (void)
 
static struct ast_websocket_protocolone_protocol (struct ast_websocket_server *server)
 If the server has exactly one configured protocol, return it. More...
 
static int protocol_cmp_fn (void *obj, void *arg, int flags)
 Comparison function for protocols. More...
 
static void protocol_destroy_fn (void *obj)
 Destructor function for protocols. More...
 
static int protocol_hash_fn (const void *obj, const int flags)
 Hashing function for protocols. More...
 
static void session_destroy_fn (void *obj)
 Destructor function for sessions. More...
 
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_argswebsocket_client_args_create (const char *host, struct ast_tls_config *tls_cfg, enum ast_websocket_result *result)
 
static void websocket_client_args_destroy (void *obj)
 
static enum ast_websocket_result websocket_client_connect (struct ast_websocket *ws, int timeout)
 
static struct ast_websocketwebsocket_client_create (struct ast_websocket_client_options *options, enum ast_websocket_result *result)
 
static char * websocket_client_create_key (void)
 
static void websocket_client_destroy (void *obj)
 
static enum ast_websocket_result websocket_client_handle_response_code (struct websocket_client *client, int response_code)
 
static enum ast_websocket_result websocket_client_handshake (struct websocket_client *client)
 
static enum ast_websocket_result websocket_client_handshake_get_response (struct websocket_client *client)
 
static int websocket_client_parse_uri (const char *uri, char **host, struct ast_str **path)
 Parse the given uri into a path and remote address. More...
 
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. More...
 
static void websocket_mask_payload (struct ast_websocket *session, char *frame, char *payload, uint64_t payload_size)
 Perform payload masking for client sessions. More...
 
static const char * websocket_opcode2str (enum ast_websocket_opcode opcode)
 
static int websocket_remove_protocol_internal (const char *name, ast_websocket_callback callback)
 
static struct ast_websocket_serverwebsocket_server_create_impl (void)
 
static void websocket_server_dtor (void *obj)
 
static struct ast_websocket_serverwebsocket_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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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_infoast_module_info = &__mod_info
 
static const char * opcode_map []
 
static struct ast_http_uri websocketuri
 

Detailed Description

WebSocket support for the Asterisk internal HTTP server.

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

Definition in file res_http_websocket.c.

Macro Definition Documentation

◆ AST_API_MODULE

#define AST_API_MODULE

Definition at line 41 of file res_http_websocket.c.

◆ CLIENT_KEY_SIZE

#define CLIENT_KEY_SIZE   16

Length of a websocket's client key.

Definition at line 48 of file res_http_websocket.c.

◆ DEFAULT_RECONSTRUCTION_CEILING

#define DEFAULT_RECONSTRUCTION_CEILING   MAXIMUM_FRAME_SIZE

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

Definition at line 71 of file res_http_websocket.c.

◆ MAX_PROTOCOL_BUCKETS

#define MAX_PROTOCOL_BUCKETS   7

Number of buckets for registered protocols.

Definition at line 51 of file res_http_websocket.c.

◆ MAX_WS_HDR_SZ

#define MAX_WS_HDR_SZ   14

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

Definition at line 84 of file res_http_websocket.c.

◆ MAXIMUM_FRAME_SIZE

#define MAXIMUM_FRAME_SIZE   65535

Size of the pre-determined buffer for WebSocket frames.

Definition at line 66 of file res_http_websocket.c.

◆ MAXIMUM_RECONSTRUCTION_CEILING

#define MAXIMUM_RECONSTRUCTION_CEILING   MAXIMUM_FRAME_SIZE

Maximum reconstruction size for multi-frame payload reconstruction.

Definition at line 74 of file res_http_websocket.c.

◆ MIN_WS_HDR_SZ

#define MIN_WS_HDR_SZ   2

Definition at line 85 of file res_http_websocket.c.

◆ WEBSOCKET_GUID

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

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

Definition at line 45 of file res_http_websocket.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 1561 of file res_http_websocket.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 1561 of file res_http_websocket.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 1561 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
nameName of the sub-protocol to register
callbackCallback called when a new connection requesting the sub-protocol is established
Return values
0success
-1if sub-protocol handler could not be registered

Definition at line 1052 of file res_http_websocket.c.

1053{
1054 return websocket_add_protocol_internal(name, callback);
1055}
static const char name[]
Definition: format_mp3.c:68
static int websocket_add_protocol_internal(const char *name, ast_websocket_callback callback)

References 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
protocolThe 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
0success
-1if sub-protocol handler could not be registered
Since
13.5.0

Definition at line 1057 of file res_http_websocket.c.

1058{
1059 struct ast_websocket_server *ws_server = websocketuri.data;
1060
1061 if (!ws_server) {
1062 return -1;
1063 }
1064
1065 if (ast_websocket_server_add_protocol2(ws_server, protocol)) {
1066 return -1;
1067 }
1068
1069 return 0;
1070}
static struct ast_http_uri websocketuri
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.
void * data
Definition: http.h:116
Structure for a WebSocket server.

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
wsthe websocket client
Returns
the accepted client sub-protocol.
Since
13

Definition at line 1275 of file res_http_websocket.c.

1277{
1278 return ws->client->accept_protocol;
1279}
struct websocket_client * 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
uriuri to connect to
protocolsa comma separated string of supported protocols
tls_cfgsecure websocket credentials
resultresult code set on client failure
Returns
a client websocket.
Return values
NULLif object could not be created or connected
Since
13

Definition at line 1440 of file res_http_websocket.c.

1443{
1445 .uri = uri,
1446 .protocols = protocols,
1447 .timeout = -1,
1448 .tls_cfg = tls_cfg,
1449 };
1450
1452}
static PGresult * result
Definition: cel_pgsql.c:84
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.
Options used for a websocket client.
struct ast_tls_config * tls_cfg
static struct test_options options

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_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
optionsWebsocket client options
resultresult code set on client failure
Returns
a client websocket.
Return values
NULLif object could not be created or connected

Definition at line 1454 of file res_http_websocket.c.

1456{
1458
1459 if (!ws) {
1460 return NULL;
1461 }
1462
1463 if ((*result = websocket_client_connect(ws, options->timeout)) != WS_OK) {
1464 ao2_ref(ws, -1);
1465 return NULL;
1466 }
1467
1468 return ws;
1469}
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
@ WS_OK
static enum ast_websocket_result websocket_client_connect(struct ast_websocket *ws, int timeout)
static struct ast_websocket * websocket_client_create(struct ast_websocket_client_options *options, enum ast_websocket_result *result)
#define NULL
Definition: resample.c:96
Structure definition for session.

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

Referenced by 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 308 of file res_http_websocket.c.

309{
311 /* The header is either 2 or 6 bytes and the
312 * reason code takes up another 2 bytes */
313 char frame[8] = { 0, };
314 int header_size, fsize, res;
315
316 if (session->close_sent) {
317 return 0;
318 }
319
320 /* clients need space for an additional 4 byte masking key */
321 header_size = session->client ? 6 : 2;
322 fsize = header_size + 2;
323
324 frame[0] = opcode | 0x80;
325 frame[1] = 2; /* The reason code is always 2 bytes */
326
327 /* If no reason has been specified assume 1000 which is normal closure */
328 put_unaligned_uint16(&frame[header_size], htons(reason ? reason : 1000));
329
330 websocket_mask_payload(session, frame, &frame[header_size], 2);
331
332 session->closing = 1;
333 session->close_sent = 1;
334
337 res = ast_iostream_write(session->stream, frame, fsize);
339
340 /* If an error occurred when trying to close this connection explicitly terminate it now.
341 * Doing so will cause the thread polling on it to wake up and terminate.
342 */
343 if (res != fsize) {
345 session->stream = NULL;
346 ast_verb(2, "WebSocket connection %s '%s' forcefully closed due to fatal write error\n",
347 session->client ? "to" : "from", ast_sockaddr_stringify(&session->remote_address));
348 }
349
351 return res == sizeof(frame);
352}
static struct ast_mansession session
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
ast_websocket_opcode
WebSocket operation codes.
@ AST_WEBSOCKET_OPCODE_CLOSE
#define ast_verb(level,...)
void ast_iostream_set_timeout_inactivity(struct ast_iostream *stream, int timeout)
Set the iostream inactivity timeout timer.
Definition: iostream.c:122
ssize_t ast_iostream_write(struct ast_iostream *stream, const void *buffer, size_t count)
Write data to an iostream.
Definition: iostream.c:385
int ast_iostream_close(struct ast_iostream *stream)
Close an iostream.
Definition: iostream.c:539
void ast_iostream_set_timeout_disable(struct ast_iostream *stream)
Disable the iostream timeout timer.
Definition: iostream.c:114
static char * ast_sockaddr_stringify(const struct ast_sockaddr *addr)
Wrapper around ast_sockaddr_stringify_fmt() with default format.
Definition: netsock2.h:256
static void websocket_mask_payload(struct ast_websocket *session, char *frame, char *payload, uint64_t payload_size)
Perform payload masking for client sessions.
static void put_unaligned_uint16(void *p, unsigned short datum)
Definition: unaligned.h:65

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

Referenced by ast_websocket_read(), ast_websocket_write(), session_destroy_fn(), 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 461 of file res_http_websocket.c.

462{
463 return session->closing ? -1 : ast_iostream_get_fd(session->stream);
464}
int ast_iostream_get_fd(struct ast_iostream *stream)
Get an iostream's file descriptor.
Definition: iostream.c:85

References ast_iostream_get_fd(), and session.

Referenced by ast_ari_websocket_session_read(), speech_test_server_cb(), websocket_echo_callback(), websocket_read(), and ws_shutdown().

◆ ast_websocket_is_secure()

int AST_OPTIONAL_API_NAME() ast_websocket_is_secure ( struct ast_websocket session)

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

Return values
0if unsecure
1if secure

Definition at line 481 of file res_http_websocket.c.

482{
483 return session->secure;
484}

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

477{
478 return &session->local_address;
479}

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
sessionPointer to the WebSocket session
payloadPointer to a char* which will be populated with a pointer to the payload if present
payload_lenPointer to a uint64_t which will be populated with the length of the payload if present
opcodePointer to an enum which will be populated with the opcode of the frame
fragmentedPointer to an int which is set to 1 if payload is fragmented and 0 if not
Return values
-1on error
0on success
Note
Once an AST_WEBSOCKET_OPCODE_CLOSE opcode is received the socket will be closed

Definition at line 602 of file res_http_websocket.c.

603{
604 int fin = 0;
605 int mask_present = 0;
606 char *mask = NULL, *new_payload = NULL;
607 size_t options_len = 0, frame_size = 0;
608
609 *payload = NULL;
610 *payload_len = 0;
611 *fragmented = 0;
612
613 if (ws_safe_read(session, &session->buf[0], MIN_WS_HDR_SZ, opcode)) {
614 return -1;
615 }
617
618 /* 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) */
619 *opcode = session->buf[0] & 0xf;
620 *payload_len = session->buf[1] & 0x7f;
623 fin = (session->buf[0] >> 7) & 1;
624 mask_present = (session->buf[1] >> 7) & 1;
625
626 /* Based on the mask flag and payload length, determine how much more we need to read before start parsing the rest of the header */
627 options_len += mask_present ? 4 : 0;
628 options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
629 if (options_len) {
630 /* read the rest of the header options */
631 if (ws_safe_read(session, &session->buf[frame_size], options_len, opcode)) {
632 return -1;
633 }
634 frame_size += options_len;
635 }
636
637 if (*payload_len == 126) {
638 /* Grab the 2-byte payload length */
639 *payload_len = ntohs(get_unaligned_uint16(&session->buf[2]));
640 mask = &session->buf[4];
641 } else if (*payload_len == 127) {
642 /* Grab the 8-byte payload length */
643 *payload_len = ntohll(get_unaligned_uint64(&session->buf[2]));
644 mask = &session->buf[10];
645 } else {
646 /* Just set the mask after the small 2-byte header */
647 mask = &session->buf[2];
648 }
649
650 /* Now read the rest of the payload */
651 *payload = &session->buf[frame_size]; /* payload will start here, at the end of the options, if any */
652 frame_size = frame_size + (*payload_len); /* final frame size is header + optional headers + payload data */
654 ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zu bytes\n", frame_size);
655 /* The frame won't fit :-( */
657 return -1;
658 }
659
660 if (*payload_len) {
661 if (ws_safe_read(session, *payload, *payload_len, opcode)) {
662 return -1;
663 }
664 }
665
666 /* If a mask is present unmask the payload */
667 if (mask_present) {
668 unsigned int pos;
669 for (pos = 0; pos < *payload_len; pos++) {
670 (*payload)[pos] ^= mask[pos % 4];
671 }
672 }
673
674 /* Per the RFC for PING we need to send back an opcode with the application data as received */
675 if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
676 if (ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len)) {
678 }
679 *payload_len = 0;
680 return 0;
681 }
682
683 /* Stop PONG processing here */
684 if (*opcode == AST_WEBSOCKET_OPCODE_PONG) {
685 *payload_len = 0;
686 return 0;
687 }
688
689 /* Save the CLOSE status code which will be sent in our own CLOSE in the destructor */
690 if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
691 session->closing = 1;
692 if (*payload_len >= 2) {
693 session->close_status_code = ntohs(get_unaligned_uint16(*payload));
694 }
695 *payload_len = 0;
696 return 0;
697 }
698
699 /* Below this point we are handling TEXT, BINARY or CONTINUATION opcodes */
700 if (*payload_len) {
701 if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
702 ast_log(LOG_WARNING, "Failed allocation: %p, %zu, %"PRIu64"\n",
703 session->payload, session->payload_len, *payload_len);
704 *payload_len = 0;
706 return -1;
707 }
708
709 session->payload = new_payload;
710 memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
711 session->payload_len += *payload_len;
712 } else if (!session->payload_len && session->payload) {
713 ast_free(session->payload);
714 session->payload = NULL;
715 }
716
717 if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
718 /* If this is not a final message we need to defer returning it until later */
719 if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
720 session->opcode = *opcode;
721 }
723 *payload_len = 0;
724 *payload = NULL;
725 } else {
726 if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
727 if (!fin) {
728 /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
729 *fragmented = 1;
730 } else {
731 /* Final frame in multi-frame so push up the actual opcode */
732 *opcode = session->opcode;
733 }
734 }
735 *payload_len = session->payload_len;
736 *payload = session->payload;
737 session->payload_len = 0;
738 }
739 } else {
740 ast_log(LOG_WARNING, "WebSocket unknown opcode %u\n", *opcode);
741 /* 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
742 * fit that, I think. */
744 }
745
746 return 0;
747}
#define ast_free(a)
Definition: astmm.h:180
#define ast_realloc(p, len)
A wrapper for realloc()
Definition: astmm.h:226
#define ast_log
Definition: astobj2.c:42
static int frame_size[4]
Definition: format_g726.c:52
@ AST_WEBSOCKET_OPCODE_PING
@ AST_WEBSOCKET_OPCODE_PONG
@ AST_WEBSOCKET_OPCODE_CONTINUATION
@ AST_WEBSOCKET_OPCODE_BINARY
@ AST_WEBSOCKET_OPCODE_TEXT
uint64_t ntohll(uint64_t net64)
Definition: strcompat.c:364
#define LOG_WARNING
#define MAXIMUM_FRAME_SIZE
Size of the pre-determined buffer for WebSocket frames.
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.
#define MIN_WS_HDR_SZ
static int ws_safe_read(struct ast_websocket *session, char *buf, size_t len, enum ast_websocket_opcode *opcode)
int AST_OPTIONAL_API_NAME() ast_websocket_close(struct ast_websocket *session, uint16_t reason)
Close function for websocket session.
static unsigned short get_unaligned_uint16(const void *p)
Definition: unaligned.h:44
static uint64_t get_unaligned_uint64(const void *p)
Definition: unaligned.h:32

References ast_free, ast_log, ast_realloc, ast_websocket_close(), 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, MAXIMUM_FRAME_SIZE, MIN_WS_HDR_SZ, ntohll(), NULL, ast_websocket::opcode, ast_websocket::payload, ast_websocket::payload_len, session, and ws_safe_read().

Referenced by ast_ari_websocket_session_read(), ast_websocket_read_string(), 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
wspointer to the websocket
bufstring buffer to populate with data read from socket
Return values
-1on 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 1471 of file res_http_websocket.c.

1473{
1474 char *payload;
1475 uint64_t payload_len;
1476 enum ast_websocket_opcode opcode;
1477 int fragmented = 1;
1478
1479 while (fragmented) {
1480 if (ast_websocket_read(ws, &payload, &payload_len,
1481 &opcode, &fragmented)) {
1482 ast_log(LOG_ERROR, "Client WebSocket string read - "
1483 "error reading string data\n");
1484 return -1;
1485 }
1486
1487 if (opcode == AST_WEBSOCKET_OPCODE_PING) {
1488 /* Try read again, we have sent pong already */
1489 fragmented = 1;
1490 continue;
1491 }
1492
1493 if (opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
1494 continue;
1495 }
1496
1497 if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
1498 return -1;
1499 }
1500
1501 if (opcode != AST_WEBSOCKET_OPCODE_TEXT) {
1502 ast_log(LOG_ERROR, "Client WebSocket string read - "
1503 "non string data received\n");
1504 return -1;
1505 }
1506 }
1507
1508 if (!(*buf = ast_strndup(payload, payload_len))) {
1509 return -1;
1510 }
1511
1512 return payload_len + 1;
1513}
#define ast_strndup(str, len)
A wrapper for strndup()
Definition: astmm.h:256
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
#define LOG_ERROR
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.

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

447{
448 session->reconstruct = 0;
449}

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
sessionPointer to the WebSocket session
bytesIf 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 441 of file res_http_websocket.c.

442{
443 session->reconstruct = MIN(bytes, MAXIMUM_RECONSTRUCTION_CEILING);
444}
#define MAXIMUM_RECONSTRUCTION_CEILING
Maximum reconstruction size for multi-frame payload reconstruction.
#define MIN(a, b)
Definition: utils.h:231

References MAXIMUM_RECONSTRUCTION_CEILING, MIN, and session.

◆ ast_websocket_ref()

void AST_OPTIONAL_API_NAME() ast_websocket_ref ( struct ast_websocket session)

Increase the reference count for a WebSocket session.

Parameters
sessionPointer to the WebSocket session

Definition at line 451 of file res_http_websocket.c.

452{
453 ao2_ref(session, +1);
454}

References ao2_ref, and session.

Referenced by transport_create().

◆ ast_websocket_remote_address()

struct ast_sockaddr *AST_OPTIONAL_API_NAME() ast_websocket_remote_address ( struct ast_websocket session)

Get the remote address for a WebSocket connected session.

Returns
Remote address

Definition at line 471 of file res_http_websocket.c.

472{
473 return &session->remote_address;
474}

References session.

Referenced by ast_ari_websocket_session_get_remote_addr(), transport_create(), and transport_read().

◆ 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
nameName of the sub-protocol to unregister
callbackSession Established callback that was previously registered with the sub-protocol
Return values
0success
-1if sub-protocol was not found or if callback did not match

Definition at line 1081 of file res_http_websocket.c.

1082{
1083 return websocket_remove_protocol_internal(name, callback);
1084}
static int websocket_remove_protocol_internal(const char *name, ast_websocket_callback callback)

References name, and websocket_remove_protocol_internal().

Referenced by AST_TEST_DEFINE(), and unload_module().

◆ 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
serverThe server to add the sub-protocol to
nameName of the sub-protocol to register
callbackCallback called when a new connection requesting the sub-protocol is established
Return values
0success
-1if sub-protocol handler could not be registered
Since
12

Definition at line 210 of file res_http_websocket.c.

211{
212 struct ast_websocket_protocol *protocol;
213
214 if (!server->protocols) {
215 return -1;
216 }
217
219 if (!protocol) {
220 return -1;
221 }
222 protocol->session_established = callback;
223
224 if (ast_websocket_server_add_protocol2(server, protocol)) {
225 ao2_ref(protocol, -1);
226 return -1;
227 }
228
229 return 0;
230}
struct ast_websocket_protocol *AST_OPTIONAL_API_NAME() ast_websocket_sub_protocol_alloc(const char *name)
Allocate a websocket sub-protocol instance.
A websocket protocol implementation.
ast_websocket_callback session_established
Callback called when a new session is established. Mandatory.
struct ao2_container * protocols

References ao2_ref, ast_websocket_server_add_protocol2(), ast_websocket_sub_protocol_alloc(), 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
serverThe server to add the sub-protocol to.
protocolThe 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
0success
-1if sub-protocol handler could not be registered
Since
13.5.0

Definition at line 232 of file res_http_websocket.c.

233{
234 struct ast_websocket_protocol *existing;
235
236 if (!server->protocols) {
237 return -1;
238 }
239
240 if (protocol->version != AST_WEBSOCKET_PROTOCOL_VERSION) {
241 ast_log(LOG_WARNING, "WebSocket could not register sub-protocol '%s': "
242 "expected version '%u', got version '%u'\n",
243 protocol->name, AST_WEBSOCKET_PROTOCOL_VERSION, protocol->version);
244 return -1;
245 }
246
247 ao2_lock(server->protocols);
248
249 /* Ensure a second protocol handler is not registered for the same protocol */
250 existing = ao2_find(server->protocols, protocol->name, OBJ_KEY | OBJ_NOLOCK);
251 if (existing) {
252 ao2_ref(existing, -1);
253 ao2_unlock(server->protocols);
254 return -1;
255 }
256
257 ao2_link_flags(server->protocols, protocol, OBJ_NOLOCK);
258 ao2_unlock(server->protocols);
259
260 ast_verb(5, "WebSocket registered sub-protocol '%s'\n", protocol->name);
261 ao2_ref(protocol, -1);
262
263 return 0;
264}
#define OBJ_KEY
Definition: astobj2.h:1151
#define ao2_link_flags(container, obj, flags)
Add an object to a container.
Definition: astobj2.h:1554
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition: astobj2.h:1063
#define AST_WEBSOCKET_PROTOCOL_VERSION
Protocol version. This prevents dynamically loadable modules from registering if this struct is chang...
unsigned int version
Protocol version. Should be set to /ref AST_WEBSOCKET_PROTOCOL_VERSION.
char * name
Name of the protocol.

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

Referenced by 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
NULLon error
Since
12

Definition at line 167 of file res_http_websocket.c.

168{
170}
static struct ast_websocket_server * websocket_server_create_impl(void)

References websocket_server_create_impl().

Referenced by 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
serverThe server to unregister the sub-protocol from
nameName of the sub-protocol to unregister
callbackCallback that was previously registered with the sub-protocol
Return values
0success
-1if sub-protocol was not found or if callback did not match
Since
12

Definition at line 266 of file res_http_websocket.c.

267{
268 struct ast_websocket_protocol *protocol;
269
270 if (!(protocol = ao2_find(server->protocols, name, OBJ_KEY))) {
271 return -1;
272 }
273
274 if (protocol->session_established != callback) {
275 ao2_ref(protocol, -1);
276 return -1;
277 }
278
279 ao2_unlink(server->protocols, protocol);
280 ao2_ref(protocol, -1);
281
282 ast_verb(5, "WebSocket unregistered sub-protocol '%s'\n", name);
283
284 return 0;
285}
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578

References ao2_find, ao2_ref, ao2_unlink, ast_verb, 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 500 of file res_http_websocket.c.

501{
502 return session->session_id;
503}

References session.

Referenced by ast_ari_websocket_session_id().

◆ 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
0on success
-1on failure

Definition at line 486 of file res_http_websocket.c.

487{
490 return 0;
491}
void ast_iostream_set_exclusive_input(struct ast_iostream *stream, int exclusive_input)
Set the iostream if it can exclusively depend upon the set timeouts.
Definition: iostream.c:149
void ast_iostream_nonblock(struct ast_iostream *stream)
Make an iostream non-blocking.
Definition: iostream.c:104

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

Referenced by ast_ari_websocket_session_create(), 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
0on success
-1on failure

Definition at line 493 of file res_http_websocket.c.

494{
495 session->timeout = timeout;
496
497 return 0;
498}

References session, and ast_websocket::timeout.

Referenced by ast_ari_websocket_session_create(), and websocket_cb().

◆ ast_websocket_sub_protocol_alloc()

struct ast_websocket_protocol *AST_OPTIONAL_API_NAME() ast_websocket_sub_protocol_alloc ( const char *  name)

Allocate a websocket sub-protocol instance.

Returns
An instance of ast_websocket_protocol on success
Return values
NULLon error
Since
13.5.0

Definition at line 191 of file res_http_websocket.c.

192{
193 struct ast_websocket_protocol *protocol;
194
195 protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn);
196 if (!protocol) {
197 return NULL;
198 }
199
200 protocol->name = ast_strdup(name);
201 if (!protocol->name) {
202 ao2_ref(protocol, -1);
203 return NULL;
204 }
206
207 return protocol;
208}
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
static void protocol_destroy_fn(void *obj)
Destructor function for protocols.

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 ast_websocket_server_add_protocol(), and load_module().

◆ ast_websocket_unref()

void AST_OPTIONAL_API_NAME() ast_websocket_unref ( struct ast_websocket session)

Decrease the reference count for a WebSocket session.

Parameters
sessionPointer to the WebSocket session

Definition at line 456 of file res_http_websocket.c.

457{
459}
#define ao2_cleanup(obj)
Definition: astobj2.h:1934

References ao2_cleanup, and session.

Referenced by ast_ari_events_event_websocket_ws_established_cb(), speech_test_server_cb(), transport_dtor(), websocket_cb(), websocket_disconnect(), websocket_echo_callback(), and websocket_session_dtor().

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

791{
792 struct ast_variable *v;
793 const char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL;
794 char *requested_protocols = NULL, *protocol = NULL;
795 int version = 0, flags = 1;
796 struct ast_websocket_protocol *protocol_handler = NULL;
797 struct ast_websocket *session;
798 struct ast_websocket_server *server;
799
801
802 /* Upgrade requests are only permitted on GET methods */
803 if (method != AST_HTTP_GET) {
804 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
805 return 0;
806 }
807
808 server = urih->data;
809
810 /* Get the minimum headers required to satisfy our needs */
811 for (v = headers; v; v = v->next) {
812 if (!strcasecmp(v->name, "Upgrade")) {
813 upgrade = v->value;
814 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
815 key = v->value;
816 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
817 key1 = v->value;
818 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
819 key2 = v->value;
820 } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
821 protos = v->value;
822 } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
823 if (sscanf(v->value, "%30d", &version) != 1) {
824 version = 0;
825 }
826 }
827 }
828
829 /* If this is not a websocket upgrade abort */
830 if (!upgrade || strcasecmp(upgrade, "websocket")) {
831 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
833 ast_http_error(ser, 426, "Upgrade Required", NULL);
834 return 0;
835 } else if (ast_strlen_zero(protos)) {
836 /* If there's only a single protocol registered, and the
837 * client doesn't specify what protocol it's using, go ahead
838 * and accept the connection */
839 protocol_handler = one_protocol(server);
840 if (!protocol_handler) {
841 /* Multiple registered subprotocols; client must specify */
842 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
845 return 0;
846 }
847 } else if (key1 && key2) {
848 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
849 * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
850 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
853 return 0;
854 }
855
856 if (!protocol_handler && protos) {
857 requested_protocols = ast_strdupa(protos);
858 /* Iterate through the requested protocols trying to find one that we have a handler for */
859 while (!protocol_handler && (protocol = strsep(&requested_protocols, ","))) {
860 protocol_handler = ao2_find(server->protocols, ast_strip(protocol), OBJ_KEY);
861 }
862 }
863
864 /* If no protocol handler exists bump this back to the requester */
865 if (!protocol_handler) {
866 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
869 return 0;
870 }
871
872 /* Determine how to respond depending on the version */
873 if (version == 7 || version == 8 || version == 13) {
874 char base64[64];
875
876 if (!key || strlen(key) + strlen(WEBSOCKET_GUID) + 1 > 8192) { /* no stack overflows please */
878 ao2_ref(protocol_handler, -1);
879 return 0;
880 }
881
882 if (ast_http_body_discard(ser)) {
884 ao2_ref(protocol_handler, -1);
885 return 0;
886 }
887
888 if (!(session = ao2_alloc(sizeof(*session) + AST_UUID_STR_LEN + 1, session_destroy_fn))) {
889 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
892 ao2_ref(protocol_handler, -1);
893 return 0;
894 }
896
897 /* Generate the session id */
898 if (!ast_uuid_generate_str(session->session_id, sizeof(session->session_id))) {
899 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to generate a session id\n",
901 ast_http_error(ser, 500, "Internal Server Error", "Allocation failed");
902 ao2_ref(protocol_handler, -1);
903 return 0;
904 }
905
906 if (protocol_handler->session_attempted
907 && protocol_handler->session_attempted(ser, get_vars, headers, session->session_id)) {
908 ast_debug(3, "WebSocket connection from '%s' rejected by protocol handler '%s'\n",
909 ast_sockaddr_stringify(&ser->remote_address), protocol_handler->name);
911 ao2_ref(protocol_handler, -1);
912 return 0;
913 }
914
915 /* RFC 6455, Section 4.1:
916 *
917 * 6. If the response includes a |Sec-WebSocket-Protocol| header
918 * field and this header field indicates the use of a
919 * subprotocol that was not present in the client's handshake
920 * (the server has indicated a subprotocol not requested by
921 * the client), the client MUST _Fail the WebSocket
922 * Connection_.
923 */
924 if (protocol) {
926 "HTTP/1.1 101 Switching Protocols\r\n"
927 "Upgrade: %s\r\n"
928 "Connection: Upgrade\r\n"
929 "Sec-WebSocket-Accept: %s\r\n"
930 "Sec-WebSocket-Protocol: %s\r\n\r\n",
931 upgrade,
932 websocket_combine_key(key, base64, sizeof(base64)),
933 protocol);
934 } else {
936 "HTTP/1.1 101 Switching Protocols\r\n"
937 "Upgrade: %s\r\n"
938 "Connection: Upgrade\r\n"
939 "Sec-WebSocket-Accept: %s\r\n\r\n",
940 upgrade,
941 websocket_combine_key(key, base64, sizeof(base64)));
942 }
943 } else {
944
945 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
946 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
949 ao2_ref(protocol_handler, -1);
950 return 0;
951 }
952
953 /* Enable keepalive on all sessions so the underlying user does not have to */
954 if (setsockopt(ast_iostream_get_fd(ser->stream), SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
955 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
958 ao2_ref(session, -1);
959 ao2_ref(protocol_handler, -1);
960 return 0;
961 }
962
963 /* Get our local address for the connected socket */
964 if (ast_getsockname(ast_iostream_get_fd(ser->stream), &session->local_address)) {
965 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to get local address\n",
968 ao2_ref(session, -1);
969 ao2_ref(protocol_handler, -1);
970 return 0;
971 }
972
973 ast_verb(2, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol ? : "", version);
974
975 /* Populate the session with all the needed details */
976 session->stream = ser->stream;
977 ast_sockaddr_copy(&session->remote_address, &ser->remote_address);
978 session->opcode = -1;
980 session->secure = ast_iostream_get_ssl(ser->stream) ? 1 : 0;
981
982 /* Give up ownership of the socket and pass it to the protocol handler */
984 protocol_handler->session_established(session, get_vars, headers);
985 ao2_ref(protocol_handler, -1);
986
987 /*
988 * By dropping the stream from the session the connection
989 * won't get closed when the HTTP server cleans up because we
990 * passed the connection to the protocol handler.
991 */
992 ser->stream = NULL;
993
994 return 0;
995}
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
static char version[AST_MAX_EXTENSION]
Definition: chan_ooh323.c:391
@ AST_HTTP_GET
Definition: http.h:60
int ast_http_body_discard(struct ast_tcptls_session_instance *ser)
Read and discard any unread HTTP request body.
Definition: http.c:1122
void ast_http_error(struct ast_tcptls_session_instance *ser, int status, const char *title, const char *text)
Send HTTP error message and close socket.
Definition: http.c:651
#define AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT
Default websocket write timeout, in ms.
char * strsep(char **str, const char *delims)
#define ast_debug(level,...)
Log a DEBUG message.
ssize_t ast_iostream_printf(struct ast_iostream *stream, const char *format,...)
Write a formatted string to an iostream.
Definition: iostream.c:502
SSL * ast_iostream_get_ssl(struct ast_iostream *stream)
Get a pointer to an iostream's OpenSSL SSL structure.
Definition: iostream.c:109
#define SCOPED_MODULE_USE(module)
Definition: module.h:679
int ast_getsockname(int sockfd, struct ast_sockaddr *addr)
Wrapper around getsockname(2) that uses struct ast_sockaddr.
Definition: netsock2.c:600
static void ast_sockaddr_copy(struct ast_sockaddr *dst, const struct ast_sockaddr *src)
Copies the data from one ast_sockaddr to another.
Definition: netsock2.h:167
static void websocket_bad_request(struct ast_tcptls_session_instance *ser)
static struct ast_websocket_protocol * one_protocol(struct ast_websocket_server *server)
If the server has exactly one configured protocol, return it.
#define DEFAULT_RECONSTRUCTION_CEILING
Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will s...
static char * websocket_combine_key(const char *key, char *res, int res_size)
#define WEBSOCKET_GUID
GUID used to compute the accept key, defined in the specifications.
static void session_destroy_fn(void *obj)
Destructor function for sessions.
const char * method
Definition: res_pjsip.c:1279
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition: strings.h:223
struct ast_module * self
Definition: module.h:356
struct ast_iostream * stream
Definition: tcptls.h:161
struct ast_sockaddr remote_address
Definition: tcptls.h:152
Structure for variables, used for configurations and for channel variables.
struct ast_variable * next
ast_websocket_pre_callback session_attempted
Callback called when a new session is attempted. Optional.
static char base64[64]
Definition: utils.c:80
#define AST_UUID_STR_LEN
Definition: uuid.h:27
char * ast_uuid_generate_str(char *buf, size_t size)
Generate a UUID string.
Definition: uuid.c:141

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, ast_verb, 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(), 210693f3123d_create_cdr_table::upgrade(), ast_variable::value, version, websocket_bad_request(), websocket_combine_key(), and WEBSOCKET_GUID.

Referenced by ari_handle_websocket().

◆ 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
sessionPointer to the WebSocket session
timeoutthe number of milliseconds to wait
Return values
-1if error occurred
0if the timeout expired
1if the WebSocket session is ready for reading

Definition at line 466 of file res_http_websocket.c.

467{
468 return session->closing ? -1 : ast_iostream_wait_for_input(session->stream, timeout);
469}
int ast_iostream_wait_for_input(struct ast_iostream *stream, int timeout)
Wait for input on the iostream's file descriptor.
Definition: iostream.c:90

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

375{
376 size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
377 char *frame;
378 uint64_t length;
379 uint64_t frame_size;
380
381 ast_debug(3, "Writing websocket %s frame, length %" PRIu64 "\n",
382 websocket_opcode2str(opcode), payload_size);
383
384 if (payload_size < 126) {
385 length = payload_size;
386 } else if (payload_size < (1 << 16)) {
387 length = 126;
388 /* We need an additional 2 bytes to store the extended length */
389 header_size += 2;
390 } else {
391 length = 127;
392 /* We need an additional 8 bytes to store the really really extended length */
393 header_size += 8;
394 }
395
396 if (session->client) {
397 /* Additional 4 bytes for the client masking key */
398 header_size += 4;
399 }
400
401 frame_size = header_size + payload_size;
402
403 frame = ast_alloca(frame_size + 1);
404 memset(frame, 0, frame_size + 1);
405
406 frame[0] = opcode | 0x80;
407 frame[1] = length;
408
409 /* Use the additional available bytes to store the length */
410 if (length == 126) {
411 put_unaligned_uint16(&frame[2], htons(payload_size));
412 } else if (length == 127) {
413 put_unaligned_uint64(&frame[2], htonll(payload_size));
414 }
415
416 memcpy(&frame[header_size], payload, payload_size);
417
418 websocket_mask_payload(session, frame, &frame[header_size], payload_size);
419
421 if (session->closing) {
423 return -1;
424 }
425
427 if (ast_iostream_write(session->stream, frame, frame_size) != frame_size) {
429 /* 1011 - server terminating connection due to not being able to fulfill the request */
430 ast_debug(1, "Closing WS with 1011 because we can't fulfill a write request\n");
432 return -1;
433 }
434
437
438 return 0;
439}
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
uint64_t htonll(uint64_t host64)
Definition: strcompat.c:390
void ast_iostream_set_timeout_sequence(struct ast_iostream *stream, struct timeval start, int timeout)
Set the iostream I/O sequence timeout timer.
Definition: iostream.c:140
static const char * websocket_opcode2str(enum ast_websocket_opcode opcode)
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
static void put_unaligned_uint64(void *p, uint64_t datum)
Definition: unaligned.h:51

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

Referenced by ast_ari_events_event_websocket_ws_established_cb(), ast_websocket_read(), ast_websocket_write_string(), speech_test_server_cb(), 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
wspointer to the websocket
bufstring data to write to socket
Return values
0if successfully written
-1if error occurred

Definition at line 1515 of file res_http_websocket.c.

1517{
1518 uint64_t len = strlen(buf);
1519
1520 ast_debug(3, "Writing websocket string of length %" PRIu64 "\n", len);
1521
1522 /* We do not pass strlen(buf) to ast_websocket_write() directly because the
1523 * size_t returned by strlen() may not require the same storage size
1524 * as the uint64_t that ast_websocket_write() uses. This normally
1525 * would not cause a problem, but since ast_websocket_write() uses
1526 * the optional API, this function call goes through a series of macros
1527 * that may cause a 32-bit to 64-bit conversion to go awry.
1528 */
1530 (char *)buf, len);
1531}
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)

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

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

◆ load_module()

static int load_module ( void  )
static

Definition at line 1533 of file res_http_websocket.c.

1534{
1536 if (!websocketuri.data) {
1538 }
1541
1542 return 0;
1543}
int ast_http_uri_link(struct ast_http_uri *urihandler)
Register a URI handler.
Definition: http.c:676
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
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 struct ast_websocket_server * websocket_server_internal_create(void)

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

◆ one_protocol()

static struct ast_websocket_protocol * one_protocol ( struct ast_websocket_server server)
static

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

Definition at line 752 of file res_http_websocket.c.

754{
755 SCOPED_AO2LOCK(lock, server->protocols);
756
757 if (ao2_container_count(server->protocols) != 1) {
758 return NULL;
759 }
760
761 return ao2_callback(server->protocols, OBJ_NOLOCK, NULL, NULL);
762}
ast_mutex_t lock
Definition: app_sla.c:331
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition: astobj2.h:1693
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
#define SCOPED_AO2LOCK(varname, obj)
scoped lock specialization for ao2 mutexes.
Definition: lock.h:604

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

Referenced by ast_websocket_uri_cb().

◆ protocol_cmp_fn()

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

Comparison function for protocols.

Definition at line 116 of file res_http_websocket.c.

117{
118 const struct ast_websocket_protocol *protocol1 = obj, *protocol2 = arg;
119 const char *protocol = arg;
120
121 return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
122}
@ CMP_MATCH
Definition: astobj2.h:1027
@ CMP_STOP
Definition: astobj2.h:1028

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

126{
127 struct ast_websocket_protocol *protocol = obj;
128 ast_free(protocol->name);
129}

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

108{
109 const struct ast_websocket_protocol *protocol = obj;
110 const char *name = obj;
111
112 return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
113}
static force_inline int attribute_pure ast_str_case_hash(const char *str)
Compute a hash value on a case-insensitive string.
Definition: strings.h:1303

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

174{
175 struct ast_websocket *session = obj;
176
177 if (session->stream) {
178 ast_websocket_close(session, session->close_status_code);
179 if (session->stream) {
181 session->stream = NULL;
182 ast_verb(2, "WebSocket connection %s '%s' closed\n", session->client ? "to" : "from",
183 ast_sockaddr_stringify(&session->remote_address));
184 }
185 }
186
187 ao2_cleanup(session->client);
188 ast_free(session->payload);
189}

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

Referenced by ast_websocket_uri_cb(), and websocket_client_create().

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 1545 of file res_http_websocket.c.

1546{
1551
1552 return 0;
1553}
void ast_http_uri_unlink(struct ast_http_uri *urihandler)
Unregister a URI handler.
Definition: http.c:708

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

◆ websocket_add_protocol_internal()

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

Definition at line 1043 of file res_http_websocket.c.

1044{
1045 struct ast_websocket_server *ws_server = websocketuri.data;
1046 if (!ws_server) {
1047 return -1;
1048 }
1049 return ast_websocket_server_add_protocol(ws_server, name, callback);
1050}
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.

References ast_websocket_server_add_protocol(), 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 777 of file res_http_websocket.c.

778{
779 struct ast_str *http_header = ast_str_create(64);
780
781 if (!http_header) {
783 ast_http_error(ser, 500, "Server Error", "Out of memory");
784 return;
785 }
786 ast_str_set(&http_header, 0, "Sec-WebSocket-Version: 7, 8, 13\r\n");
787 ast_http_send(ser, AST_HTTP_UNKNOWN, 400, "Bad Request", http_header, NULL, 0, 0);
788}
void ast_http_send(struct ast_tcptls_session_instance *ser, enum ast_http_method method, int status_code, const char *status_title, struct ast_str *http_header, struct ast_str *out, int fd, unsigned int static_content)
Generic function for sending HTTP/1.1 response.
Definition: http.c:459
@ AST_HTTP_UNKNOWN
Definition: http.h:59
void ast_http_request_close_on_completion(struct ast_tcptls_session_instance *ser)
Request the HTTP connection be closed after this HTTP request.
Definition: http.c:840
#define ast_str_create(init_len)
Create a malloc'ed dynamic length string.
Definition: strings.h:659
int ast_str_set(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Set a dynamic string using variable arguments.
Definition: strings.h:1113
Support for dynamic strings.
Definition: strings.h:623

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

Referenced by ast_websocket_uri_cb().

◆ websocket_client_args_create()

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

Definition at line 1140 of file res_http_websocket.c.

1143{
1144 struct ast_sockaddr *addr;
1147
1148 if (!args) {
1150 return NULL;
1151 }
1152
1153 args->accept_fd = -1;
1154 args->tls_cfg = tls_cfg;
1155 args->name = "websocket client";
1156
1157 if (!ast_sockaddr_resolve(&addr, host, 0, 0)) {
1158 ast_log(LOG_ERROR, "Unable to resolve address %s\n",
1159 host);
1160 ao2_ref(args, -1);
1162 return NULL;
1163 }
1164 ast_sockaddr_copy(&args->remote_address, addr);
1165 ast_free(addr);
1166
1167 /* We need to save off the hostname but it may contain a port spec */
1168 snprintf(args->hostname, sizeof(args->hostname),
1169 "%.*s",
1170 (int) strcspn(host, ":"), host);
1171
1172 return args;
1173}
@ WS_ALLOCATE_ERROR
@ WS_URI_RESOLVE_ERROR
int ast_sockaddr_resolve(struct ast_sockaddr **addrs, const char *str, int flags, int family)
Parses a string with an IPv4 or IPv6 address and place results into an array.
Definition: netsock2.c:280
static void websocket_client_args_destroy(void *obj)
Socket address structure.
Definition: netsock2.h:97
arguments for the accepting thread
Definition: tcptls.h:130
struct ast_tls_config * tls_cfg
Definition: tcptls.h:135
const char * args

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

Referenced by websocket_client_create().

◆ websocket_client_args_destroy()

static void websocket_client_args_destroy ( void *  obj)
static

Definition at line 1124 of file res_http_websocket.c.

1125{
1126 struct ast_tcptls_session_args *args = obj;
1127
1128 if (args->tls_cfg) {
1129 ast_free(args->tls_cfg->certfile);
1130 ast_free(args->tls_cfg->pvtfile);
1131 ast_free(args->tls_cfg->cipher);
1132 ast_free(args->tls_cfg->cafile);
1133 ast_free(args->tls_cfg->capath);
1134
1135 ast_ssl_teardown(args->tls_cfg);
1136 }
1137 ast_free(args->tls_cfg);
1138}
void ast_ssl_teardown(struct ast_tls_config *cfg)
free resources used by an SSL server
Definition: tcptls.c:575

References args, ast_free, and ast_ssl_teardown().

Referenced by websocket_client_args_create().

◆ websocket_client_connect()

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

Definition at line 1417 of file res_http_websocket.c.

1418{
1419 enum ast_websocket_result res;
1420 /* create and connect the client - note client_start
1421 releases the session instance on failure */
1423 ast_tcptls_client_create(ws->client->args), timeout))) {
1424 return WS_CLIENT_START_ERROR;
1425 }
1426
1427 if ((res = websocket_client_handshake(ws->client)) != WS_OK) {
1428 ao2_ref(ws->client->ser, -1);
1429 ws->client->ser = NULL;
1430 return res;
1431 }
1432
1433 ws->stream = ws->client->ser->stream;
1434 ws->secure = ast_iostream_get_ssl(ws->stream) ? 1 : 0;
1435 ws->client->ser->stream = NULL;
1437 return WS_OK;
1438}
ast_websocket_result
Result code for a websocket client.
@ WS_CLIENT_START_ERROR
static enum ast_websocket_result websocket_client_handshake(struct websocket_client *client)
struct ast_iostream * stream
struct ast_sockaddr remote_address
unsigned int secure
struct ast_tcptls_session_args * args
struct ast_tcptls_session_instance * ser
struct ast_tcptls_session_instance * ast_tcptls_client_create(struct ast_tcptls_session_args *desc)
Creates a client connection's ast_tcptls_session_instance.
Definition: tcptls.c:678
struct ast_tcptls_session_instance * ast_tcptls_client_start_timeout(struct ast_tcptls_session_instance *tcptls_session, int timeout)
Attempt to connect and start a tcptls session within the given timeout.
Definition: tcptls.c:645

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

Referenced by ast_websocket_client_create_with_options().

◆ websocket_client_create()

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

Definition at line 1231 of file res_http_websocket.c.

1233{
1234 struct ast_websocket *ws = ao2_alloc(sizeof(*ws), session_destroy_fn);
1235
1236 if (!ws) {
1237 ast_log(LOG_ERROR, "Unable to allocate websocket\n");
1239 return NULL;
1240 }
1241
1242 if (!(ws->client = ao2_alloc(
1243 sizeof(*ws->client), websocket_client_destroy))) {
1244 ast_log(LOG_ERROR, "Unable to allocate websocket client\n");
1246 return NULL;
1247 }
1248
1249 if (!(ws->client->key = websocket_client_create_key())) {
1250 ao2_ref(ws, -1);
1252 return NULL;
1253 }
1254
1256 options->uri, &ws->client->host, &ws->client->resource_name)) {
1257 ao2_ref(ws, -1);
1259 return NULL;
1260 }
1261
1263 ws->client->host, options->tls_cfg, result))) {
1264 ao2_ref(ws, -1);
1265 return NULL;
1266 }
1267 ws->client->protocols = ast_strdup(options->protocols);
1268
1269 ws->client->version = 13;
1270 ws->opcode = -1;
1272 return ws;
1273}
@ WS_KEY_ERROR
@ WS_URI_PARSE_ERROR
static void websocket_client_destroy(void *obj)
static char * websocket_client_create_key(void)
static int websocket_client_parse_uri(const char *uri, char **host, struct ast_str **path)
Parse the given uri into a path and remote address.
static struct ast_tcptls_session_args * websocket_client_args_create(const char *host, struct ast_tls_config *tls_cfg, enum ast_websocket_result *result)
enum ast_websocket_opcode opcode
struct ast_str * resource_name

References ao2_alloc, ao2_ref, websocket_client::args, ast_log, ast_strdup, ast_websocket::client, DEFAULT_RECONSTRUCTION_CEILING, websocket_client::host, websocket_client::key, LOG_ERROR, NULL, ast_websocket::opcode, options, websocket_client::protocols, ast_websocket::reconstruct, websocket_client::resource_name, result, session_destroy_fn(), 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 1175 of file res_http_websocket.c.

1176{
1177 static int encoded_size = CLIENT_KEY_SIZE * 2 * sizeof(char) + 1;
1178 /* key is randomly selected 16-byte base64 encoded value */
1179 unsigned char key[CLIENT_KEY_SIZE + sizeof(long) - 1];
1180 char *encoded = ast_malloc(encoded_size);
1181 long i = 0;
1182
1183 if (!encoded) {
1184 ast_log(LOG_ERROR, "Unable to allocate client websocket key\n");
1185 return NULL;
1186 }
1187
1188 while (i < CLIENT_KEY_SIZE) {
1189 long num = ast_random();
1190 memcpy(key + i, &num, sizeof(long));
1191 i += sizeof(long);
1192 }
1193
1194 ast_base64encode(encoded, key, CLIENT_KEY_SIZE, encoded_size);
1195 return encoded;
1196}
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
#define CLIENT_KEY_SIZE
Length of a websocket's client key.
int ast_base64encode(char *dst, const unsigned char *src, int srclen, int max)
Encode data in base64.
Definition: utils.c:406
long int ast_random(void)
Definition: utils.c:2312

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

◆ websocket_client_handle_response_code()

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

Definition at line 1281 of file res_http_websocket.c.

1283{
1284 if (response_code <= 0) {
1285 return WS_INVALID_RESPONSE;
1286 }
1287
1288 switch (response_code) {
1289 case 101:
1290 return 0;
1291 case 400:
1292 ast_log(LOG_ERROR, "Received response 400 - Bad Request "
1293 "- from %s\n", client->host);
1294 return WS_BAD_REQUEST;
1295 case 404:
1296 ast_log(LOG_ERROR, "Received response 404 - Request URL not "
1297 "found - from %s\n", client->host);
1298 return WS_URL_NOT_FOUND;
1299 }
1300
1301 ast_log(LOG_ERROR, "Invalid HTTP response code %d from %s\n",
1302 response_code, client->host);
1303 return WS_INVALID_RESPONSE;
1304}
@ WS_BAD_REQUEST
@ WS_URL_NOT_FOUND
@ WS_INVALID_RESPONSE

References ast_log, ast_websocket::client, websocket_client::host, LOG_ERROR, WS_BAD_REQUEST, WS_INVALID_RESPONSE, 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 1387 of file res_http_websocket.c.

1389{
1390 char protocols[100] = "";
1391
1392 if (!ast_strlen_zero(client->protocols)) {
1393 sprintf(protocols, "Sec-WebSocket-Protocol: %s\r\n",
1394 client->protocols);
1395 }
1396
1397 if (ast_iostream_printf(client->ser->stream,
1398 "GET /%s HTTP/1.1\r\n"
1399 "Sec-WebSocket-Version: %d\r\n"
1400 "Upgrade: websocket\r\n"
1401 "Connection: Upgrade\r\n"
1402 "Host: %s\r\n"
1403 "Sec-WebSocket-Key: %s\r\n"
1404 "%s\r\n",
1405 client->resource_name ? ast_str_buffer(client->resource_name) : "",
1406 client->version,
1407 client->host,
1408 client->key,
1409 protocols) < 0) {
1410 ast_log(LOG_ERROR, "Failed to send handshake.\n");
1411 return WS_WRITE_ERROR;
1412 }
1413 /* wait for a response before doing anything else */
1415}
@ WS_WRITE_ERROR
static enum ast_websocket_result websocket_client_handshake_get_response(struct websocket_client *client)
char * ast_str_buffer(const struct ast_str *buf)
Returns the string buffer within the ast_str buf.
Definition: strings.h:761

References ast_iostream_printf(), ast_log, ast_str_buffer(), ast_strlen_zero(), ast_websocket::client, websocket_client::host, websocket_client::key, LOG_ERROR, websocket_client::protocols, websocket_client::resource_name, websocket_client::ser, ast_tcptls_session_instance::stream, websocket_client::version, websocket_client_handshake_get_response(), and WS_WRITE_ERROR.

Referenced by websocket_client_connect().

◆ websocket_client_handshake_get_response()

static enum ast_websocket_result websocket_client_handshake_get_response ( struct websocket_client client)
static

Definition at line 1306 of file res_http_websocket.c.

1308{
1309 enum ast_websocket_result res;
1310 char buf[4096];
1311 char base64[64];
1312 int has_upgrade = 0;
1313 int has_connection = 0;
1314 int has_accept = 0;
1315 int has_protocol = 0;
1316
1317 while (ast_iostream_gets(client->ser->stream, buf, sizeof(buf)) <= 0) {
1318 if (errno == EINTR || errno == EAGAIN) {
1319 continue;
1320 }
1321
1322 ast_log(LOG_ERROR, "Unable to retrieve HTTP status line.");
1323 return WS_BAD_STATUS;
1324 }
1325
1326 if ((res = websocket_client_handle_response_code(client,
1328 buf, "HTTP/1.1", 101))) != WS_OK) {
1329 return res;
1330 }
1331
1332 /* Ignoring line folding - assuming header field values are contained
1333 within a single line */
1334 while (1) {
1335 ssize_t len = ast_iostream_gets(client->ser->stream, buf, sizeof(buf));
1336 char *name, *value;
1337 int parsed;
1338
1339 if (len <= 0) {
1340 if (errno == EINTR || errno == EAGAIN) {
1341 continue;
1342 }
1343 break;
1344 }
1345
1346 parsed = ast_http_header_parse(buf, &name, &value);
1347 if (parsed < 0) {
1348 break;
1349 }
1350
1351 if (parsed > 0) {
1352 continue;
1353 }
1354
1355 if (!has_upgrade &&
1356 (has_upgrade = ast_http_header_match(
1357 name, "upgrade", value, "websocket")) < 0) {
1358 return WS_HEADER_MISMATCH;
1359 } else if (!has_connection &&
1360 (has_connection = ast_http_header_match(
1361 name, "connection", value, "upgrade")) < 0) {
1362 return WS_HEADER_MISMATCH;
1363 } else if (!has_accept &&
1364 (has_accept = ast_http_header_match(
1365 name, "sec-websocket-accept", value,
1367 client->key, base64, sizeof(base64)))) < 0) {
1368 return WS_HEADER_MISMATCH;
1369 } else if (!has_protocol &&
1370 (has_protocol = ast_http_header_match_in(
1371 name, "sec-websocket-protocol", value, client->protocols))) {
1372 if (has_protocol < 0) {
1373 return WS_HEADER_MISMATCH;
1374 }
1375 client->accept_protocol = ast_strdup(value);
1376 } else if (!strcasecmp(name, "sec-websocket-extensions")) {
1377 ast_log(LOG_ERROR, "Extensions received, but not "
1378 "supported by client\n");
1379 return WS_NOT_SUPPORTED;
1380 }
1381 }
1382
1383 return has_upgrade && has_connection && has_accept ?
1385}
int ast_http_header_parse(char *buf, char **name, char **value)
Parse a header into the given name/value strings.
Definition: http.c:1691
int ast_http_header_match_in(const char *name, const char *expected_name, const char *value, const char *expected_value)
Check if the header name matches the expected header name. If so, then check to see if the value can ...
Definition: http.c:1729
int ast_http_header_match(const char *name, const char *expected_name, const char *value, const char *expected_value)
Check if the header and value match (case insensitive) their associated expected values.
Definition: http.c:1713
int ast_http_response_status_line(const char *buf, const char *version, int code)
Parse the http response status line.
Definition: http.c:1639
@ WS_NOT_SUPPORTED
@ WS_HEADER_MISMATCH
@ WS_BAD_STATUS
@ WS_HEADER_MISSING
ssize_t ast_iostream_gets(struct ast_iostream *stream, char *buffer, size_t size)
Read a LF-terminated string from an iostream.
Definition: iostream.c:311
int errno
static enum ast_websocket_result websocket_client_handle_response_code(struct websocket_client *client, int response_code)
int value
Definition: syslog.c:37

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

Referenced by websocket_client_handshake().

◆ websocket_client_parse_uri()

static int websocket_client_parse_uri ( const char *  uri,
char **  host,
struct ast_str **  path 
)
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 1094 of file res_http_websocket.c.

1095{
1096 struct ast_uri *parsed_uri = ast_uri_parse_websocket(uri);
1097
1098 if (!parsed_uri) {
1099 return -1;
1100 }
1101
1102 *host = ast_uri_make_host_with_port(parsed_uri);
1103
1104 if (ast_uri_path(parsed_uri) || ast_uri_query(parsed_uri)) {
1105 *path = ast_str_create(64);
1106 if (!*path) {
1107 ao2_ref(parsed_uri, -1);
1108 return -1;
1109 }
1110
1111 if (ast_uri_path(parsed_uri)) {
1112 ast_str_set(path, 0, "%s", ast_uri_path(parsed_uri));
1113 }
1114
1115 if (ast_uri_query(parsed_uri)) {
1116 ast_str_append(path, 0, "?%s", ast_uri_query(parsed_uri));
1117 }
1118 }
1119
1120 ao2_ref(parsed_uri, -1);
1121 return 0;
1122}
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition: strings.h:1139
Stores parsed uri information.
Definition: uri.c:30
char * host
Definition: uri.c:36
char * path
Definition: uri.c:40
char uri[0]
Definition: uri.c:44
const char * ast_uri_path(const struct ast_uri *uri)
Retrieve the uri path.
Definition: uri.c:135
struct ast_uri * ast_uri_parse_websocket(const char *uri)
Parse the given websocket uri into a structure.
Definition: uri.c:295
const char * ast_uri_query(const struct ast_uri *uri)
Retrieve the uri query parameters.
Definition: uri.c:140
char * ast_uri_make_host_with_port(const struct ast_uri *uri)
Retrieve a string of the host and port.
Definition: uri.c:300

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

Referenced by websocket_client_create().

◆ websocket_combine_key()

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

Definition at line 764 of file res_http_websocket.c.

765{
766 char *combined;
767 unsigned combined_length = strlen(key) + strlen(WEBSOCKET_GUID) + 1;
768 uint8_t sha[20];
769
770 combined = ast_alloca(combined_length);
771 snprintf(combined, combined_length, "%s%s", key, WEBSOCKET_GUID);
772 ast_sha1_hash_uint(sha, combined);
773 ast_base64encode(res, (const unsigned char*)sha, 20, res_size);
774 return res;
775}
void ast_sha1_hash_uint(uint8_t *digest, const char *input)
Produces SHA1 hash based on input string, stored in uint8_t array.
Definition: utils.c:284

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

1008{
1009 int res;
1010
1011 ast_debug(1, "Entering WebSocket echo loop\n");
1012
1013 if (ast_fd_set_flags(ast_websocket_fd(session), O_NONBLOCK)) {
1014 goto end;
1015 }
1016
1017 while ((res = ast_websocket_wait_for_input(session, -1)) > 0) {
1018 char *payload;
1019 uint64_t payload_len;
1020 enum ast_websocket_opcode opcode;
1021 int fragmented;
1022
1023 if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
1024 /* We err on the side of caution and terminate the session if any error occurs */
1025 ast_log(LOG_WARNING, "Read failure during WebSocket echo loop\n");
1026 break;
1027 }
1028
1029 if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
1030 ast_websocket_write(session, opcode, payload, payload_len);
1031 } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
1032 break;
1033 } else {
1034 ast_debug(1, "Ignored WebSocket opcode %u\n", opcode);
1035 }
1036 }
1037
1038end:
1039 ast_debug(1, "Exiting WebSocket echo loop\n");
1041}
char * end
Definition: eagi_proxy.c:73
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_fd(struct ast_websocket *session)
Get the file descriptor for a WebSocket session.
void AST_OPTIONAL_API_NAME() ast_websocket_unref(struct ast_websocket *session)
Decrease the reference count for a WebSocket session.
#define ast_fd_set_flags(fd, flags)
Set flags on the given file descriptor.
Definition: utils.h:1039

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

Referenced by load_module(), and unload_module().

◆ websocket_mask_payload()

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

Perform payload masking for client sessions.

Definition at line 288 of file res_http_websocket.c.

289{
290 /* RFC 6455 5.1 - clients MUST mask frame data */
291 if (session->client) {
292 uint64_t i;
293 uint8_t mask_key_idx;
294 uint32_t mask_key = ast_random();
295 uint8_t length = frame[1] & 0x7f;
296 frame[1] |= 0x80; /* set mask bit to 1 */
297 /* The mask key octet position depends on the length */
298 mask_key_idx = length == 126 ? 4 : length == 127 ? 10 : 2;
299 put_unaligned_uint32(&frame[mask_key_idx], mask_key);
300 for (i = 0; i < payload_size; i++) {
301 payload[i] ^= ((char *)&mask_key)[i % 4];
302 }
303 }
304}
static void put_unaligned_uint32(void *p, unsigned int datum)
Definition: unaligned.h:58

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

Referenced by ast_websocket_close(), and ast_websocket_write().

◆ websocket_opcode2str()

static const char * websocket_opcode2str ( enum ast_websocket_opcode  opcode)
static

Definition at line 363 of file res_http_websocket.c.

364{
366 opcode > AST_WEBSOCKET_OPCODE_PONG) {
367 return "<unknown>";
368 } else {
369 return opcode_map[opcode];
370 }
371}
static const char * opcode_map[]

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

Referenced by ast_websocket_write().

◆ websocket_remove_protocol_internal()

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

Definition at line 1072 of file res_http_websocket.c.

1073{
1074 struct ast_websocket_server *ws_server = websocketuri.data;
1075 if (!ws_server) {
1076 return -1;
1077 }
1078 return ast_websocket_server_remove_protocol(ws_server, name, callback);
1079}
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.

References ast_websocket_server_remove_protocol(), 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 143 of file res_http_websocket.c.

144{
145 RAII_VAR(struct ast_websocket_server *, server, NULL, ao2_cleanup);
146
147 server = ao2_alloc(sizeof(*server), websocket_server_dtor);
148 if (!server) {
149 return NULL;
150 }
151
154 if (!server->protocols) {
155 return NULL;
156 }
157
158 ao2_ref(server, +1);
159 return server;
160}
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
#define MAX_PROTOCOL_BUCKETS
Number of buckets for registered protocols.
static void websocket_server_dtor(void *obj)
static int protocol_cmp_fn(void *obj, void *arg, int flags)
Comparison function for protocols.
static int protocol_hash_fn(const void *obj, const int flags)
Hashing function for protocols.
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941

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

137{
138 struct ast_websocket_server *server = obj;
139 ao2_cleanup(server->protocols);
140 server->protocols = NULL;
141}

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

163{
165}

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

535{
536 ssize_t rlen;
537 int xlen = len;
538 char *rbuf = buf;
539 int sanity = 10;
540
541 ast_assert(len > 0);
542
543 if (!len) {
544 errno = EINVAL;
545 return -1;
546 }
547
549 if (!session->stream) {
551 errno = ECONNABORTED;
552 return -1;
553 }
554
555 for (;;) {
556 rlen = ast_iostream_read(session->stream, rbuf, xlen);
557 if (rlen != xlen) {
558 if (rlen == 0) {
559 ast_log(LOG_WARNING, "Web socket closed abruptly\n");
561 session->closing = 1;
563 return -1;
564 }
565
566 if (rlen < 0 && errno != EAGAIN) {
567 ast_log(LOG_ERROR, "Error reading from web socket: %s\n", strerror(errno));
569 session->closing = 1;
571 return -1;
572 }
573
574 if (!--sanity) {
575 ast_log(LOG_WARNING, "Websocket seems unresponsive, disconnecting ...\n");
577 session->closing = 1;
579 return -1;
580 }
581 }
582 if (rlen > 0) {
583 xlen = xlen - rlen;
584 rbuf = rbuf + rlen;
585 if (!xlen) {
586 break;
587 }
588 }
589 if (ast_iostream_wait_for_input(session->stream, 1000) < 0) {
590 ast_log(LOG_ERROR, "ast_iostream_wait_for_input returned err: %s\n", strerror(errno));
592 session->closing = 1;
594 return -1;
595 }
596 }
597
599 return 0;
600}
ssize_t ast_iostream_read(struct ast_iostream *stream, void *buffer, size_t count)
Read data from an iostream.
Definition: iostream.c:284
#define ast_assert(a)
Definition: utils.h:739

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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 1561 of file res_http_websocket.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 1561 of file res_http_websocket.c.

◆ opcode_map

const char* opcode_map[]
static

Definition at line 354 of file res_http_websocket.c.

Referenced by websocket_opcode2str().

◆ websocketuri

struct ast_http_uri websocketuri
static