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_module *	AST_MODULE_SELF_SYM (void)
int AST_OPTIONAL_API_NAME()	ast_websocket_add_protocol (const char *name, ast_websocket_callback callback)
int AST_OPTIONAL_API_NAME()	ast_websocket_add_protocol2 (struct ast_websocket_protocol *protocol)
const char *AST_OPTIONAL_API_NAME()	ast_websocket_client_accept_protocol (struct ast_websocket *ws)
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)
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)
int AST_OPTIONAL_API_NAME()	ast_websocket_is_secure (struct ast_websocket *session)
struct ast_sockaddr *AST_OPTIONAL_API_NAME()	ast_websocket_local_address (struct ast_websocket *session)
int AST_OPTIONAL_API_NAME()	ast_websocket_read (struct ast_websocket *session, char **payload, uint64_t *payload_len, enum ast_websocket_opcode *opcode, int *fragmented)
int AST_OPTIONAL_API_NAME()	ast_websocket_read_string (struct ast_websocket *ws, char **buf)
void AST_OPTIONAL_API_NAME()	ast_websocket_reconstruct_disable (struct ast_websocket *session)
void AST_OPTIONAL_API_NAME()	ast_websocket_reconstruct_enable (struct ast_websocket *session, size_t bytes)
void AST_OPTIONAL_API_NAME()	ast_websocket_ref (struct ast_websocket *session)
struct ast_sockaddr *AST_OPTIONAL_API_NAME()	ast_websocket_remote_address (struct ast_websocket *session)
int AST_OPTIONAL_API_NAME()	ast_websocket_remove_protocol (const char *name, ast_websocket_callback callback)
int AST_OPTIONAL_API_NAME()	ast_websocket_server_add_protocol (struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
int AST_OPTIONAL_API_NAME()	ast_websocket_server_add_protocol2 (struct ast_websocket_server *server, struct ast_websocket_protocol *protocol)
struct ast_websocket_server *AST_OPTIONAL_API_NAME()	ast_websocket_server_create (void)
int AST_OPTIONAL_API_NAME()	ast_websocket_server_remove_protocol (struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
const char *AST_OPTIONAL_API_NAME()	ast_websocket_session_id (struct ast_websocket *session)
int AST_OPTIONAL_API_NAME()	ast_websocket_set_nonblock (struct ast_websocket *session)
int AST_OPTIONAL_API_NAME()	ast_websocket_set_timeout (struct ast_websocket *session, int timeout)
struct ast_websocket_protocol *AST_OPTIONAL_API_NAME()	ast_websocket_sub_protocol_alloc (const char *name)
void AST_OPTIONAL_API_NAME()	ast_websocket_unref (struct ast_websocket *session)
int AST_OPTIONAL_API_NAME()	ast_websocket_uri_cb (struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_vars, struct ast_variable *headers)
int AST_OPTIONAL_API_NAME()	ast_websocket_wait_for_input (struct ast_websocket *session, int timeout)
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)
static int	load_module (void)
static struct ast_websocket_protocol *	one_protocol (struct ast_websocket_server *server)
	If the server has exactly one configured protocol, return it. 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_args *	websocket_client_args_create (const char *host, struct ast_tls_config *tls_cfg, enum ast_websocket_result *result)
static void	websocket_client_args_destroy (void *obj)
static enum ast_websocket_result	websocket_client_connect (struct ast_websocket *ws)
static struct ast_websocket *	websocket_client_create (const char *uri, const char *protocols, struct ast_tls_config *tls_cfg, 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_server *	websocket_server_create_impl (void)
static void	websocket_server_dtor (void *obj)
static struct ast_websocket_server *	websocket_server_internal_create (void)
static int	ws_safe_read (struct ast_websocket *session, char *buf, size_t len, enum ast_websocket_opcode *opcode)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "HTTP WebSocket Support" , .key = "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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "http", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const char *	opcode_map []
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.

Referenced by websocket_client_create_key().

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.

Referenced by ast_websocket_uri_cb(), and websocket_client_create().

MAX_PROTOCOL_BUCKETS

#define MAX_PROTOCOL_BUCKETS   7

Number of buckets for registered protocols.

Definition at line 51 of file res_http_websocket.c.

Referenced by websocket_server_create_impl().

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.

Referenced by ast_websocket_read().

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.

Referenced by ast_websocket_reconstruct_enable().

MIN_WS_HDR_SZ

#define MIN_WS_HDR_SZ   2

Definition at line 85 of file res_http_websocket.c.

Referenced by ast_websocket_read().

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.

Referenced by ast_websocket_uri_cb(), and websocket_combine_key().

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1529 of file res_http_websocket.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1529 of file res_http_websocket.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 1529 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
	)

Definition at line 1052 of file res_http_websocket.c.

References name, and websocket_add_protocol_internal().

Referenced by load_module(), and reload_config().

{
   return websocket_add_protocol_internal(name, callback);
}

ast_websocket_add_protocol2()

int AST_OPTIONAL_API_NAME() ast_websocket_add_protocol2

(

struct ast_websocket_protocol *

protocol

)

Definition at line 1057 of file res_http_websocket.c.

References ast_websocket_server_add_protocol2(), and ast_http_uri::data.

{
   struct ast_websocket_server *ws_server = websocketuri.data;

   if (!ws_server) {
      return -1;
   }

   if (ast_websocket_server_add_protocol2(ws_server, protocol)) {
      return -1;
   }

   return 0;
}

ast_websocket_client_accept_protocol()

const char* AST_OPTIONAL_API_NAME() ast_websocket_client_accept_protocol

(

struct ast_websocket *

ws

)

Definition at line 1270 of file res_http_websocket.c.

Referenced by __stub__ast_websocket_client_create(), and AST_TEST_DEFINE().

{
   return ws->client->accept_protocol;
}

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
	)

Definition at line 1421 of file res_http_websocket.c.

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

Referenced by AST_TEST_DEFINE(), and websocket_client_connect().

{
   struct ast_websocket *ws = websocket_client_create(
      uri, protocols, tls_cfg, result);

   if (!ws) {
      return NULL;
   }

   if ((*result = websocket_client_connect(ws)) != WS_OK) {
      ao2_ref(ws, -1);
      return NULL;
   }

   return ws;
}

ast_websocket_close()

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

Close function for websocket session.

