res_pjsip_transport_websocket.c File Reference

#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include "asterisk/module.h"
#include "asterisk/http_websocket.h"
#include "asterisk/res_pjsip.h"
#include "asterisk/res_pjsip_session.h"
#include "asterisk/taskprocessor.h"

Include dependency graph for res_pjsip_transport_websocket.c:

Go to the source code of this file.

Data Structures
struct	transport_create_data
struct	transport_read_data
struct	ws_transport
	Wrapper for pjsip_transport, for storing the WebSocket session. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct ast_taskprocessor *	create_websocket_serializer (void)
static int	get_write_timeout (void)
static int	load_module (void)
static int	transport_create (void *data)
	Create a pjsip transport. More...
static void	transport_dtor (void *arg)
static int	transport_read (void *data)
	Pass WebSocket data into pjsip transport manager. More...
static int	transport_shutdown (void *data)
static int	unload_module (void)
static void	websocket_cb (struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
	WebSocket connection handler. More...
static pj_bool_t	websocket_on_rx_msg (pjsip_rx_data *rdata)
	Store the transport a message came in on, so it can be used for outbound messages to that contact. More...
static void	websocket_outgoing_invite_request (struct ast_sip_session *session, struct pjsip_tx_data *tdata)
	Function called when an INVITE goes out. More...
static pj_status_t	ws_destroy (pjsip_transport *transport)
	Destroy the pjsip transport. More...
static pj_status_t	ws_send_msg (pjsip_transport *transport, pjsip_tx_data *tdata, const pj_sockaddr_t *rem_addr, int addr_len, void *token, pjsip_transport_callback callback)
	Send a message over the WebSocket connection. More...

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP WebSocket Transport 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_APP_DEPEND, .requires = "res_pjsip,res_http_websocket", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static int	transport_type_wss
	WebSocket transport module. More...
static int	transport_type_wss_ipv6
static pjsip_module	websocket_module
static struct ast_sip_session_supplement	websocket_supplement
	Supplement for adding Websocket functionality to dialog. More...
static int	ws_obj_name_serial

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 535 of file res_pjsip_transport_websocket.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 535 of file res_pjsip_transport_websocket.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 535 of file res_pjsip_transport_websocket.c.

create_websocket_serializer()

static struct ast_taskprocessor* create_websocket_serializer ( void  )

static

Definition at line 349 of file res_pjsip_transport_websocket.c.

References ast_sip_create_serializer(), ast_taskprocessor_build_name(), and AST_TASKPROCESSOR_MAX_NAME.

Referenced by websocket_cb().

{
   char tps_name[AST_TASKPROCESSOR_MAX_NAME + 1];

   /* Create name with seq number appended. */
   ast_taskprocessor_build_name(tps_name, sizeof(tps_name), "pjsip/websocket");

   return ast_sip_create_serializer(tps_name);
}

get_write_timeout()

static int get_write_timeout ( void  )

static

Definition at line 311 of file res_pjsip_transport_websocket.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_debug, AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT, ast_sip_get_sorcery(), ast_sip_get_transport_states(), ast_sorcery_retrieve_by_id(), AST_TRANSPORT_WS, AST_TRANSPORT_WSS, ast_sip_transport_state::id, MAX, ws_transport::transport, transport_states, ast_sip_transport_state::type, ast_sip_transport::type, and ast_sip_transport::write_timeout.

Referenced by websocket_cb().

{
   int write_timeout = -1;
   struct ao2_container *transport_states;

   transport_states = ast_sip_get_transport_states();

   if (transport_states) {
      struct ao2_iterator it_transport_states = ao2_iterator_init(transport_states, 0);
      struct ast_sip_transport_state *transport_state;

      for (; (transport_state = ao2_iterator_next(&it_transport_states)); ao2_cleanup(transport_state)) {
         struct ast_sip_transport *transport;

         if (transport_state->type != AST_TRANSPORT_WS && transport_state->type != AST_TRANSPORT_WSS) {
            continue;
         }
         transport = ast_sorcery_retrieve_by_id(ast_sip_get_sorcery(), "transport", transport_state->id);
         if (!transport) {
            continue;
         }
         ast_debug(5, "Found %s transport with write timeout: %d\n",
            transport->type == AST_TRANSPORT_WS ? "WS" : "WSS",
            transport->write_timeout);
         write_timeout = MAX(write_timeout, transport->write_timeout);
      }
      ao2_iterator_destroy(&it_transport_states);
      ao2_cleanup(transport_states);
   }

   if (write_timeout < 0) {
      write_timeout = AST_DEFAULT_WEBSOCKET_WRITE_TIMEOUT;
   }

   ast_debug(1, "Write timeout for WS/WSS transports: %d\n", write_timeout);
   return write_timeout;
}

load_module()

static int load_module ( void  )

static

Definition at line 490 of file res_pjsip_transport_websocket.c.

References AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_sip_register_service(), ast_sip_session_register_supplement, ast_sip_session_unregister_supplement(), ast_sip_unregister_service(), ast_websocket_add_protocol(), transport_type_wss, transport_type_wss_ipv6, websocket_cb(), and websocket_module.

Referenced by unload_module().

{
   /*
    * We only need one transport type name (ws) defined.  Firefox
    * and Chrome do not support anything other than secure websockets
    * anymore.
    *
    * Also we really cannot have two transports with the same name
    * and address family because it would be ambiguous.  Outgoing
    * requests may try to find the transport by name and pjproject
    * only finds the first one registered.
    */
   pjsip_transport_register_type(PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE, "ws", 5060, &transport_type_wss);
   pjsip_transport_register_type(PJSIP_TRANSPORT_RELIABLE | PJSIP_TRANSPORT_SECURE | PJSIP_TRANSPORT_IPV6, "ws", 5060, &transport_type_wss_ipv6);

   if (ast_sip_register_service(&websocket_module) != PJ_SUCCESS) {
      return AST_MODULE_LOAD_DECLINE;
   }

   ast_sip_session_register_supplement(&websocket_supplement);

   if (ast_websocket_add_protocol("sip", websocket_cb)) {
      ast_sip_session_unregister_supplement(&websocket_supplement);
      ast_sip_unregister_service(&websocket_module);
      return AST_MODULE_LOAD_DECLINE;
   }

   return AST_MODULE_LOAD_SUCCESS;
}

transport_create()

static int transport_create ( void *  data )

static

Create a pjsip transport.

Definition at line 149 of file res_pjsip_transport_websocket.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_cleanup, ao2_ref, ao2_t_alloc_options, ast_atomic_fetchadd_int(), ast_debug, ast_log, ast_sip_get_pjsip_endpoint(), ast_sockaddr_port, ast_sockaddr_stringify(), ast_sockaddr_stringify_addr(), ast_websocket_is_secure(), ast_websocket_local_address(), ast_websocket_ref(), ast_websocket_remote_address(), buf, LOG_ERROR, NULL, pool, status, ws_transport::transport, transport_create_data::transport, transport_dtor(), transport_type_wss, transport_type_wss_ipv6, ws_destroy(), ws_obj_name_serial, ws_send_msg(), ws_transport::ws_session, and transport_create_data::ws_session.

Referenced by websocket_cb().

{
   struct transport_create_data *create_data = data;
   struct ws_transport *newtransport = NULL;
   pjsip_tp_state_callback state_cb;

   pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
   struct pjsip_tpmgr *tpmgr = pjsip_endpt_get_tpmgr(endpt);

   char *ws_addr_str;
   pj_pool_t *pool;
   pj_str_t buf;
   pj_status_t status;

   newtransport = ao2_t_alloc_options(sizeof(*newtransport), transport_dtor,
         AO2_ALLOC_OPT_LOCK_NOLOCK, "pjsip websocket transport");
   if (!newtransport) {
      ast_log(LOG_ERROR, "Failed to allocate WebSocket transport.\n");
      goto on_error;
   }

   /* Give websocket transport a unique name for its lifetime */
   snprintf(newtransport->transport.obj_name, PJ_MAX_OBJ_NAME, "ws%p-%d",
      &newtransport->transport, ast_atomic_fetchadd_int(&ws_obj_name_serial, 1));

   newtransport->transport.endpt = endpt;

   if (!(pool = pjsip_endpt_create_pool(endpt, "ws", 512, 512))) {
      ast_log(LOG_ERROR, "Failed to allocate WebSocket endpoint pool.\n");
      goto on_error;
   }

   newtransport->transport.pool = pool;
   newtransport->ws_session = create_data->ws_session;

   /* Keep the session until transport dies */
   ast_websocket_ref(newtransport->ws_session);

   status = pj_atomic_create(pool, 0, &newtransport->transport.ref_cnt);
   if (status != PJ_SUCCESS) {
      goto on_error;
   }

   status = pj_lock_create_recursive_mutex(pool, pool->obj_name, &newtransport->transport.lock);
   if (status != PJ_SUCCESS) {
      goto on_error;
   }

   /*
    * The type_name here is mostly used by log messages eihter in
    * pjproject or Asterisk.  Other places are reconstituting subscriptions
    * after a restart (which could never work for a websocket connection anyway),
    * received MESSAGE requests to set PJSIP_TRANSPORT, and most importantly
    * by pjproject when generating the Via header.
    */
   newtransport->transport.type_name = ast_websocket_is_secure(newtransport->ws_session)
      ? "WSS" : "WS";

   ws_addr_str = ast_sockaddr_stringify(ast_websocket_remote_address(newtransport->ws_session));
   ast_debug(4, "Creating websocket transport for %s:%s\n",
      newtransport->transport.type_name, ws_addr_str);

   newtransport->transport.info = (char *) pj_pool_alloc(newtransport->transport.pool,
      strlen(newtransport->transport.type_name) + strlen(ws_addr_str) + sizeof(" to "));
   sprintf(newtransport->transport.info, "%s to %s", newtransport->transport.type_name, ws_addr_str);

   pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ws_addr_str), &newtransport->transport.key.rem_addr);
   if (newtransport->transport.key.rem_addr.addr.sa_family == pj_AF_INET6()) {
      newtransport->transport.key.type = transport_type_wss_ipv6;
   } else {
      newtransport->transport.key.type = transport_type_wss;
   }

   newtransport->transport.addr_len = pj_sockaddr_get_len(&newtransport->transport.key.rem_addr);

   ws_addr_str = ast_sockaddr_stringify(ast_websocket_local_address(newtransport->ws_session));
   pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ws_addr_str), &newtransport->transport.local_addr);
   pj_strdup2(pool, &newtransport->transport.local_name.host, ast_sockaddr_stringify_addr(ast_websocket_local_address(newtransport->ws_session)));
   newtransport->transport.local_name.port = ast_sockaddr_port(ast_websocket_local_address(newtransport->ws_session));

   newtransport->transport.flag = pjsip_transport_get_flag_from_type((pjsip_transport_type_e)newtransport->transport.key.type);
   newtransport->transport.dir = PJSIP_TP_DIR_INCOMING;
   newtransport->transport.tpmgr = tpmgr;
   newtransport->transport.send_msg = &ws_send_msg;
   newtransport->transport.destroy = &ws_destroy;

   status = pjsip_transport_register(newtransport->transport.tpmgr,
         (pjsip_transport *)newtransport);
   if (status != PJ_SUCCESS) {
      goto on_error;
   }

   /* Add a reference for pjsip transport manager */
   ao2_ref(newtransport, +1);

   newtransport->rdata.tp_info.transport = &newtransport->transport;
   newtransport->rdata.tp_info.pool = pjsip_endpt_create_pool(endpt, "rtd%p",
      PJSIP_POOL_RDATA_LEN, PJSIP_POOL_RDATA_INC);
   if (!newtransport->rdata.tp_info.pool) {
      ast_log(LOG_ERROR, "Failed to allocate WebSocket rdata.\n");
      pjsip_transport_destroy((pjsip_transport *)newtransport);
      goto on_error;
   }

   create_data->transport = newtransport;

   /* Notify application of transport state */
   state_cb = pjsip_tpmgr_get_state_cb(newtransport->transport.tpmgr);
   if (state_cb) {
      pjsip_transport_state_info state_info;

      memset(&state_info, 0, sizeof(state_info));
      state_cb(&newtransport->transport, PJSIP_TP_STATE_CONNECTED, &state_info);
   }

   return 0;

