/*
* Callback from TURN session when state has changed
*/
static void turn_on_state(pj_turn_session *sess,
pj_turn_state_t old_state,
pj_turn_state_t new_state)
{
pj_turn_sock *turn_sock = (pj_turn_sock*)
pj_turn_session_get_user_data(sess);
pj_status_t status;
if (turn_sock == NULL) {
/* We've been destroyed */
return;
}
/* Notify app first */
if (turn_sock->cb.on_state) {
(*turn_sock->cb.on_state)(turn_sock, old_state, new_state);
}
/* Make sure user hasn't destroyed us in the callback */
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
pj_turn_session_info info;
pj_turn_session_get_info(turn_sock->sess, &info);
new_state = info.state;
}
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
/*
* Once server has been resolved, initiate outgoing TCP
* connection to the server.
*/
pj_turn_session_info info;
char addrtxt[PJ_INET6_ADDRSTRLEN+8];
int sock_type;
pj_sock_t sock;
pj_activesock_cfg asock_cfg;
pj_activesock_cb asock_cb;
pj_sockaddr bound_addr, *cfg_bind_addr;
pj_uint16_t max_bind_retry;
/* Close existing connection, if any. This happens when
* we're switching to alternate TURN server when either TCP
* connection or ALLOCATE request failed.
*/
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
/* Get server address from session info */
pj_turn_session_get_info(sess, &info);
if (turn_sock->conn_type == PJ_TURN_TP_UDP)
sock_type = pj_SOCK_DGRAM();
else
sock_type = pj_SOCK_STREAM();
/* Init socket */
status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Bind socket */
cfg_bind_addr = &turn_sock->setting.bound_addr;
max_bind_retry = MAX_BIND_RETRY;
if (turn_sock->setting.port_range &&
turn_sock->setting.port_range < max_bind_retry)
{
max_bind_retry = turn_sock->setting.port_range;
}
pj_sockaddr_init(turn_sock->af, &bound_addr, NULL, 0);
if (cfg_bind_addr->addr.sa_family == pj_AF_INET() ||
cfg_bind_addr->addr.sa_family == pj_AF_INET6())
{
pj_sockaddr_cp(&bound_addr, cfg_bind_addr);
}
status = pj_sock_bind_random(sock, &bound_addr,
turn_sock->setting.port_range,
max_bind_retry);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type,
&turn_sock->setting.qos_params,
(turn_sock->setting.qos_ignore_error?2:1),
turn_sock->pool->obj_name, NULL);
if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply socket buffer size */
if (turn_sock->setting.so_rcvbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_rcvbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_RCVBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_RCVBUF");
} else {
if (sobuf_size < turn_sock->setting.so_rcvbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_RCVBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_rcvbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_RCVBUF set to %d",
sobuf_size));
}
}
}
if (turn_sock->setting.so_sndbuf_size > 0) {
unsigned sobuf_size = turn_sock->setting.so_sndbuf_size;
status = pj_sock_setsockopt_sobuf(sock, pj_SO_SNDBUF(),
PJ_TRUE, &sobuf_size);
if (status != PJ_SUCCESS) {
pj_perror(3, turn_sock->obj_name, status,
"Failed setting SO_SNDBUF");
} else {
if (sobuf_size < turn_sock->setting.so_sndbuf_size) {
PJ_LOG(4, (turn_sock->obj_name,
"Warning! Cannot set SO_SNDBUF as configured,"
" now=%d, configured=%d", sobuf_size,
turn_sock->setting.so_sndbuf_size));
} else {
PJ_LOG(5, (turn_sock->obj_name, "SO_SNDBUF set to %d",
sobuf_size));
}
}
}
/* Create active socket */
pj_activesock_cfg_default(&asock_cfg);
asock_cfg.grp_lock = turn_sock->grp_lock;
pj_bzero(&asock_cb, sizeof(asock_cb));
asock_cb.on_data_read = &on_data_read;
asock_cb.on_connect_complete = &on_connect_complete;
status = pj_activesock_create(turn_sock->pool, sock,
sock_type, &asock_cfg,
turn_sock->cfg.ioqueue, &asock_cb,
turn_sock,
&turn_sock->active_sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
PJ_LOG(5,(turn_sock->pool->obj_name,
"Connecting to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3)));
/* Initiate non-blocking connect */
#if PJ_HAS_TCP
status=pj_activesock_start_connect(turn_sock->active_sock,
turn_sock->pool,
&info.server,
pj_sockaddr_get_len(&info.server));
if (status == PJ_SUCCESS) {
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
pj_turn_sock_destroy(turn_sock);
return;
}
#else
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
#endif
/* Done for now. Subsequent work will be done in
* on_connect_complete() callback.
*/
}
if (new_state >= PJ_TURN_STATE_DESTROYING && turn_sock->sess) {
pj_time_val delay = {0, 0};
turn_sock->sess = NULL;
pj_turn_session_set_user_data(sess, NULL);
pj_timer_heap_cancel_if_active(turn_sock->cfg.timer_heap,
&turn_sock->timer, 0);
pj_timer_heap_schedule_w_grp_lock(turn_sock->cfg.timer_heap,
&turn_sock->timer,
&delay, TIMER_DESTROY,
turn_sock->grp_lock);
}
}
static void destroy_relay(void)
{
if (g.relay) {
pj_turn_sock_destroy(g.relay);
}
}
static int destroy_test(pj_stun_config *stun_cfg,
pj_bool_t with_dns_srv,
pj_bool_t in_callback,
pj_bool_t use_ipv6)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
PJ_TRUE, /* DNS SRV */
0xFFFF /* Destroy on state */
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
int target_state;
int rc;
PJ_LOG(3,("", " destroy test %s %s",
(in_callback? "in callback" : ""),
(with_dns_srv? "with DNS srv" : "")
));
test_cfg.client.enable_dns_srv = with_dns_srv;
set_server_flag(&test_cfg, use_ipv6);
for (target_state=PJ_TURN_STATE_RESOLVING; target_state<=PJ_TURN_STATE_READY; ++target_state) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
pj_time_val tstart;
capture_pjlib_state(stun_cfg, &pjlib_state);
PJ_LOG(3,("", " %s", pj_turn_state_name((pj_turn_state_t)target_state)));
if (in_callback)
test_cfg.client.destroy_on_state = target_state;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
if (in_callback) {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 100, PJ_FALSE);
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -7;
break;
}
}
} else {
pj_gettimeofday(&tstart);
rc = 0;
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 1, PJ_FALSE);
pj_turn_sock_get_info(sess->turn_sock, &info);
if (info.state >= target_state) {
pj_turn_sock_destroy(sess->turn_sock);
break;
}
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
rc = -8;
break;
}
}
}
if (rc != 0) {
PJ_LOG(3,("", " error: timeout"));
return rc;
}
poll_events(stun_cfg, 1000, PJ_FALSE);
destroy_session(sess);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
return 0;
}
/*
* Callback from TURN session when state has changed
*/
static void turn_on_state(pj_turn_session *sess,
pj_turn_state_t old_state,
pj_turn_state_t new_state)
{
pj_turn_sock *turn_sock = (pj_turn_sock*)
pj_turn_session_get_user_data(sess);
pj_status_t status;
if (turn_sock == NULL) {
/* We've been destroyed */
return;
}
/* Notify app first */
if (turn_sock->cb.on_state) {
(*turn_sock->cb.on_state)(turn_sock, old_state, new_state);
}
/* Make sure user hasn't destroyed us in the callback */
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
pj_turn_session_info info;
pj_turn_session_get_info(turn_sock->sess, &info);
new_state = info.state;
}
if (turn_sock->sess && new_state == PJ_TURN_STATE_RESOLVED) {
/*
* Once server has been resolved, initiate outgoing TCP
* connection to the server.
*/
pj_turn_session_info info;
char addrtxt[PJ_INET6_ADDRSTRLEN+8];
int sock_type;
pj_sock_t sock;
pj_activesock_cb asock_cb;
/* Close existing connection, if any. This happens when
* we're switching to alternate TURN server when either TCP
* connection or ALLOCATE request failed.
*/
if (turn_sock->active_sock) {
pj_activesock_close(turn_sock->active_sock);
turn_sock->active_sock = NULL;
}
/* Get server address from session info */
pj_turn_session_get_info(sess, &info);
if (turn_sock->conn_type == PJ_TURN_TP_UDP)
sock_type = pj_SOCK_DGRAM();
else
sock_type = pj_SOCK_STREAM();
/* Init socket */
status = pj_sock_socket(turn_sock->af, sock_type, 0, &sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Apply QoS, if specified */
status = pj_sock_apply_qos2(sock, turn_sock->setting.qos_type,
&turn_sock->setting.qos_params,
(turn_sock->setting.qos_ignore_error?2:1),
turn_sock->pool->obj_name, NULL);
if (status != PJ_SUCCESS && !turn_sock->setting.qos_ignore_error) {
pj_turn_sock_destroy(turn_sock);
return;
}
/* Create active socket */
pj_bzero(&asock_cb, sizeof(asock_cb));
asock_cb.on_data_read = &on_data_read;
asock_cb.on_connect_complete = &on_connect_complete;
status = pj_activesock_create(turn_sock->pool, sock,
sock_type, NULL,
turn_sock->cfg.ioqueue, &asock_cb,
turn_sock,
&turn_sock->active_sock);
if (status != PJ_SUCCESS) {
pj_turn_sock_destroy(turn_sock);
return;
}
PJ_LOG(5,(turn_sock->pool->obj_name,
"Connecting to %s",
pj_sockaddr_print(&info.server, addrtxt,
sizeof(addrtxt), 3)));
/* Initiate non-blocking connect */
#if PJ_HAS_TCP
status=pj_activesock_start_connect(turn_sock->active_sock,
turn_sock->pool,
&info.server,
pj_sockaddr_get_len(&info.server));
if (status == PJ_SUCCESS) {
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
} else if (status != PJ_EPENDING) {
pj_turn_sock_destroy(turn_sock);
return;
}
#else
on_connect_complete(turn_sock->active_sock, PJ_SUCCESS);
#endif
/* Done for now. Subsequent work will be done in
* on_connect_complete() callback.
*/
}
if (new_state >= PJ_TURN_STATE_DESTROYING && turn_sock->sess) {
pj_time_val delay = {0, 0};
turn_sock->sess = NULL;
pj_turn_session_set_user_data(sess, NULL);
if (turn_sock->timer.id) {
pj_timer_heap_cancel(turn_sock->cfg.timer_heap, &turn_sock->timer);
turn_sock->timer.id = 0;
}
turn_sock->timer.id = TIMER_DESTROY;
pj_timer_heap_schedule(turn_sock->cfg.timer_heap, &turn_sock->timer,
&delay);
}
}
static int state_progression_test(pj_stun_config *stun_cfg,
pj_bool_t use_ipv6)
{
struct test_session_cfg test_cfg =
{
{ /* Client cfg */
PJ_TRUE, /* DNS SRV */
0xFFFF /* Destroy on state */
},
{ /* Server cfg */
0xFFFFFFFF, /* flags */
PJ_TRUE, /* respond to allocate */
PJ_TRUE /* respond to refresh */
}
};
struct test_session *sess;
unsigned i;
int rc = 0;
PJ_LOG(3,("", " state progression tests - (%s)",use_ipv6?"IPv6":"IPv4"));
set_server_flag(&test_cfg, use_ipv6);
for (i=0; i<=1; ++i) {
enum { TIMEOUT = 60 };
pjlib_state pjlib_state;
pj_turn_session_info info;
struct test_result result;
pj_time_val tstart;
PJ_LOG(3,("", " %s DNS SRV resolution",
(i==0? "without" : "with")));
capture_pjlib_state(stun_cfg, &pjlib_state);
test_cfg.client.enable_dns_srv = i;
rc = create_test_session(stun_cfg, &test_cfg, &sess);
if (rc != 0)
return rc;
pj_bzero(&info, sizeof(info));
/* Wait until state is READY */
pj_gettimeofday(&tstart);
while (sess->turn_sock) {
pj_time_val now;
poll_events(stun_cfg, 10, PJ_FALSE);
rc = pj_turn_sock_get_info(sess->turn_sock, &info);
if (rc!=PJ_SUCCESS)
break;
if (info.state >= PJ_TURN_STATE_READY)
break;
pj_gettimeofday(&now);
if (now.sec - tstart.sec > TIMEOUT) {
PJ_LOG(3,("", " timed-out"));
break;
}
}
if (info.state != PJ_TURN_STATE_READY) {
PJ_LOG(3,("", " error: state is not READY"));
destroy_session(sess);
return -130;
}
/* Deallocate */
pj_turn_sock_destroy(sess->turn_sock);
/* Wait for couple of seconds.
* We can't poll the session info since the session may have
* been destroyed
*/
poll_events(stun_cfg, 2000, PJ_FALSE);
sess->turn_sock = NULL;
pj_memcpy(&result, &sess->result, sizeof(result));
destroy_session(sess);
/* Check the result */
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVING is not called"));
return -140;
}
if ((result.state_called & (1<<PJ_TURN_STATE_RESOLVED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_RESOLVED is not called"));
return -150;
}
if ((result.state_called & (1<<PJ_TURN_STATE_ALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_ALLOCATING is not called"));
return -155;
}
if ((result.state_called & (1<<PJ_TURN_STATE_READY)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_READY is not called"));
return -160;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATING is not called"));
return -170;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DEALLOCATED)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DEALLOCATED is not called"));
return -180;
}
if ((result.state_called & (1<<PJ_TURN_STATE_DESTROYING)) == 0) {
PJ_LOG(3,("", " error: PJ_TURN_STATE_DESTROYING is not called"));
return -190;
}
poll_events(stun_cfg, 500, PJ_FALSE);
rc = check_pjlib_state(stun_cfg, &pjlib_state);
if (rc != 0) {
PJ_LOG(3,("", " error: memory/timer-heap leak detected"));
return rc;
}
}
if (use_ipv6)
rc = state_progression_test(stun_cfg, 0);
return rc;
}