Definition at line 308 of file res_http_websocket.c.

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, ast_websocket::client, ast_websocket::close_sent, ast_websocket::closing, NULL, ast_websocket::opcode, put_unaligned_uint16(), ast_websocket::remote_address, ast_websocket::stream, ast_websocket::timeout, and websocket_mask_payload().

Referenced by ast_websocket_read(), ast_websocket_write(), session_destroy_fn(), and ws_destroy().

{
   enum ast_websocket_opcode opcode = AST_WEBSOCKET_OPCODE_CLOSE;
   /* The header is either 2 or 6 bytes and the
    * reason code takes up another 2 bytes */
   char frame[8] = { 0, };
   int header_size, fsize, res;

   if (session->close_sent) {
      return 0;
   }

   /* clients need space for an additional 4 byte masking key */
   header_size = session->client ? 6 : 2;
   fsize = header_size + 2;

   frame[0] = opcode | 0x80;
   frame[1] = 2; /* The reason code is always 2 bytes */

   /* If no reason has been specified assume 1000 which is normal closure */
   put_unaligned_uint16(&frame[header_size], htons(reason ? reason : 1000));

   websocket_mask_payload(session, frame, &frame[header_size], 2);

   session->closing = 1;
   session->close_sent = 1;

   ao2_lock(session);
   ast_iostream_set_timeout_inactivity(session->stream, session->timeout);
   res = ast_iostream_write(session->stream, frame, fsize);
   ast_iostream_set_timeout_disable(session->stream);

   /* If an error occurred when trying to close this connection explicitly terminate it now.
    * Doing so will cause the thread polling on it to wake up and terminate.
    */
   if (res != fsize) {
      ast_iostream_close(session->stream);
      session->stream = NULL;
      ast_verb(2, "WebSocket connection %s '%s' forcefully closed due to fatal write error\n",
         session->client ? "to" : "from", ast_sockaddr_stringify(&session->remote_address));
   }

   ao2_unlock(session);
   return res == sizeof(frame);
}

ast_websocket_fd()

int AST_OPTIONAL_API_NAME() ast_websocket_fd

(

struct ast_websocket *

session

)

Definition at line 461 of file res_http_websocket.c.

References ast_iostream_get_fd(), ast_websocket::closing, and ast_websocket::stream.

Referenced by ast_ari_websocket_session_read(), sip_prepare_socket(), sip_websocket_callback(), websocket_echo_callback(), and ws_destroy().

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

ast_websocket_is_secure()

int AST_OPTIONAL_API_NAME() ast_websocket_is_secure

(

struct ast_websocket *

session

)

Definition at line 481 of file res_http_websocket.c.

References ast_websocket::secure.

Referenced by sip_websocket_callback(), and transport_create().

{
   return session->secure;
}

ast_websocket_local_address()

struct ast_sockaddr* AST_OPTIONAL_API_NAME() ast_websocket_local_address

(

struct ast_websocket *

session

)

Definition at line 476 of file res_http_websocket.c.

References ast_websocket::local_address.

Referenced by transport_create().

{
   return &session->local_address;
}

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
	)

Definition at line 602 of file res_http_websocket.c.

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(), ast_websocket::buf, ast_websocket::close_status_code, ast_websocket::closing, 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, ast_websocket::reconstruct, and ws_safe_read().

Referenced by ast_ari_websocket_session_read(), ast_websocket_read_string(), sip_websocket_callback(), websocket_cb(), and websocket_echo_callback().

{
   int fin = 0;
   int mask_present = 0;
   char *mask = NULL, *new_payload = NULL;
   size_t options_len = 0, frame_size = 0;

   *payload = NULL;
   *payload_len = 0;
   *fragmented = 0;

   if (ws_safe_read(session, &session->buf[0], MIN_WS_HDR_SZ, opcode)) {
      return -1;
   }
   frame_size += MIN_WS_HDR_SZ;

   /* ok, now we have the first 2 bytes, so we know some flags, opcode and payload length (or whether payload length extension will be required) */
   *opcode = session->buf[0] & 0xf;
   *payload_len = session->buf[1] & 0x7f;
   if (*opcode == AST_WEBSOCKET_OPCODE_TEXT || *opcode == AST_WEBSOCKET_OPCODE_BINARY || *opcode == AST_WEBSOCKET_OPCODE_CONTINUATION ||
       *opcode == AST_WEBSOCKET_OPCODE_PING || *opcode == AST_WEBSOCKET_OPCODE_PONG  || *opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
      fin = (session->buf[0] >> 7) & 1;
      mask_present = (session->buf[1] >> 7) & 1;

      /* Based on the mask flag and payload length, determine how much more we need to read before start parsing the rest of the header */
      options_len += mask_present ? 4 : 0;
      options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
      if (options_len) {
         /* read the rest of the header options */
         if (ws_safe_read(session, &session->buf[frame_size], options_len, opcode)) {
            return -1;
         }
         frame_size += options_len;
      }

      if (*payload_len == 126) {
         /* Grab the 2-byte payload length  */
         *payload_len = ntohs(get_unaligned_uint16(&session->buf[2]));
         mask = &session->buf[4];
      } else if (*payload_len == 127) {
         /* Grab the 8-byte payload length  */
         *payload_len = ntohll(get_unaligned_uint64(&session->buf[2]));
         mask = &session->buf[10];
      } else {
         /* Just set the mask after the small 2-byte header */
         mask = &session->buf[2];
      }

      /* Now read the rest of the payload */
      *payload = &session->buf[frame_size]; /* payload will start here, at the end of the options, if any */
      frame_size = frame_size + (*payload_len); /* final frame size is header + optional headers + payload data */
      if (frame_size > MAXIMUM_FRAME_SIZE) {
         ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zu bytes\n", frame_size);
         /* The frame won't fit :-( */
         ast_websocket_close(session, 1009);
         return -1;
      }

      if (*payload_len) {
         if (ws_safe_read(session, *payload, *payload_len, opcode)) {
            return -1;
         }
      }

      /* If a mask is present unmask the payload */
      if (mask_present) {
         unsigned int pos;
         for (pos = 0; pos < *payload_len; pos++) {
            (*payload)[pos] ^= mask[pos % 4];
         }
      }

      /* Per the RFC for PING we need to send back an opcode with the application data as received */
      if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
         if (ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len)) {
            ast_websocket_close(session, 1009);
         }
         *payload_len = 0;
         return 0;
      }

      /* Stop PONG processing here */
      if (*opcode == AST_WEBSOCKET_OPCODE_PONG) {
         *payload_len = 0;
         return 0;
      }

      /* Save the CLOSE status code which will be sent in our own CLOSE in the destructor */
      if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
         session->closing = 1;
         if (*payload_len >= 2) {
            session->close_status_code = ntohs(get_unaligned_uint16(*payload));
         }
         *payload_len = 0;
         return 0;
      }

      /* Below this point we are handling TEXT, BINARY or CONTINUATION opcodes */
      if (*payload_len) {
         if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
            ast_log(LOG_WARNING, "Failed allocation: %p, %zu, %"PRIu64"\n",
               session->payload, session->payload_len, *payload_len);
            *payload_len = 0;
            ast_websocket_close(session, 1009);
            return -1;
         }

         session->payload = new_payload;
         memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
         session->payload_len += *payload_len;
      } else if (!session->payload_len && session->payload) {
         ast_free(session->payload);
         session->payload = NULL;
      }

      if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
         /* If this is not a final message we need to defer returning it until later */
         if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
            session->opcode = *opcode;
         }
         *opcode = AST_WEBSOCKET_OPCODE_CONTINUATION;
         *payload_len = 0;
         *payload = NULL;
      } else {
         if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
            if (!fin) {
               /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
               *fragmented = 1;
            } else {
               /* Final frame in multi-frame so push up the actual opcode */
               *opcode = session->opcode;
            }
         }
         *payload_len = session->payload_len;
         *payload = session->payload;
         session->payload_len = 0;
      }
   } else {
      ast_log(LOG_WARNING, "WebSocket unknown opcode %u\n", *opcode);
      /* We received an opcode that we don't understand, the RFC states that 1003 is for a type of data that can't be accepted... opcodes
       * fit that, I think. */
      ast_websocket_close(session, 1003);
   }

   return 0;
}