on_error:
   ao2_cleanup(newtransport);
   return -1;
}

transport_dtor()

static void transport_dtor ( void *  arg )

static

Definition at line 100 of file res_pjsip_transport_websocket.c.

References ast_websocket_unref(), ws_transport::rdata, ws_transport::transport, and ws_transport::ws_session.

Referenced by transport_create().

{
   struct ws_transport *wstransport = arg;

   if (wstransport->ws_session) {
      ast_websocket_unref(wstransport->ws_session);
   }

   if (wstransport->transport.ref_cnt) {
      pj_atomic_destroy(wstransport->transport.ref_cnt);
   }

   if (wstransport->transport.lock) {
      pj_lock_destroy(wstransport->transport.lock);
   }

   if (wstransport->transport.endpt && wstransport->transport.pool) {
      pjsip_endpt_release_pool(wstransport->transport.endpt, wstransport->transport.pool);
   }

   if (wstransport->rdata.tp_info.pool) {
      pjsip_endpt_release_pool(wstransport->transport.endpt, wstransport->rdata.tp_info.pool);
   }
}

transport_read()

static int transport_read ( void *  data )

static

Pass WebSocket data into pjsip transport manager.

Definition at line 280 of file res_pjsip_transport_websocket.c.

References ast_sockaddr_port, ast_sockaddr_stringify(), ast_sockaddr_stringify_addr(), ast_websocket_remote_address(), buf, transport_read_data::payload, transport_read_data::payload_len, ws_transport::rdata, session, transport_read_data::transport, and ws_transport::ws_session.

