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

Macros
#define	COLON_LEN   1
#define	MAX_PORT_LEN   5

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 void	save_orig_contact_host (pjsip_rx_data *rdata, pjsip_sip_uri *uri)
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...
static pj_status_t	ws_shutdown (pjsip_transport *transport)
	Shut down the pjsip transport. 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

Macro Definition Documentation

COLON_LEN

#define COLON_LEN   1

MAX_PORT_LEN

#define MAX_PORT_LEN   5

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 582 of file res_pjsip_transport_websocket.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 582 of file res_pjsip_transport_websocket.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 582 of file res_pjsip_transport_websocket.c.

create_websocket_serializer()

static struct ast_taskprocessor * create_websocket_serializer ( void  )

static

Definition at line 364 of file res_pjsip_transport_websocket.c.

{
    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);
}

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

Referenced by websocket_cb().

get_write_timeout()

static int get_write_timeout ( void  )

static

Definition at line 326 of file res_pjsip_transport_websocket.c.

{
    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;
}

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, transport_states, ast_sip_transport_state::type, ast_sip_transport::type, and ast_sip_transport::write_timeout.

Referenced by websocket_cb().

load_module()

static int load_module ( void  )

static

Definition at line 537 of file res_pjsip_transport_websocket.c.

{
    /*
     * 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;
}

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

save_orig_contact_host()

static void save_orig_contact_host ( pjsip_rx_data *  rdata, pjsip_sip_uri *  uri  )

static

Definition at line 435 of file res_pjsip_transport_websocket.c.

{
    pjsip_param *x_orig_host;
    pj_str_t p_value;
#define COLON_LEN 1
#define MAX_PORT_LEN 5
 
    if (rdata->msg_info.msg->type != PJSIP_REQUEST_MSG ||
        rdata->msg_info.msg->line.req.method.id != PJSIP_REGISTER_METHOD) {
        return;
    }
 
    ast_debug(1, "Saving contact '%.*s:%d'\n",
        (int)uri->host.slen, uri->host.ptr, uri->port);
 
    x_orig_host = PJ_POOL_ALLOC_T(rdata->tp_info.pool, pjsip_param);
    x_orig_host->name = pj_strdup3(rdata->tp_info.pool, "x-ast-orig-host");
    p_value.slen = pj_strlen(&uri->host) + COLON_LEN + MAX_PORT_LEN;
    p_value.ptr = (char*)pj_pool_alloc(rdata->tp_info.pool, p_value.slen + 1);
    p_value.slen = snprintf(p_value.ptr, p_value.slen + 1, "%.*s:%d", (int)uri->host.slen, uri->host.ptr, uri->port);
    pj_strassign(&x_orig_host->value, &p_value);
    pj_list_insert_before(&uri->other_param, x_orig_host);
 
    return;
}

References ast_debug, COLON_LEN, and MAX_PORT_LEN.

Referenced by websocket_on_rx_msg().

transport_create()

static int transport_create ( void *  data )

static

Create a pjsip transport.

Definition at line 161 of file res_pjsip_transport_websocket.c.

{
    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));
    pj_strdup2(pool, &newtransport->transport.remote_name.host, ast_sockaddr_stringify_addr(ast_websocket_remote_address(newtransport->ws_session)));
    newtransport->transport.remote_name.port = ast_sockaddr_port(ast_websocket_remote_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.do_shutdown = &ws_shutdown;
    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;
}

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, ws_transport::rdata, 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, transport_create_data::ws_session, and ws_shutdown().

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

transport_dtor()

static void transport_dtor ( void *  arg )

static

Definition at line 112 of file res_pjsip_transport_websocket.c.

{
    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);
    }
}

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

Referenced by transport_create().

transport_read()

static int transport_read ( void *  data )

static

Pass WebSocket data into pjsip transport manager.

Definition at line 295 of file res_pjsip_transport_websocket.c.

{
    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;
}

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

transport_shutdown()

static int transport_shutdown ( void *  data )

static

Definition at line 137 of file res_pjsip_transport_websocket.c.

{
    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;
}

References ao2_ref, and ws_transport::transport.

Referenced by websocket_cb().

unload_module()

static int unload_module ( void  )

static

Definition at line 567 of file res_pjsip_transport_websocket.c.

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

References ast_sip_session_unregister_supplement(), ast_sip_unregister_service(), ast_websocket_remove_protocol(), websocket_cb(), websocket_module, and websocket_supplement.

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 375 of file res_pjsip_transport_websocket.c.

{
    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;
 
    pjsip_transport_add_ref(&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;
        }
    }
    pjsip_transport_dec_ref(&transport->transport);
 
    ast_sip_push_task_wait_serializer(serializer, transport_shutdown, transport);
 
    ast_taskprocessor_unreference(serializer);
    ast_websocket_unref(session);
}

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

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 464 of file res_pjsip_transport_websocket.c.

{
    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;
 
        /* Saving the contact on REGISTER so it can be restored on outbound response
         * This will actually be done by restore_orig_contact_host in res_pjsip_nat, via nat_on_tx_message */
        save_orig_contact_host(rdata, uri);
 
        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;
}

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

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 523 of file res_pjsip_transport_websocket.c.

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

References NULL, session, and websocket_module.

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.

{
    struct ws_transport *wstransport = (struct ws_transport *)transport;
 
    ao2_ref(wstransport, -1);
 
    return PJ_SUCCESS;
}

References ao2_ref, and ws_transport::transport.

Referenced by transport_create().

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.

{
    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;
}

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

Referenced by transport_create().

ws_shutdown()

static pj_status_t ws_shutdown ( pjsip_transport *  transport )

static

Shut down the pjsip transport.

Called by pjsip transport manager.

Definition at line 99 of file res_pjsip_transport_websocket.c.

{
    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);
    }
 
    return PJ_SUCCESS;
}

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

Referenced by transport_create().

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 582 of file res_pjsip_transport_websocket.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 582 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 514 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 531 of file res_pjsip_transport_websocket.c.

Referenced by load_module(), and unload_module().

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