ast_websocket_read_string()

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

Definition at line 1440 of file res_http_websocket.c.

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

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

{
   char *payload;
   uint64_t payload_len;
   enum ast_websocket_opcode opcode;
   int fragmented = 1;

   while (fragmented) {
      if (ast_websocket_read(ws, &payload, &payload_len,
                   &opcode, &fragmented)) {
         ast_log(LOG_ERROR, "Client WebSocket string read - "
            "error reading string data\n");
         return -1;
      }

      if (opcode == AST_WEBSOCKET_OPCODE_PING) {
         /* Try read again, we have sent pong already */
         fragmented = 1;
         continue;
      }

      if (opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
         continue;
      }

      if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
         return -1;
      }

      if (opcode != AST_WEBSOCKET_OPCODE_TEXT) {
         ast_log(LOG_ERROR, "Client WebSocket string read - "
            "non string data received\n");
         return -1;
      }
   }

   if (!(*buf = ast_strndup(payload, payload_len))) {
      return -1;
   }

   return payload_len + 1;
}

ast_websocket_reconstruct_disable()

void AST_OPTIONAL_API_NAME() ast_websocket_reconstruct_disable

(

struct ast_websocket *

session

)

Definition at line 446 of file res_http_websocket.c.

References ast_websocket::reconstruct.

{
   session->reconstruct = 0;
}

ast_websocket_reconstruct_enable()

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

Definition at line 441 of file res_http_websocket.c.

References MAXIMUM_RECONSTRUCTION_CEILING, MIN, and ast_websocket::reconstruct.

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

ast_websocket_ref()

void AST_OPTIONAL_API_NAME() ast_websocket_ref

(

struct ast_websocket *

session

)

Definition at line 451 of file res_http_websocket.c.

References ao2_ref.

Referenced by copy_socket_data(), and transport_create().

{
   ao2_ref(session, +1);
}

ast_websocket_remote_address()

struct ast_sockaddr* AST_OPTIONAL_API_NAME() ast_websocket_remote_address

(

struct ast_websocket *

session

)

Definition at line 471 of file res_http_websocket.c.

References ast_websocket::remote_address.

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

{
   return &session->remote_address;
}

ast_websocket_remove_protocol()

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

Definition at line 1081 of file res_http_websocket.c.

References name, and websocket_remove_protocol_internal().

Referenced by reload_config(), and unload_module().

{
   return websocket_remove_protocol_internal(name, callback);
}

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
	)

Definition at line 210 of file res_http_websocket.c.

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

{
   struct ast_websocket_protocol *protocol;

   if (!server->protocols) {
      return -1;
   }

   protocol = ast_websocket_sub_protocol_alloc(name);
   if (!protocol) {
      return -1;
   }
   protocol->session_established = callback;

   if (ast_websocket_server_add_protocol2(server, protocol)) {
      ao2_ref(protocol, -1);
      return -1;
   }

   return 0;
}

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
	)

Definition at line 232 of file res_http_websocket.c.

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

{
   struct ast_websocket_protocol *existing;

   if (!server->protocols) {
      return -1;
   }

   if (protocol->version != AST_WEBSOCKET_PROTOCOL_VERSION) {
      ast_log(LOG_WARNING, "WebSocket could not register sub-protocol '%s': "
         "expected version '%u', got version '%u'\n",
         protocol->name, AST_WEBSOCKET_PROTOCOL_VERSION, protocol->version);
      return -1;
   }

   ao2_lock(server->protocols);

   /* Ensure a second protocol handler is not registered for the same protocol */
   existing = ao2_find(server->protocols, protocol->name, OBJ_KEY | OBJ_NOLOCK);
   if (existing) {
      ao2_ref(existing, -1);
      ao2_unlock(server->protocols);
      return -1;
   }

   ao2_link_flags(server->protocols, protocol, OBJ_NOLOCK);
   ao2_unlock(server->protocols);

   ast_verb(2, "WebSocket registered sub-protocol '%s'\n", protocol->name);
   ao2_ref(protocol, -1);

   return 0;
}

ast_websocket_server_create()

struct ast_websocket_server* AST_OPTIONAL_API_NAME() ast_websocket_server_create

(

void

)

Definition at line 167 of file res_http_websocket.c.

References websocket_server_create_impl().

Referenced by load_module().

{
   return websocket_server_create_impl();
}

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
	)

Definition at line 266 of file res_http_websocket.c.

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