Referenced by websocket_cb().

{
   struct transport_read_data *read_data = data;
   struct ws_transport *newtransport = read_data->transport;
   struct ast_websocket *session = newtransport->ws_session;

   pjsip_rx_data *rdata = &newtransport->rdata;
   int recvd;
   pj_str_t buf;
   int pjsip_pkt_len;

   pj_gettimeofday(&rdata->pkt_info.timestamp);

   pjsip_pkt_len = PJSIP_MAX_PKT_LEN < read_data->payload_len ? PJSIP_MAX_PKT_LEN : read_data->payload_len;
   pj_memcpy(rdata->pkt_info.packet, read_data->payload, pjsip_pkt_len);
   rdata->pkt_info.len = pjsip_pkt_len;
   rdata->pkt_info.zero = 0;

   pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ast_sockaddr_stringify(ast_websocket_remote_address(session))), &rdata->pkt_info.src_addr);
   rdata->pkt_info.src_addr_len = sizeof(rdata->pkt_info.src_addr);

   pj_ansi_strcpy(rdata->pkt_info.src_name, ast_sockaddr_stringify_addr(ast_websocket_remote_address(session)));
   rdata->pkt_info.src_port = ast_sockaddr_port(ast_websocket_remote_address(session));

   recvd = pjsip_tpmgr_receive_packet(rdata->tp_info.transport->tpmgr, rdata);

   pj_pool_reset(rdata->tp_info.pool);

   return (read_data->payload_len == recvd) ? 0 : -1;
}

