/* Destroy TCP transport */
static pj_status_t tcp_destroy(pjsip_transport *transport,
pj_status_t reason)
{
struct tcp_transport *tcp = (struct tcp_transport*)transport;
if (tcp->close_reason == 0)
tcp->close_reason = reason;
if (tcp->is_registered) {
tcp->is_registered = PJ_FALSE;
pjsip_transport_destroy(transport);
/* pjsip_transport_destroy will recursively call this function
* again.
*/
return PJ_SUCCESS;
}
/* Mark transport as closing */
tcp->is_closing = PJ_TRUE;
/* Stop keep-alive timer. */
if (tcp->ka_timer.id) {
pjsip_endpt_cancel_timer(tcp->base.endpt, &tcp->ka_timer);
tcp->ka_timer.id = PJ_FALSE;
}
/* Cancel all delayed transmits */
while (!pj_list_empty(&tcp->delayed_list)) {
struct delayed_tdata *pending_tx;
pj_ioqueue_op_key_t *op_key;
pending_tx = tcp->delayed_list.next;
pj_list_erase(pending_tx);
op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
on_data_sent(tcp->asock, op_key, -reason);
}
if (tcp->asock) {
pj_activesock_close(tcp->asock);
tcp->asock = NULL;
tcp->sock = PJ_INVALID_SOCKET;
} else if (tcp->sock != PJ_INVALID_SOCKET) {
pj_sock_close(tcp->sock);
tcp->sock = PJ_INVALID_SOCKET;
}
if (tcp->grp_lock) {
pj_grp_lock_t *grp_lock = tcp->grp_lock;
tcp->grp_lock = NULL;
pj_grp_lock_dec_ref(grp_lock);
/* Transport may have been deleted at this point */
} else {
tcp_on_destroy(tcp);
}
return PJ_SUCCESS;
}
/* Destroy TLS transport */
static pj_status_t tls_destroy(pjsip_transport *transport,
pj_status_t reason)
{
struct tls_transport *tls = (struct tls_transport*)transport;
if (tls->close_reason == 0)
tls->close_reason = reason;
if (tls->is_registered) {
tls->is_registered = PJ_FALSE;
pjsip_transport_destroy(transport);
/* pjsip_transport_destroy will recursively call this function
* again.
*/
return PJ_SUCCESS;
}
/* Mark transport as closing */
tls->is_closing = PJ_TRUE;
/* Stop keep-alive timer. */
if (tls->ka_timer.id) {
pjsip_endpt_cancel_timer(tls->base.endpt, &tls->ka_timer);
tls->ka_timer.id = PJ_FALSE;
}
/* Cancel all delayed transmits */
while (!pj_list_empty(&tls->delayed_list)) {
struct delayed_tdata *pending_tx;
pj_ioqueue_op_key_t *op_key;
pending_tx = tls->delayed_list.next;
pj_list_erase(pending_tx);
op_key = (pj_ioqueue_op_key_t*)pending_tx->tdata_op_key;
on_data_sent(tls->ssock, op_key, -reason);
}
if (tls->rdata.tp_info.pool) {
pj_pool_release(tls->rdata.tp_info.pool);
tls->rdata.tp_info.pool = NULL;
}
if (tls->ssock) {
pj_ssl_sock_close(tls->ssock);
tls->ssock = NULL;
}
if (tls->base.lock) {
pj_lock_destroy(tls->base.lock);
tls->base.lock = NULL;
}
if (tls->base.ref_cnt) {
pj_atomic_destroy(tls->base.ref_cnt);
tls->base.ref_cnt = NULL;
}
if (tls->base.pool) {
pj_pool_t *pool;
if (reason != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(reason, errmsg, sizeof(errmsg));
PJ_LOG(4,(tls->base.obj_name,
"TLS transport destroyed with reason %d: %s",
reason, errmsg));
} else {
PJ_LOG(4,(tls->base.obj_name,
"TLS transport destroyed normally"));
}
pool = tls->base.pool;
tls->base.pool = NULL;
pj_pool_release(pool);
}
return PJ_SUCCESS;
}
/*
* pjsip_udp_transport_attach()
*
* Attach UDP socket and start transport.
*/
static pj_status_t transport_attach( pjsip_endpoint *endpt,
pjsip_transport_type_e type,
pj_sock_t sock,
const pjsip_host_port *a_name,
unsigned async_cnt,
pjsip_transport **p_transport)
{
pj_pool_t *pool;
struct udp_transport *tp;
const char *format, *ipv6_quoteb, *ipv6_quotee;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(endpt && sock!=PJ_INVALID_SOCKET && a_name && async_cnt>0,
PJ_EINVAL);
/* Object name. */
if (type & PJSIP_TRANSPORT_IPV6) {
format = "udpv6%p";
ipv6_quoteb = "[";
ipv6_quotee = "]";
} else {
format = "udp%p";
ipv6_quoteb = ipv6_quotee = "";
}
/* Create pool. */
pool = pjsip_endpt_create_pool(endpt, format, PJSIP_POOL_LEN_TRANSPORT,
PJSIP_POOL_INC_TRANSPORT);
if (!pool)
return PJ_ENOMEM;
/* Create the UDP transport object. */
tp = PJ_POOL_ZALLOC_T(pool, struct udp_transport);
/* Save pool. */
tp->base.pool = pool;
pj_memcpy(tp->base.obj_name, pool->obj_name, PJ_MAX_OBJ_NAME);
/* Init reference counter. */
status = pj_atomic_create(pool, 0, &tp->base.ref_cnt);
if (status != PJ_SUCCESS)
goto on_error;
/* Init lock. */
status = pj_lock_create_recursive_mutex(pool, pool->obj_name,
&tp->base.lock);
if (status != PJ_SUCCESS)
goto on_error;
/* Set type. */
tp->base.key.type = type;
/* Remote address is left zero (except the family) */
tp->base.key.rem_addr.addr.sa_family = (pj_uint16_t)
((type & PJSIP_TRANSPORT_IPV6) ? pj_AF_INET6() : pj_AF_INET());
/* Type name. */
tp->base.type_name = "UDP";
/* Transport flag */
tp->base.flag = pjsip_transport_get_flag_from_type(type);
/* Length of addressess. */
tp->base.addr_len = sizeof(tp->base.local_addr);
/* Init local address. */
status = pj_sock_getsockname(sock, &tp->base.local_addr,
&tp->base.addr_len);
if (status != PJ_SUCCESS)
goto on_error;
/* Init remote name. */
if (type == PJSIP_TRANSPORT_UDP)
tp->base.remote_name.host = pj_str("0.0.0.0");
else
tp->base.remote_name.host = pj_str("::0");
tp->base.remote_name.port = 0;
/* Init direction */
tp->base.dir = PJSIP_TP_DIR_NONE;
/* Set endpoint. */
tp->base.endpt = endpt;
/* Transport manager and timer will be initialized by tpmgr */
/* Attach socket and assign name. */
udp_set_socket(tp, sock, a_name);
/* Register to ioqueue */
status = register_to_ioqueue(tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Set functions. */
tp->base.send_msg = &udp_send_msg;
tp->base.do_shutdown = &udp_shutdown;
tp->base.destroy = &udp_destroy;
/* This is a permanent transport, so we initialize the ref count
* to one so that transport manager don't destroy this transport
* when there's no user!
*/
pj_atomic_inc(tp->base.ref_cnt);
/* Register to transport manager. */
tp->base.tpmgr = pjsip_endpt_get_tpmgr(endpt);
status = pjsip_transport_register( tp->base.tpmgr, (pjsip_transport*)tp);
if (status != PJ_SUCCESS)
goto on_error;
/* Create rdata and put it in the array. */
tp->rdata_cnt = 0;
tp->rdata = (pjsip_rx_data**)
pj_pool_calloc(tp->base.pool, async_cnt,
sizeof(pjsip_rx_data*));
for (i=0; i<async_cnt; ++i) {
pj_pool_t *rdata_pool = pjsip_endpt_create_pool(endpt, "rtd%p",
PJSIP_POOL_RDATA_LEN,
PJSIP_POOL_RDATA_INC);
if (!rdata_pool) {
pj_atomic_set(tp->base.ref_cnt, 0);
pjsip_transport_destroy(&tp->base);
return PJ_ENOMEM;
}
init_rdata(tp, i, rdata_pool, NULL);
tp->rdata_cnt++;
}
/* Start reading the ioqueue. */
status = start_async_read(tp);
if (status != PJ_SUCCESS) {
pjsip_transport_destroy(&tp->base);
return status;
}
/* Done. */
if (p_transport)
*p_transport = &tp->base;
PJ_LOG(4,(tp->base.obj_name,
"SIP %s started, published address is %s%.*s%s:%d",
pjsip_transport_get_type_desc((pjsip_transport_type_e)tp->base.key.type),
ipv6_quoteb,
(int)tp->base.local_name.host.slen,
tp->base.local_name.host.ptr,
ipv6_quotee,
tp->base.local_name.port));
return PJ_SUCCESS;
on_error:
udp_destroy((pjsip_transport*)tp);
return status;
}
/*!
* \brief Create a pjsip transport.
*/
static int transport_create(void *data)
{
struct transport_create_data *create_data = data;
struct ws_transport *newtransport = NULL;
pjsip_endpoint *endpt = ast_sip_get_pjsip_endpoint();
struct pjsip_tpmgr *tpmgr = pjsip_endpt_get_tpmgr(endpt);
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;
}
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;
}
pj_sockaddr_parse(pj_AF_UNSPEC(), 0, pj_cstr(&buf, ast_sockaddr_stringify(ast_websocket_remote_address(newtransport->ws_session))), &newtransport->transport.key.rem_addr);
newtransport->transport.key.rem_addr.addr.sa_family = pj_AF_INET();
newtransport->transport.key.type = ast_websocket_is_secure(newtransport->ws_session) ? transport_type_wss : transport_type_ws;
newtransport->transport.addr_len = pj_sockaddr_get_len(&newtransport->transport.key.rem_addr);
pj_sockaddr_cp(&newtransport->transport.local_addr, &newtransport->transport.key.rem_addr);
newtransport->transport.local_name.host.ptr = (char *)pj_pool_alloc(pool, newtransport->transport.addr_len+4);
pj_sockaddr_print(&newtransport->transport.key.rem_addr, newtransport->transport.local_name.host.ptr, newtransport->transport.addr_len+4, 0);
newtransport->transport.local_name.host.slen = pj_ansi_strlen(newtransport->transport.local_name.host.ptr);
newtransport->transport.local_name.port = pj_sockaddr_get_port(&newtransport->transport.key.rem_addr);
newtransport->transport.type_name = (char *)pjsip_transport_get_type_name(newtransport->transport.key.type);
newtransport->transport.flag = pjsip_transport_get_flag_from_type((pjsip_transport_type_e)newtransport->transport.key.type);
newtransport->transport.info = (char *)pj_pool_alloc(newtransport->transport.pool, 64);
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;
return 0;
on_error:
ao2_cleanup(newtransport);
return -1;
}
/*
* UDP transport test.
*/
int transport_udp_test(void)
{
enum { SEND_RECV_LOOP = 8 };
pjsip_transport *udp_tp, *tp;
pj_sockaddr_in addr, rem_addr;
pj_str_t s;
pj_status_t status;
int rtt[SEND_RECV_LOOP], min_rtt;
int i, pkt_lost;
pj_sockaddr_in_init(&addr, NULL, TEST_UDP_PORT);
/* Start UDP transport. */
status = pjsip_udp_transport_start( endpt, &addr, NULL, 1, &udp_tp);
if (status != PJ_SUCCESS) {
app_perror(" Error: unable to start UDP transport", status);
return -10;
}
/* UDP transport must have initial reference counter set to 1. */
if (pj_atomic_get(udp_tp->ref_cnt) != 1)
return -20;
/* Test basic transport attributes */
status = generic_transport_test(udp_tp);
if (status != PJ_SUCCESS)
return status;
/* Test that transport manager is returning the correct
* transport.
*/
pj_sockaddr_in_init(&rem_addr, pj_cstr(&s, "1.1.1.1"), 80);
status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_UDP,
&rem_addr, sizeof(rem_addr),
NULL, &tp);
if (status != PJ_SUCCESS)
return -50;
if (tp != udp_tp)
return -60;
/* pjsip_endpt_acquire_transport() adds reference, so we need
* to decrement it.
*/
pjsip_transport_dec_ref(tp);
/* Check again that reference counter is 1. */
if (pj_atomic_get(udp_tp->ref_cnt) != 1)
return -70;
/* Basic transport's send/receive loopback test. */
pj_sockaddr_in_init(&rem_addr, pj_cstr(&s, "127.0.0.1"), TEST_UDP_PORT);
for (i=0; i<SEND_RECV_LOOP; ++i) {
status = transport_send_recv_test(PJSIP_TRANSPORT_UDP, tp,
"sip:[email protected]:"TEST_UDP_PORT_STR,
&rtt[i]);
if (status != 0)
return status;
}
min_rtt = 0xFFFFFFF;
for (i=0; i<SEND_RECV_LOOP; ++i)
if (rtt[i] < min_rtt) min_rtt = rtt[i];
report_ival("udp-rtt-usec", min_rtt, "usec",
"Best UDP transport round trip time, in microseconds "
"(time from sending request until response is received. "
"Tests were performed on local machine only)");
/* Multi-threaded round-trip test. */
status = transport_rt_test(PJSIP_TRANSPORT_UDP, tp,
"sip:[email protected]:"TEST_UDP_PORT_STR,
&pkt_lost);
if (status != 0)
return status;
if (pkt_lost != 0)
PJ_LOG(3,(THIS_FILE, " note: %d packet(s) was lost", pkt_lost));
/* Check again that reference counter is 1. */
if (pj_atomic_get(udp_tp->ref_cnt) != 1)
return -80;
/* Destroy this transport. */
pjsip_transport_dec_ref(udp_tp);
/* Force destroy this transport. */
status = pjsip_transport_destroy(udp_tp);
if (status != PJ_SUCCESS)
return -90;
/* Flush events. */
PJ_LOG(3,(THIS_FILE, " Flushing events, 1 second..."));
flush_events(1000);
/* Done */
return 0;
}
int transport_tcp_test(void)
{
enum { SEND_RECV_LOOP = 8 };
pjsip_tpfactory *tpfactory;
pjsip_transport *tcp;
pj_sockaddr_in rem_addr;
pj_status_t status;
char url[PJSIP_MAX_URL_SIZE];
int rtt[SEND_RECV_LOOP], min_rtt;
int i, pkt_lost;
/* Start TCP listener on arbitrary port. */
status = pjsip_tcp_transport_start(endpt, NULL, 1, &tpfactory);
if (status != PJ_SUCCESS) {
app_perror(" Error: unable to start TCP transport", status);
return -10;
}
/* Get the listener address */
status = pj_sockaddr_in_init(&rem_addr, &tpfactory->addr_name.host,
(pj_uint16_t)tpfactory->addr_name.port);
if (status != PJ_SUCCESS) {
app_perror(" Error: possibly invalid TCP address name", status);
return -14;
}
pj_ansi_sprintf(url, "sip:alice@%s:%d;transport=tcp",
pj_inet_ntoa(rem_addr.sin_addr),
pj_ntohs(rem_addr.sin_port));
/* Acquire one TCP transport. */
status = pjsip_endpt_acquire_transport(endpt, PJSIP_TRANSPORT_TCP,
&rem_addr, sizeof(rem_addr),
NULL, &tcp);
if (status != PJ_SUCCESS || tcp == NULL) {
app_perror(" Error: unable to acquire TCP transport", status);
return -17;
}
/* After pjsip_endpt_acquire_transport, TCP transport must have
* reference counter 1.
*/
if (pj_atomic_get(tcp->ref_cnt) != 1)
return -20;
/* Test basic transport attributes */
status = generic_transport_test(tcp);
if (status != PJ_SUCCESS)
return status;
/* Check again that reference counter is 1. */
if (pj_atomic_get(tcp->ref_cnt) != 1)
return -40;
/* Load test */
if (transport_load_test(url) != 0)
return -60;
/* Basic transport's send/receive loopback test. */
for (i=0; i<SEND_RECV_LOOP; ++i) {
status = transport_send_recv_test(PJSIP_TRANSPORT_TCP, tcp, url, &rtt[i]);
if (status != 0) {
pjsip_transport_dec_ref(tcp);
flush_events(500);
return -72;
}
}
min_rtt = 0xFFFFFFF;
for (i=0; i<SEND_RECV_LOOP; ++i)
if (rtt[i] < min_rtt) min_rtt = rtt[i];
report_ival("tcp-rtt-usec", min_rtt, "usec",
"Best TCP transport round trip time, in microseconds "
"(time from sending request until response is received. "
"Tests were performed on local machine only, and after "
"TCP socket has been established by previous test)");
/* Multi-threaded round-trip test. */
status = transport_rt_test(PJSIP_TRANSPORT_TCP, tcp, url, &pkt_lost);
if (status != 0) {
pjsip_transport_dec_ref(tcp);
return status;
}
if (pkt_lost != 0)
PJ_LOG(3,(THIS_FILE, " note: %d packet(s) was lost", pkt_lost));
/* Check again that reference counter is still 1. */
if (pj_atomic_get(tcp->ref_cnt) != 1)
return -80;
/* Destroy this transport. */
pjsip_transport_dec_ref(tcp);
/* Force destroy this transport. */
status = pjsip_transport_destroy(tcp);
if (status != PJ_SUCCESS)
return -90;
/* Unregister factory */
status = pjsip_tpmgr_unregister_tpfactory(pjsip_endpt_get_tpmgr(endpt),
tpfactory);
if (status != PJ_SUCCESS)
return -95;
/* Flush events. */
PJ_LOG(3,(THIS_FILE, " Flushing events, 1 second..."));
flush_events(1000);
/* Done */
return 0;
}