{
   struct ast_websocket_protocol *protocol;

   if (!(protocol = ao2_find(server->protocols, name, OBJ_KEY))) {
      return -1;
   }

   if (protocol->session_established != callback) {
      ao2_ref(protocol, -1);
      return -1;
   }

   ao2_unlink(server->protocols, protocol);
   ao2_ref(protocol, -1);

   ast_verb(2, "WebSocket unregistered sub-protocol '%s'\n", name);

   return 0;
}

ast_websocket_session_id()

const char* AST_OPTIONAL_API_NAME() ast_websocket_session_id

(

struct ast_websocket *

session

)

Definition at line 500 of file res_http_websocket.c.

References ast_websocket::session_id.

Referenced by ast_ari_websocket_session_id().

{
   return session->session_id;
}

ast_websocket_set_nonblock()

int AST_OPTIONAL_API_NAME() ast_websocket_set_nonblock

(

struct ast_websocket *

session

)

Definition at line 486 of file res_http_websocket.c.

References ast_iostream_nonblock(), ast_iostream_set_exclusive_input(), and ast_websocket::stream.

Referenced by ast_ari_websocket_session_create(), sip_websocket_callback(), and websocket_cb().

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

ast_websocket_set_timeout()

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

Definition at line 493 of file res_http_websocket.c.

References ast_websocket::timeout.

Referenced by ast_ari_websocket_session_create(), sip_websocket_callback(), and websocket_cb().

{
   session->timeout = timeout;

   return 0;
}

ast_websocket_sub_protocol_alloc()

struct ast_websocket_protocol* AST_OPTIONAL_API_NAME() ast_websocket_sub_protocol_alloc

(

const char *

name

)

Definition at line 191 of file res_http_websocket.c.

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

{
   struct ast_websocket_protocol *protocol;

   protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn);
   if (!protocol) {
      return NULL;
   }

   protocol->name = ast_strdup(name);
   if (!protocol->name) {
      ao2_ref(protocol, -1);
      return NULL;
   }
   protocol->version = AST_WEBSOCKET_PROTOCOL_VERSION;

   return protocol;
}

ast_websocket_unref()

void AST_OPTIONAL_API_NAME() ast_websocket_unref

(

struct ast_websocket *

session

)

Definition at line 456 of file res_http_websocket.c.

References ao2_cleanup.

Referenced by ast_ari_events_event_websocket_ws_established_cb(), copy_socket_data(), expire_register(), parse_moved_contact(), set_socket_transport(), sip_destroy_peer(), sip_pvt_dtor(), sip_websocket_callback(), transport_dtor(), websocket_cb(), websocket_echo_callback(), and websocket_session_dtor().

{
   ao2_cleanup(session);
}

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
	)

Definition at line 790 of file res_http_websocket.c.

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, ast_websocket::local_address, LOG_WARNING, method, ast_variable::name, ast_websocket_protocol::name, ast_variable::next, NULL, OBJ_KEY, one_protocol(), ast_websocket::opcode, ast_websocket_server::protocols, ast_websocket::reconstruct, ast_websocket::remote_address, ast_tcptls_session_instance::remote_address, SCOPED_MODULE_USE, ast_websocket::secure, ast_module_info::self, session, ast_websocket_protocol::session_attempted, session_destroy_fn(), ast_websocket_protocol::session_established, ast_websocket::session_id, ast_websocket::stream, ast_tcptls_session_instance::stream, strsep(), ast_websocket::timeout, 210693f3123d_create_cdr_table::upgrade(), ast_variable::value, version, websocket_bad_request(), websocket_combine_key(), and WEBSOCKET_GUID.

Referenced by ari_handle_websocket().