transport_shutdown()

static int transport_shutdown ( void *  data )

static

Definition at line 125 of file res_pjsip_transport_websocket.c.

References ao2_ref, and ws_transport::transport.

Referenced by websocket_cb().

{
   struct ws_transport *wstransport = data;

   if (!wstransport->transport.is_shutdown && !wstransport->transport.is_destroying) {
      pjsip_transport_shutdown(&wstransport->transport);
   }

   /* Note that the destructor calls PJSIP functions,
    * therefore it must be called in a PJSIP thread.
    */
   ao2_ref(wstransport, -1);

   return 0;
}

unload_module()

static int unload_module ( void  )

static

Definition at line 520 of file res_pjsip_transport_websocket.c.

References AST_MODFLAG_LOAD_ORDER, AST_MODPRI_APP_DEPEND, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_sip_session_unregister_supplement(), ast_sip_unregister_service(), ast_websocket_remove_protocol(), ASTERISK_GPL_KEY, load_module(), websocket_cb(), and websocket_module.

{
   ast_sip_unregister_service(&websocket_module);
   ast_sip_session_unregister_supplement(&websocket_supplement);
   ast_websocket_remove_protocol("sip", websocket_cb);

   return 0;
}

websocket_cb()

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

static

WebSocket connection handler.

Definition at line 360 of file res_pjsip_transport_websocket.c.