{
   struct ast_variable *v;
   const char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL;
   char *requested_protocols = NULL, *protocol = NULL;
   int version = 0, flags = 1;
   struct ast_websocket_protocol *protocol_handler = NULL;
   struct ast_websocket *session;
   struct ast_websocket_server *server;

   SCOPED_MODULE_USE(ast_module_info->self);

   /* Upgrade requests are only permitted on GET methods */
   if (method != AST_HTTP_GET) {
      ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
      return 0;
   }

   server = urih->data;

   /* Get the minimum headers required to satisfy our needs */
   for (v = headers; v; v = v->next) {
      if (!strcasecmp(v->name, "Upgrade")) {
         upgrade = v->value;
      } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
         key = v->value;
      } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
         key1 = v->value;
      } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
         key2 = v->value;
      } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
         protos = v->value;
      } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
         if (sscanf(v->value, "%30d", &version) != 1) {
            version = 0;
         }
      }
   }

   /* If this is not a websocket upgrade abort */
   if (!upgrade || strcasecmp(upgrade, "websocket")) {
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
         ast_sockaddr_stringify(&ser->remote_address));
      ast_http_error(ser, 426, "Upgrade Required", NULL);
      return 0;
   } else if (ast_strlen_zero(protos)) {
      /* If there's only a single protocol registered, and the
       * client doesn't specify what protocol it's using, go ahead
       * and accept the connection */
      protocol_handler = one_protocol(server);
      if (!protocol_handler) {
         /* Multiple registered subprotocols; client must specify */
         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
            ast_sockaddr_stringify(&ser->remote_address));
         websocket_bad_request(ser);
         return 0;
      }
   } else if (key1 && key2) {
      /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
       * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
         ast_sockaddr_stringify(&ser->remote_address));
      websocket_bad_request(ser);
      return 0;
   }

   if (!protocol_handler && protos) {
      requested_protocols = ast_strdupa(protos);
      /* Iterate through the requested protocols trying to find one that we have a handler for */
      while (!protocol_handler && (protocol = strsep(&requested_protocols, ","))) {
         protocol_handler = ao2_find(server->protocols, ast_strip(protocol), OBJ_KEY);
      }
   }

   /* If no protocol handler exists bump this back to the requester */
   if (!protocol_handler) {
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
         ast_sockaddr_stringify(&ser->remote_address), protos);
      websocket_bad_request(ser);
      return 0;
   }

   /* Determine how to respond depending on the version */
   if (version == 7 || version == 8 || version == 13) {
      char base64[64];

      if (!key || strlen(key) + strlen(WEBSOCKET_GUID) + 1 > 8192) { /* no stack overflows please */
         websocket_bad_request(ser);
         ao2_ref(protocol_handler, -1);
         return 0;
      }

      if (ast_http_body_discard(ser)) {
         websocket_bad_request(ser);
         ao2_ref(protocol_handler, -1);
         return 0;
      }

      if (!(session = ao2_alloc(sizeof(*session) + AST_UUID_STR_LEN + 1, session_destroy_fn))) {
         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
            ast_sockaddr_stringify(&ser->remote_address));
         websocket_bad_request(ser);
         ao2_ref(protocol_handler, -1);
         return 0;
      }
      session->timeout = AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT;

      /* Generate the session id */
      if (!ast_uuid_generate_str(session->session_id, sizeof(session->session_id))) {
         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to generate a session id\n",
            ast_sockaddr_stringify(&ser->remote_address));
         ast_http_error(ser, 500, "Internal Server Error", "Allocation failed");
         ao2_ref(protocol_handler, -1);
         return 0;
      }

      if (protocol_handler->session_attempted
          && protocol_handler->session_attempted(ser, get_vars, headers, session->session_id)) {
         ast_debug(3, "WebSocket connection from '%s' rejected by protocol handler '%s'\n",
            ast_sockaddr_stringify(&ser->remote_address), protocol_handler->name);
         websocket_bad_request(ser);
         ao2_ref(protocol_handler, -1);
         return 0;
      }

      /* RFC 6455, Section 4.1:
       *
       * 6. If the response includes a |Sec-WebSocket-Protocol| header
       *    field and this header field indicates the use of a
       *    subprotocol that was not present in the client's handshake
       *    (the server has indicated a subprotocol not requested by
       *    the client), the client MUST _Fail the WebSocket
       *    Connection_.
       */
      if (protocol) {
         ast_iostream_printf(ser->stream,
            "HTTP/1.1 101 Switching Protocols\r\n"
            "Upgrade: %s\r\n"
            "Connection: Upgrade\r\n"
            "Sec-WebSocket-Accept: %s\r\n"
            "Sec-WebSocket-Protocol: %s\r\n\r\n",
            upgrade,
            websocket_combine_key(key, base64, sizeof(base64)),
            protocol);
      } else {
         ast_iostream_printf(ser->stream,
            "HTTP/1.1 101 Switching Protocols\r\n"
            "Upgrade: %s\r\n"
            "Connection: Upgrade\r\n"
            "Sec-WebSocket-Accept: %s\r\n\r\n",
            upgrade,
            websocket_combine_key(key, base64, sizeof(base64)));
      }
   } else {

      /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
         ast_sockaddr_stringify(&ser->remote_address), version ? version : 75);
      websocket_bad_request(ser);
      ao2_ref(protocol_handler, -1);
      return 0;
   }

   /* Enable keepalive on all sessions so the underlying user does not have to */
   if (setsockopt(ast_iostream_get_fd(ser->stream), SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
         ast_sockaddr_stringify(&ser->remote_address));
      websocket_bad_request(ser);
      ao2_ref(session, -1);
      ao2_ref(protocol_handler, -1);
      return 0;
   }

   /* Get our local address for the connected socket */
   if (ast_getsockname(ast_iostream_get_fd(ser->stream), &session->local_address)) {
      ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to get local address\n",
         ast_sockaddr_stringify(&ser->remote_address));
      websocket_bad_request(ser);
      ao2_ref(session, -1);
      ao2_ref(protocol_handler, -1);
      return 0;
   }

   ast_verb(2, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol ? : "", version);

   /* Populate the session with all the needed details */
   session->stream = ser->stream;
   ast_sockaddr_copy(&session->remote_address, &ser->remote_address);
   session->opcode = -1;
   session->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
   session->secure = ast_iostream_get_ssl(ser->stream) ? 1 : 0;

   /* Give up ownership of the socket and pass it to the protocol handler */
   ast_iostream_set_exclusive_input(session->stream, 0);
   protocol_handler->session_established(session, get_vars, headers);
   ao2_ref(protocol_handler, -1);

   /*
    * By dropping the stream from the session the connection
    * won't get closed when the HTTP server cleans up because we
    * passed the connection to the protocol handler.
    */
   ser->stream = NULL;

   return 0;
}

ast_websocket_wait_for_input()

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

Definition at line 466 of file res_http_websocket.c.

References ast_iostream_wait_for_input(), ast_websocket::closing, ast_websocket::stream, and ast_websocket::timeout.

Referenced by websocket_cb(), and websocket_echo_callback().

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

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.

Definition at line 374 of file res_http_websocket.c.

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(), ast_websocket::client, ast_websocket::closing, frame_size, htonll(), ast_websocket::opcode, ast_websocket::payload, put_unaligned_uint16(), put_unaligned_uint64(), ast_websocket::stream, ast_websocket::timeout, websocket_mask_payload(), and websocket_opcode2str().

Referenced by ast_ari_events_event_websocket_ws_established_cb(), ast_websocket_read(), ast_websocket_write_string(), websocket_echo_callback(), and ws_send_msg().

{
   size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
   char *frame;
   uint64_t length;
   uint64_t frame_size;

   ast_debug(3, "Writing websocket %s frame, length %" PRIu64 "\n",
         websocket_opcode2str(opcode), payload_size);

   if (payload_size < 126) {
      length = payload_size;
   } else if (payload_size < (1 << 16)) {
      length = 126;
      /* We need an additional 2 bytes to store the extended length */
      header_size += 2;
   } else {
      length = 127;
      /* We need an additional 8 bytes to store the really really extended length */
      header_size += 8;
   }

   if (session->client) {
      /* Additional 4 bytes for the client masking key */
      header_size += 4;
   }

   frame_size = header_size + payload_size;

   frame = ast_alloca(frame_size + 1);
   memset(frame, 0, frame_size + 1);

   frame[0] = opcode | 0x80;
   frame[1] = length;

   /* Use the additional available bytes to store the length */
   if (length == 126) {
      put_unaligned_uint16(&frame[2], htons(payload_size));
   } else if (length == 127) {
      put_unaligned_uint64(&frame[2], htonll(payload_size));
   }

   memcpy(&frame[header_size], payload, payload_size);

   websocket_mask_payload(session, frame, &frame[header_size], payload_size);

   ao2_lock(session);
   if (session->closing) {
      ao2_unlock(session);
      return -1;
   }

   ast_iostream_set_timeout_sequence(session->stream, ast_tvnow(), session->timeout);
   if (ast_iostream_write(session->stream, frame, frame_size) != frame_size) {
      ao2_unlock(session);
      /* 1011 - server terminating connection due to not being able to fulfill the request */
      ast_debug(1, "Closing WS with 1011 because we can't fulfill a write request\n");
      ast_websocket_close(session, 1011);
      return -1;
   }

   ast_iostream_set_timeout_disable(session->stream);
   ao2_unlock(session);

   return 0;
}

ast_websocket_write_string()

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

Definition at line 1484 of file res_http_websocket.c.

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

Referenced by __sip_xmit(), __stub__ast_websocket_write(), ast_ari_websocket_session_write(), AST_TEST_DEFINE(), and ast_websocket_read_string().

{
   uint64_t len = strlen(buf);

   ast_debug(3, "Writing websocket string of length %" PRIu64 "\n", len);

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

load_module()

static int load_module ( void  )

static

Definition at line 1501 of file res_http_websocket.c.

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

Referenced by unload_module().

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

   return 0;
}

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.

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

Referenced by ast_websocket_uri_cb().

{
   SCOPED_AO2LOCK(lock, server->protocols);

   if (ao2_container_count(server->protocols) != 1) {
      return NULL;
   }

   return ao2_callback(server->protocols, OBJ_NOLOCK, NULL, NULL);
}

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.

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

Referenced by websocket_server_create_impl().

{
   const struct ast_websocket_protocol *protocol1 = obj, *protocol2 = arg;
   const char *protocol = arg;

   return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
}

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.

References ast_free, and ast_websocket_protocol::name.

Referenced by ast_websocket_sub_protocol_alloc().

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

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.

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

Referenced by websocket_server_create_impl().

{
   const struct ast_websocket_protocol *protocol = obj;
   const char *name = obj;

   return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
}

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.

References ao2_cleanup, ast_free, ast_iostream_close(), ast_sockaddr_stringify(), ast_verb, ast_websocket_close(), ast_websocket::client, ast_websocket::close_status_code, NULL, ast_websocket::payload, ast_websocket::remote_address, session, and ast_websocket::stream.

Referenced by ast_websocket_uri_cb(), and websocket_client_create().

{
   struct ast_websocket *session = obj;

   if (session->stream) {
      ast_websocket_close(session, session->close_status_code);
      if (session->stream) {
         ast_iostream_close(session->stream);
         session->stream = NULL;
         ast_verb(2, "WebSocket connection %s '%s' closed\n", session->client ? "to" : "from",
            ast_sockaddr_stringify(&session->remote_address));
      }
   }

   ao2_cleanup(session->client);
   ast_free(session->payload);
}

unload_module()

static int unload_module ( void  )

static

Definition at line 1513 of file res_http_websocket.c.

References ao2_ref, ast_http_uri_unlink(), AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DEPEND, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, ast_http_uri::data, load_module(), NULL, websocket_echo_callback(), and websocket_remove_protocol_internal().

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

   return 0;
}

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.

References ast_websocket_server_add_protocol(), and ast_http_uri::data.

Referenced by ast_websocket_add_protocol(), and load_module().

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

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.

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