References ast_log, ast_sip_push_task_wait_serializer(), ast_taskprocessor_unreference(), AST_WEBSOCKET_OPCODE_BINARY, AST_WEBSOCKET_OPCODE_CLOSE, AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_read(), ast_websocket_set_nonblock(), ast_websocket_set_timeout(), ast_websocket_unref(), ast_websocket_wait_for_input(), create_websocket_serializer(), get_write_timeout(), LOG_ERROR, transport_read_data::payload, transport_read_data::payload_len, session, ws_transport::transport, transport_create_data::transport, transport_read_data::transport, transport_create(), transport_read(), transport_shutdown(), and transport_create_data::ws_session.

Referenced by load_module(), and unload_module().

{
   struct ast_taskprocessor *serializer;
   struct transport_create_data create_data;
   struct ws_transport *transport;
   struct transport_read_data read_data;

   if (ast_websocket_set_nonblock(session)) {
      ast_websocket_unref(session);
      return;
   }

   if (ast_websocket_set_timeout(session, get_write_timeout())) {
      ast_websocket_unref(session);
      return;
   }

   serializer = create_websocket_serializer();
   if (!serializer) {
      ast_websocket_unref(session);
      return;
   }

   create_data.ws_session = session;

   if (ast_sip_push_task_wait_serializer(serializer, transport_create, &create_data)) {
      ast_log(LOG_ERROR, "Could not create WebSocket transport.\n");
      ast_taskprocessor_unreference(serializer);
      ast_websocket_unref(session);
      return;
   }

   transport = create_data.transport;
   read_data.transport = transport;

   while (ast_websocket_wait_for_input(session, -1) > 0) {
      enum ast_websocket_opcode opcode;
      int fragmented;

      if (ast_websocket_read(session, &read_data.payload, &read_data.payload_len, &opcode, &fragmented)) {
         break;
      }

      if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
         if (read_data.payload_len) {
            ast_sip_push_task_wait_serializer(serializer, transport_read, &read_data);
         }
      } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
         break;
      }
   }

   ast_sip_push_task_wait_serializer(serializer, transport_shutdown, transport);

   ast_taskprocessor_unreference(serializer);
   ast_websocket_unref(session);
}

websocket_on_rx_msg()

static pj_bool_t websocket_on_rx_msg ( pjsip_rx_data *  rdata )

static

Store the transport a message came in on, so it can be used for outbound messages to that contact.

Definition at line 421 of file res_pjsip_transport_websocket.c.

References ast_log, AST_SOCKADDR_BUFLEN, DEBUG_ATLEAST, LOG_DEBUG, NULL, transport_type_wss, transport_type_wss_ipv6, and type.

{
   static const pj_str_t STR_WS = { "ws", 2 };
   pjsip_contact_hdr *contact;

   long type = rdata->tp_info.transport->key.type;

   if (type != (long) transport_type_wss && type != (long) transport_type_wss_ipv6) {
      return PJ_FALSE;
   }

   contact = pjsip_msg_find_hdr(rdata->msg_info.msg, PJSIP_H_CONTACT, NULL);
   if (contact
      && !contact->star
      && (PJSIP_URI_SCHEME_IS_SIP(contact->uri) || PJSIP_URI_SCHEME_IS_SIPS(contact->uri))) {
      pjsip_sip_uri *uri = pjsip_uri_get_uri(contact->uri);
      const pj_str_t *txp_str = &STR_WS;

      if (DEBUG_ATLEAST(4)) {
         char src_addr_buffer[AST_SOCKADDR_BUFLEN];
         const char *ipv6_s = "", *ipv6_e = "";

         if (pj_strchr(&uri->host, ':')) {
            ipv6_s = "[";
            ipv6_e = "]";
         }

         ast_log(LOG_DEBUG, "%s re-writing Contact URI from %s%.*s%s:%d%s%.*s to %s;transport=%s\n",
            pjsip_rx_data_get_info(rdata),
            ipv6_s, (int) pj_strlen(&uri->host), pj_strbuf(&uri->host), ipv6_e, uri->port,
            pj_strlen(&uri->transport_param) ? ";transport=" : "",
            (int) pj_strlen(&uri->transport_param), pj_strbuf(&uri->transport_param),
            pj_sockaddr_print(&rdata->pkt_info.src_addr, src_addr_buffer, sizeof(src_addr_buffer), 3),
            pj_strbuf(txp_str));
      }

      pj_strdup2(rdata->tp_info.pool, &uri->host, rdata->pkt_info.src_name);
      uri->port = rdata->pkt_info.src_port;
      pj_strdup(rdata->tp_info.pool, &uri->transport_param, txp_str);
   }

   rdata->msg_info.via->rport_param = 0;

   return PJ_FALSE;
}