{
   struct ast_str *http_header = ast_str_create(64);

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

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

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

Referenced by websocket_client_create().

{
   struct ast_sockaddr *addr;
   struct ast_tcptls_session_args *args = ao2_alloc(
      sizeof(*args), websocket_client_args_destroy);

   if (!args) {
      *result = WS_ALLOCATE_ERROR;
      return NULL;
   }

   args->accept_fd = -1;
   args->tls_cfg = tls_cfg;
   args->name = "websocket client";

   if (!ast_sockaddr_resolve(&addr, host, 0, 0)) {
      ast_log(LOG_ERROR, "Unable to resolve address %s\n",
         host);
      ao2_ref(args, -1);
      *result = WS_URI_RESOLVE_ERROR;
      return NULL;
   }
   ast_sockaddr_copy(&args->remote_address, addr);
   ast_free(addr);
   return args;
}

websocket_client_args_destroy()

static void websocket_client_args_destroy ( void *  obj )

static

Definition at line 1123 of file res_http_websocket.c.

References args, ast_free, ast_ssl_teardown(), ast_tls_config::cafile, ast_tls_config::capath, ast_tls_config::certfile, ast_tls_config::cipher, ast_tls_config::pvtfile, and ast_tcptls_session_args::tls_cfg.

Referenced by websocket_client_args_create().

{
   struct ast_tcptls_session_args *args = obj;

   if (args->tls_cfg) {
      ast_free(args->tls_cfg->certfile);
      ast_free(args->tls_cfg->pvtfile);
      ast_free(args->tls_cfg->cipher);
      ast_free(args->tls_cfg->cafile);
      ast_free(args->tls_cfg->capath);

      ast_ssl_teardown(args->tls_cfg);
   }
   ast_free(args->tls_cfg);
}

websocket_client_connect()

static enum ast_websocket_result websocket_client_connect ( struct ast_websocket *  ws )

static

Definition at line 1397 of file res_http_websocket.c.

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

Referenced by ast_websocket_client_create().

{
   enum ast_websocket_result res;
   /* create and connect the client - note client_start
      releases the session instance on failure */
   if (!(ws->client->ser = ast_tcptls_client_start(
            ast_tcptls_client_create(ws->client->args)))) {
      return WS_CLIENT_START_ERROR;
   }

   if ((res = websocket_client_handshake(ws->client)) != WS_OK) {
      ao2_ref(ws->client->ser, -1);
      ws->client->ser = NULL;
      return res;
   }

   ws->stream = ws->client->ser->stream;
   ws->secure = ast_iostream_get_ssl(ws->stream) ? 1 : 0;
   ws->client->ser->stream = NULL;
   ast_sockaddr_copy(&ws->remote_address, &ws->client->ser->remote_address);
   return WS_OK;
}

websocket_client_create()

static struct ast_websocket* websocket_client_create ( const char *  uri, const char *  protocols, struct ast_tls_config *  tls_cfg, enum ast_websocket_result *  result  )

static

Definition at line 1224 of file res_http_websocket.c.

References ao2_alloc, ao2_ref, websocket_client::args, ast_log, AST_OPTIONAL_API_NAME, ast_strdup, ast_websocket::client, DEFAULT_RECONSTRUCTION_CEILING, websocket_client::host, websocket_client::key, LOG_ERROR, NULL, ast_websocket::opcode, websocket_client::protocols, ast_websocket::reconstruct, websocket_client::resource_name, 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().

{
   struct ast_websocket *ws = ao2_alloc(sizeof(*ws), session_destroy_fn);

   if (!ws) {
      ast_log(LOG_ERROR, "Unable to allocate websocket\n");
      *result = WS_ALLOCATE_ERROR;
      return NULL;
   }

   if (!(ws->client = ao2_alloc(
            sizeof(*ws->client), websocket_client_destroy))) {
      ast_log(LOG_ERROR, "Unable to allocate websocket client\n");
      *result = WS_ALLOCATE_ERROR;
      return NULL;
   }

   if (!(ws->client->key = websocket_client_create_key())) {
      ao2_ref(ws, -1);
      *result = WS_KEY_ERROR;
      return NULL;
   }

   if (websocket_client_parse_uri(
          uri, &ws->client->host, &ws->client->resource_name)) {
      ao2_ref(ws, -1);
      *result = WS_URI_PARSE_ERROR;
      return NULL;
   }

   if (!(ws->client->args = websocket_client_args_create(
            ws->client->host, tls_cfg, result))) {
      ao2_ref(ws, -1);
      return NULL;
   }
   ws->client->protocols = ast_strdup(protocols);

   ws->client->version = 13;
   ws->opcode = -1;
   ws->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
   return ws;
}

websocket_client_create_key()

static char* websocket_client_create_key ( void  )

static

Definition at line 1168 of file res_http_websocket.c.

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

Referenced by websocket_client_create().

{
   static int encoded_size = CLIENT_KEY_SIZE * 2 * sizeof(char) + 1;
   /* key is randomly selected 16-byte base64 encoded value */
   unsigned char key[CLIENT_KEY_SIZE + sizeof(long) - 1];
   char *encoded = ast_malloc(encoded_size);
   long i = 0;

   if (!encoded) {
      ast_log(LOG_ERROR, "Unable to allocate client websocket key\n");
      return NULL;
   }

   while (i < CLIENT_KEY_SIZE) {
      long num = ast_random();
      memcpy(key + i, &num, sizeof(long));
      i += sizeof(long);
   }

   ast_base64encode(encoded, key, CLIENT_KEY_SIZE, encoded_size);
   return encoded;
}

websocket_client_destroy()

static void websocket_client_destroy ( void *  obj )

static

Definition at line 1210 of file res_http_websocket.c.

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

Referenced by websocket_client_create().

{
   struct websocket_client *client = obj;

   ao2_cleanup(client->ser);
   ao2_cleanup(client->args);

   ast_free(client->accept_protocol);
   ast_free(client->protocols);
   ast_free(client->key);
   ast_free(client->resource_name);
   ast_free(client->host);
}

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

References ast_log, websocket_client::host, LOG_ERROR, WS_BAD_REQUEST, WS_INVALID_RESPONSE, and WS_URL_NOT_FOUND.

Referenced by websocket_client_handshake_get_response().

{
   if (response_code <= 0) {
      return WS_INVALID_RESPONSE;
   }

   switch (response_code) {
   case 101:
      return 0;
   case 400:
      ast_log(LOG_ERROR, "Received response 400 - Bad Request "
         "- from %s\n", client->host);
      return WS_BAD_REQUEST;
   case 404:
      ast_log(LOG_ERROR, "Received response 404 - Request URL not "
         "found - from %s\n", client->host);
      return WS_URL_NOT_FOUND;
   }

   ast_log(LOG_ERROR, "Invalid HTTP response code %d from %s\n",
      response_code, client->host);
   return WS_INVALID_RESPONSE;
}

websocket_client_handshake()

static enum ast_websocket_result websocket_client_handshake ( struct websocket_client *  client )

static

Definition at line 1367 of file res_http_websocket.c.

References ast_iostream_printf(), ast_log, ast_str_buffer(), ast_strlen_zero, 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().

{
   char protocols[100] = "";

   if (!ast_strlen_zero(client->protocols)) {
      sprintf(protocols, "Sec-WebSocket-Protocol: %s\r\n",
         client->protocols);
   }

   if (ast_iostream_printf(client->ser->stream,
         "GET /%s HTTP/1.1\r\n"
         "Sec-WebSocket-Version: %d\r\n"
         "Upgrade: websocket\r\n"
         "Connection: Upgrade\r\n"
         "Host: %s\r\n"
         "Sec-WebSocket-Key: %s\r\n"
         "%s\r\n",
         client->resource_name ? ast_str_buffer(client->resource_name) : "",
         client->version,
         client->host,
         client->key,
         protocols) < 0) {
      ast_log(LOG_ERROR, "Failed to send handshake.\n");
      return WS_WRITE_ERROR;
   }
   /* wait for a response before doing anything else */
   return websocket_client_handshake_get_response(client);
}

websocket_client_handshake_get_response()

static enum ast_websocket_result websocket_client_handshake_get_response ( struct websocket_client *  client )

static

Definition at line 1300 of file res_http_websocket.c.

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, ast_websocket::buf, websocket_client::key, 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().

{
   enum ast_websocket_result res;
   char buf[4096];
   char base64[64];
   int has_upgrade = 0;
   int has_connection = 0;
   int has_accept = 0;
   int has_protocol = 0;

   if (ast_iostream_gets(client->ser->stream, buf, sizeof(buf)) <= 0) {
      ast_log(LOG_ERROR, "Unable to retrieve HTTP status line.");
      return WS_BAD_STATUS;
   }

   if ((res = websocket_client_handle_response_code(client,
          ast_http_response_status_line(
             buf, "HTTP/1.1", 101))) != WS_OK) {
      return res;
   }

   /* Ignoring line folding - assuming header field values are contained
      within a single line */
   while (ast_iostream_gets(client->ser->stream, buf, sizeof(buf)) > 0) {
      char *name, *value;
      int parsed = ast_http_header_parse(buf, &name, &value);

      if (parsed < 0) {
         break;
      }

      if (parsed > 0) {
         continue;
      }

      if (!has_upgrade &&
          (has_upgrade = ast_http_header_match(
             name, "upgrade", value, "websocket")) < 0) {
         return WS_HEADER_MISMATCH;
      } else if (!has_connection &&
            (has_connection = ast_http_header_match(
               name, "connection", value, "upgrade")) < 0) {
         return WS_HEADER_MISMATCH;
      } else if (!has_accept &&
            (has_accept = ast_http_header_match(
               name, "sec-websocket-accept", value,
             websocket_combine_key(
                client->key, base64, sizeof(base64)))) < 0) {
         return WS_HEADER_MISMATCH;
      } else if (!has_protocol &&
            (has_protocol = ast_http_header_match_in(
               name, "sec-websocket-protocol", value, client->protocols))) {
         if (has_protocol < 0) {
            return WS_HEADER_MISMATCH;
         }
         client->accept_protocol = ast_strdup(value);
      } else if (!strcasecmp(name, "sec-websocket-extensions")) {
         ast_log(LOG_ERROR, "Extensions received, but not "
            "supported by client\n");
         return WS_NOT_SUPPORTED;
      }
   }
   return has_upgrade && has_connection && has_accept ?
      WS_OK : WS_HEADER_MISSING;
}

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

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

Referenced by websocket_client_create().

{
   struct ast_uri *parsed_uri = ast_uri_parse_websocket(uri);

   if (!parsed_uri) {
      return -1;
   }

   *host = ast_uri_make_host_with_port(parsed_uri);

   if (ast_uri_path(parsed_uri) || ast_uri_query(parsed_uri)) {
      *path = ast_str_create(64);
      if (!*path) {
         ao2_ref(parsed_uri, -1);
         return -1;
      }

      if (ast_uri_path(parsed_uri)) {
         ast_str_set(path, 0, "%s", ast_uri_path(parsed_uri));
      }

      if (ast_uri_query(parsed_uri)) {
         ast_str_append(path, 0, "?%s", ast_uri_query(parsed_uri));
      }
   }

   ao2_ref(parsed_uri, -1);
   return 0;
}

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.

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

Referenced by ast_websocket_uri_cb(), and websocket_client_handshake_get_response().

{
   char *combined;
   unsigned combined_length = strlen(key) + strlen(WEBSOCKET_GUID) + 1;
   uint8_t sha[20];

   combined = ast_alloca(combined_length);
   snprintf(combined, combined_length, "%s%s", key, WEBSOCKET_GUID);
   ast_sha1_hash_uint(sha, combined);
   ast_base64encode(res, (const unsigned char*)sha, 20, res_size);
   return res;
}

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.

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, ast_websocket::opcode, ast_websocket::payload, and ast_websocket::payload_len.

Referenced by load_module(), and unload_module().

{
   int res;

   ast_debug(1, "Entering WebSocket echo loop\n");

   if (ast_fd_set_flags(ast_websocket_fd(session), O_NONBLOCK)) {
      goto end;
   }

   while ((res = ast_websocket_wait_for_input(session, -1)) > 0) {
      char *payload;
      uint64_t payload_len;
      enum ast_websocket_opcode opcode;
      int fragmented;

      if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
         /* We err on the side of caution and terminate the session if any error occurs */
         ast_log(LOG_WARNING, "Read failure during WebSocket echo loop\n");
         break;
      }

      if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
         ast_websocket_write(session, opcode, payload, payload_len);
      } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
         break;
      } else {
         ast_debug(1, "Ignored WebSocket opcode %u\n", opcode);
      }
   }