websocket_outgoing_invite_request()

static void websocket_outgoing_invite_request ( struct ast_sip_session *  session, struct pjsip_tx_data *  tdata  )

static

Function called when an INVITE goes out.

Definition at line 476 of file res_pjsip_transport_websocket.c.

References ast_sip_session::inv_session, NULL, and websocket_module.

{
   if (session->inv_session->state == PJSIP_INV_STATE_NULL) {
      pjsip_dlg_add_usage(session->inv_session->dlg, &websocket_module, NULL);
   }
}

ws_destroy()

static pj_status_t ws_destroy ( pjsip_transport *  transport )

static

Destroy the pjsip transport.

Called by pjsip transport manager.

Definition at line 85 of file res_pjsip_transport_websocket.c.

References ao2_ref, ast_websocket_close(), ast_websocket_fd(), and ws_transport::ws_session.

Referenced by transport_create().

{
   struct ws_transport *wstransport = (struct ws_transport *)transport;
   int fd = ast_websocket_fd(wstransport->ws_session);

   if (fd > 0) {
      ast_websocket_close(wstransport->ws_session, 1000);
      shutdown(fd, SHUT_RDWR);
   }

   ao2_ref(wstransport, -1);

   return PJ_SUCCESS;
}

ws_send_msg()

static pj_status_t ws_send_msg ( pjsip_transport *  transport, pjsip_tx_data *  tdata, const pj_sockaddr_t *  rem_addr, int  addr_len, void *  token, pjsip_transport_callback  callback  )

static

Send a message over the WebSocket connection.

Called by pjsip transport manager.

Definition at line 63 of file res_pjsip_transport_websocket.c.

References AST_WEBSOCKET_OPCODE_TEXT, ast_websocket_write(), len(), and ws_transport::ws_session.

Referenced by transport_create().

{
   struct ws_transport *wstransport = (struct ws_transport *)transport;
   uint64_t len = tdata->buf.cur - tdata->buf.start;

   if (ast_websocket_write(wstransport->ws_session, AST_WEBSOCKET_OPCODE_TEXT, tdata->buf.start, len)) {
      return PJ_EUNKNOWN;
   }

   return PJ_SUCCESS;
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "PJSIP WebSocket Transport 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_APP_DEPEND, .requires = "res_pjsip,res_http_websocket", }

static

Definition at line 535 of file res_pjsip_transport_websocket.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 535 of file res_pjsip_transport_websocket.c.

transport_type_wss

int transport_type_wss

static

WebSocket transport module.

Definition at line 41 of file res_pjsip_transport_websocket.c.

Referenced by load_module(), transport_create(), and websocket_on_rx_msg().

transport_type_wss_ipv6

int transport_type_wss_ipv6

static

Definition at line 42 of file res_pjsip_transport_websocket.c.

Referenced by load_module(), transport_create(), and websocket_on_rx_msg().

websocket_module

pjsip_module websocket_module

static

Definition at line 467 of file res_pjsip_transport_websocket.c.

Referenced by load_module(), unload_module(), and websocket_outgoing_invite_request().

websocket_supplement

struct ast_sip_session_supplement websocket_supplement

static

Initial value:

= {
   .method = "INVITE",
   .priority = AST_SIP_SUPPLEMENT_PRIORITY_FIRST + 1,
   .outgoing_request = websocket_outgoing_invite_request,
}

Supplement for adding Websocket functionality to dialog.

Definition at line 484 of file res_pjsip_transport_websocket.c.

ws_obj_name_serial

int ws_obj_name_serial

static

Used to ensure uniqueness among WS transport names

Definition at line 47 of file res_pjsip_transport_websocket.c.

Referenced by transport_create().