end:
   ast_debug(1, "Exiting WebSocket echo loop\n");
   ast_websocket_unref(session);
}

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.

References ast_random(), ast_websocket::client, and put_unaligned_uint32().

Referenced by ast_websocket_close(), and ast_websocket_write().

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

websocket_opcode2str()

static const char* websocket_opcode2str ( enum ast_websocket_opcode  opcode )

static

Definition at line 363 of file res_http_websocket.c.

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

Referenced by ast_websocket_write().

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

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.

References ast_websocket_server_remove_protocol(), and ast_http_uri::data.

Referenced by ast_websocket_remove_protocol(), and unload_module().

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

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.

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

{
   RAII_VAR(struct ast_websocket_server *, server, NULL, ao2_cleanup);

   server = ao2_alloc(sizeof(*server), websocket_server_dtor);
   if (!server) {
      return NULL;
   }

   server->protocols = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
      MAX_PROTOCOL_BUCKETS, protocol_hash_fn, NULL, protocol_cmp_fn);
   if (!server->protocols) {
      return NULL;
   }

   ao2_ref(server, +1);
   return server;
}

websocket_server_dtor()

static void websocket_server_dtor ( void *  obj )

static

Definition at line 136 of file res_http_websocket.c.

References ao2_cleanup, NULL, and ast_websocket_server::protocols.

Referenced by websocket_server_create_impl().

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

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.

References websocket_server_create_impl().

Referenced by load_module().

{
   return websocket_server_create_impl();
}

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.

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

Referenced by ast_websocket_read().

{
   ssize_t rlen;
   int xlen = len;
   char *rbuf = buf;
   int sanity = 10;

   ast_assert(len > 0);

   if (!len) {
      errno = EINVAL;
      return -1;
   }

   ao2_lock(session);
   if (!session->stream) {
      ao2_unlock(session);
      errno = ECONNABORTED;
      return -1;
   }

   for (;;) {
      rlen = ast_iostream_read(session->stream, rbuf, xlen);
      if (rlen != xlen) {
         if (rlen == 0) {
            ast_log(LOG_WARNING, "Web socket closed abruptly\n");
            *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
            session->closing = 1;
            ao2_unlock(session);
            return -1;
         }

         if (rlen < 0 && errno != EAGAIN) {
            ast_log(LOG_ERROR, "Error reading from web socket: %s\n", strerror(errno));
            *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
            session->closing = 1;
            ao2_unlock(session);
            return -1;
         }

         if (!--sanity) {
            ast_log(LOG_WARNING, "Websocket seems unresponsive, disconnecting ...\n");
            *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
            session->closing = 1;
            ao2_unlock(session);
            return -1;
         }
      }
      if (rlen > 0) {
         xlen = xlen - rlen;
         rbuf = rbuf + rlen;
         if (!xlen) {
            break;
         }
      }
      if (ast_iostream_wait_for_input(session->stream, 1000) < 0) {
         ast_log(LOG_ERROR, "ast_iostream_wait_for_input returned err: %s\n", strerror(errno));
         *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
         session->closing = 1;
         ao2_unlock(session);
         return -1;
      }
   }

   ao2_unlock(session);
   return 0;
}

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 = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_CHANNEL_DEPEND, .requires = "http", }

static

Definition at line 1529 of file res_http_websocket.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

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

Definition at line 997 of file res_http_websocket.c.