/* Timer callback */
static void on_sess_timer(pj_timer_heap_t *th,
pj_timer_entry *te)
{
nat_detect_session *sess;
sess = (nat_detect_session*) te->user_data;
if (te->id == TIMER_DESTROY) {
pj_grp_lock_acquire(sess->grp_lock);
pj_ioqueue_unregister(sess->key);
sess->key = NULL;
sess->sock = PJ_INVALID_SOCKET;
te->id = 0;
pj_grp_lock_release(sess->grp_lock);
sess_destroy(sess);
} else if (te->id == TIMER_TEST) {
pj_bool_t next_timer;
pj_grp_lock_acquire(sess->grp_lock);
next_timer = PJ_FALSE;
if (sess->timer_executed == 0) {
send_test(sess, ST_TEST_1, NULL, 0);
next_timer = PJ_TRUE;
} else if (sess->timer_executed == 1) {
send_test(sess, ST_TEST_2, NULL, CHANGE_IP_PORT_FLAG);
next_timer = PJ_TRUE;
} else if (sess->timer_executed == 2) {
send_test(sess, ST_TEST_3, NULL, CHANGE_PORT_FLAG);
} else {
pj_assert(!"Shouldn't have timer at this state");
}
++sess->timer_executed;
if (next_timer) {
pj_time_val delay = {0, TEST_INTERVAL};
pj_timer_heap_schedule(th, te, &delay);
} else {
te->id = 0;
}
pj_grp_lock_release(sess->grp_lock);
} else {
pj_assert(!"Invalid timer ID");
}
}
static pj_status_t stun_tsx_on_send_msg(pj_stun_client_tsx *tsx,
const void *stun_pkt,
pj_size_t pkt_size)
{
pj_stun_tx_data *tdata;
pj_stun_session *sess;
pj_status_t status;
tdata = (pj_stun_tx_data*) pj_stun_client_tsx_get_data(tsx);
sess = tdata->sess;
/* Lock the session and prevent user from destroying us in the callback */
pj_grp_lock_acquire(sess->grp_lock);
if (sess->is_destroying) {
/* Stray timer */
pj_grp_lock_release(sess->grp_lock);
return PJ_EINVALIDOP;
}
status = sess->cb.on_send_msg(tdata->sess, tdata->token, stun_pkt,
pkt_size, tdata->dst_addr,
tdata->addr_len);
if (pj_grp_lock_release(sess->grp_lock))
return PJ_EGONE;
return status;
}
PJ_DEF(pj_status_t) pj_ioqueue_lock_key(pj_ioqueue_key_t *key)
{
if (key->grp_lock)
return pj_grp_lock_acquire(key->grp_lock);
else
return pj_lock_acquire(key->lock);
}
/* Send application data */
PJ_DEF(pj_status_t) pj_stun_sock_sendto( pj_stun_sock *stun_sock,
pj_ioqueue_op_key_t *send_key,
const void *pkt,
unsigned pkt_len,
unsigned flag,
const pj_sockaddr_t *dst_addr,
unsigned addr_len)
{
pj_ssize_t size;
pj_status_t status;
PJ_ASSERT_RETURN(stun_sock && pkt && dst_addr && addr_len, PJ_EINVAL);
pj_grp_lock_acquire(stun_sock->grp_lock);
if (!stun_sock->active_sock) {
/* We have been shutdown, but this callback may still get called
* by retransmit timer.
*/
pj_grp_lock_release(stun_sock->grp_lock);
return PJ_EINVALIDOP;
}
if (send_key==NULL)
send_key = &stun_sock->send_key;
size = pkt_len;
status = pj_activesock_sendto(stun_sock->active_sock, send_key,
pkt, &size, flag, dst_addr, addr_len);
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/* DNS resolver callback */
static void dns_srv_resolver_cb(void *user_data,
pj_status_t status,
const pj_dns_srv_record *rec)
{
pj_stun_sock *stun_sock = (pj_stun_sock*) user_data;
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Clear query */
stun_sock->q = NULL;
/* Handle error */
if (status != PJ_SUCCESS) {
sess_fail(stun_sock, PJ_STUN_SOCK_DNS_OP, status);
pj_grp_lock_release(stun_sock->grp_lock);
return;
}
pj_assert(rec->count);
pj_assert(rec->entry[0].server.addr_count);
PJ_TODO(SUPPORT_IPV6_IN_RESOLVER);
pj_assert(stun_sock->af == pj_AF_INET());
/* Set the address */
pj_sockaddr_in_init(&stun_sock->srv_addr.ipv4, NULL,
rec->entry[0].port);
stun_sock->srv_addr.ipv4.sin_addr = rec->entry[0].server.addr[0];
/* Start sending Binding request */
get_mapped_addr(stun_sock);
pj_grp_lock_release(stun_sock->grp_lock);
}
/* Destroy */
PJ_DEF(pj_status_t) pj_stun_sock_destroy(pj_stun_sock *stun_sock)
{
TRACE_((stun_sock->obj_name, "STUN sock %p request, ref_cnt=%d",
stun_sock, pj_grp_lock_get_ref(stun_sock->grp_lock)));
pj_grp_lock_acquire(stun_sock->grp_lock);
if (stun_sock->is_destroying) {
/* Destroy already called */
pj_grp_lock_release(stun_sock->grp_lock);
return PJ_EINVALIDOP;
}
stun_sock->is_destroying = PJ_TRUE;
pj_timer_heap_cancel_if_active(stun_sock->stun_cfg.timer_heap,
&stun_sock->ka_timer, 0);
if (stun_sock->active_sock != NULL) {
stun_sock->sock_fd = PJ_INVALID_SOCKET;
pj_activesock_close(stun_sock->active_sock);
} else if (stun_sock->sock_fd != PJ_INVALID_SOCKET) {
pj_sock_close(stun_sock->sock_fd);
stun_sock->sock_fd = PJ_INVALID_SOCKET;
}
if (stun_sock->stun_sess) {
pj_stun_session_destroy(stun_sock->stun_sess);
}
pj_grp_lock_dec_ref(stun_sock->grp_lock);
pj_grp_lock_release(stun_sock->grp_lock);
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_stun_client_tsx_schedule_destroy(
pj_stun_client_tsx *tsx,
const pj_time_val *delay)
{
pj_status_t status;
PJ_ASSERT_RETURN(tsx && delay, PJ_EINVAL);
PJ_ASSERT_RETURN(tsx->cb.on_destroy, PJ_EINVAL);
pj_grp_lock_acquire(tsx->grp_lock);
/* Cancel previously registered timer */
pj_timer_heap_cancel_if_active(tsx->timer_heap, &tsx->destroy_timer,
TIMER_INACTIVE);
/* Stop retransmission, just in case */
pj_timer_heap_cancel_if_active(tsx->timer_heap, &tsx->retransmit_timer,
TIMER_INACTIVE);
status = pj_timer_heap_schedule_w_grp_lock(tsx->timer_heap,
&tsx->destroy_timer, delay,
TIMER_ACTIVE, tsx->grp_lock);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(tsx->grp_lock);
return status;
}
tsx->cb.on_complete = NULL;
pj_grp_lock_release(tsx->grp_lock);
TRACE_((tsx->obj_name, "STUN transaction %p schedule destroy", tsx));
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_stun_session_set_user_data( pj_stun_session *sess,
void *user_data)
{
PJ_ASSERT_RETURN(sess, PJ_EINVAL);
pj_grp_lock_acquire(sess->grp_lock);
sess->user_data = user_data;
pj_grp_lock_release(sess->grp_lock);
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_stun_session_set_software_name(pj_stun_session *sess,
const pj_str_t *sw)
{
PJ_ASSERT_RETURN(sess, PJ_EINVAL);
pj_grp_lock_acquire(sess->grp_lock);
if (sw && sw->slen)
pj_strdup(sess->pool, &sess->srv_name, sw);
else
sess->srv_name.slen = 0;
pj_grp_lock_release(sess->grp_lock);
return PJ_SUCCESS;
}
/* Send application data */
PJ_DEF(pj_status_t) pj_stun_sock_sendto( pj_stun_sock *stun_sock,
pj_ioqueue_op_key_t *send_key,
const void *pkt,
unsigned pkt_len,
unsigned flag,
const pj_sockaddr_t *dst_addr,
unsigned addr_len)
{
pj_ssize_t size;
pj_status_t status;
pj_bool_t is_stun = PJ_FALSE;
pj_bool_t is_tnl_data = PJ_FALSE;
PJ_ASSERT_RETURN(stun_sock && pkt && dst_addr && addr_len, PJ_EINVAL);
pj_grp_lock_acquire(stun_sock->grp_lock);
if (!stun_sock->active_sock) {
/* We have been shutdown, but this callback may still get called
* by retransmit timer.
*/
pj_grp_lock_release(stun_sock->grp_lock);
return PJ_EINVALIDOP;
}
if (send_key==NULL)
send_key = &stun_sock->send_key;
size = pkt_len;
if (!stun_sock || !stun_sock->active_sock)
return PJ_EINVALIDOP;
/* Check that this is STUN message */
status = pj_stun_msg_check((const pj_uint8_t*)pkt, size,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET);
if (status == PJ_SUCCESS)
is_stun = PJ_TRUE;
else
is_tnl_data = (((pj_uint8_t*)pkt)[pkt_len] == 1);
if(is_stun || !is_tnl_data) {
pj_ioqueue_op_key_t *op_key = (pj_ioqueue_op_key_t*)pj_mem_alloc(sizeof(pj_ioqueue_op_key_t));
pj_ioqueue_op_key_init(op_key, sizeof(pj_ioqueue_op_key_t));
status = pj_activesock_sendto(stun_sock->active_sock, op_key,
pkt, &size, (flag | PJ_IOQUEUE_URGENT_DATA), dst_addr, addr_len);
} else {
status = pj_activesock_sendto(stun_sock->active_sock, &stun_sock->send_key,
pkt, &size, flag, dst_addr, addr_len);
}
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/*
* Callback upon receiving packet from network.
*/
static void on_read_complete(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
nat_detect_session *sess;
pj_status_t status;
sess = (nat_detect_session *) pj_ioqueue_get_user_data(key);
pj_assert(sess != NULL);
pj_grp_lock_acquire(sess->grp_lock);
/* Ignore packet when STUN session has been destroyed */
if (!sess->stun_sess)
goto on_return;
if (bytes_read < 0) {
if (-bytes_read != PJ_STATUS_FROM_OS(OSERR_EWOULDBLOCK) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_EINPROGRESS) &&
-bytes_read != PJ_STATUS_FROM_OS(OSERR_ECONNRESET))
{
/* Permanent error */
end_session(sess, (pj_status_t)-bytes_read,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
} else if (bytes_read > 0) {
pj_stun_session_on_rx_pkt(sess->stun_sess, sess->rx_pkt, bytes_read,
PJ_STUN_IS_DATAGRAM|PJ_STUN_CHECK_PACKET,
NULL, NULL,
&sess->src_addr, sess->src_addr_len);
}
sess->rx_pkt_len = sizeof(sess->rx_pkt);
sess->src_addr_len = sizeof(sess->src_addr);
status = pj_ioqueue_recvfrom(key, op_key, sess->rx_pkt, &sess->rx_pkt_len,
PJ_IOQUEUE_ALWAYS_ASYNC,
&sess->src_addr, &sess->src_addr_len);
if (status != PJ_EPENDING) {
pj_assert(status != PJ_SUCCESS);
end_session(sess, status, PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
/*
* Initialize.
*/
PJ_DEF(pj_status_t) pj_turn_sock_alloc(pj_turn_sock *turn_sock,
const pj_str_t *domain,
int default_port,
pj_dns_resolver *resolver,
const pj_stun_auth_cred *cred,
const pj_turn_alloc_param *param)
{
pj_status_t status;
PJ_ASSERT_RETURN(turn_sock && domain, PJ_EINVAL);
PJ_ASSERT_RETURN(turn_sock->sess, PJ_EINVALIDOP);
pj_grp_lock_acquire(turn_sock->grp_lock);
/* Copy alloc param. We will call session_alloc() only after the
* server address has been resolved.
*/
if (param) {
pj_turn_alloc_param_copy(turn_sock->pool, &turn_sock->alloc_param, param);
} else {
pj_turn_alloc_param_default(&turn_sock->alloc_param);
}
/* Set credental */
if (cred) {
status = pj_turn_session_set_credential(turn_sock->sess, cred);
if (status != PJ_SUCCESS) {
sess_fail(turn_sock, "Error setting credential", status);
pj_grp_lock_release(turn_sock->grp_lock);
return status;
}
}
/* Resolve server */
status = pj_turn_session_set_server(turn_sock->sess, domain, default_port,
resolver);
if (status != PJ_SUCCESS) {
sess_fail(turn_sock, "Error setting TURN server", status);
pj_grp_lock_release(turn_sock->grp_lock);
return status;
}
/* Done for now. The next work will be done when session state moved
* to RESOLVED state.
*/
pj_grp_lock_release(turn_sock->grp_lock);
return PJ_SUCCESS;
}
/*
* Notification when outgoing TCP socket has been connected.
*/
static pj_bool_t on_connect_complete(pj_activesock_t *asock,
pj_status_t status)
{
pj_turn_sock *turn_sock;
turn_sock = (pj_turn_sock*) pj_activesock_get_user_data(asock);
if (!turn_sock)
return PJ_FALSE;
pj_grp_lock_acquire(turn_sock->grp_lock);
/* TURN session may have already been destroyed here.
* See ticket #1557 (http://trac.pjsip.org/repos/ticket/1557).
*/
if (!turn_sock->sess) {
sess_fail(turn_sock, "TURN session already destroyed", status);
pj_grp_lock_release(turn_sock->grp_lock);
return PJ_FALSE;
}
if (status != PJ_SUCCESS) {
sess_fail(turn_sock, "TCP connect() error", status);
pj_grp_lock_release(turn_sock->grp_lock);
return PJ_FALSE;
}
if (turn_sock->conn_type != PJ_TURN_TP_UDP) {
PJ_LOG(5,(turn_sock->obj_name, "TCP connected"));
}
/* Kick start pending read operation */
status = pj_activesock_start_read(asock, turn_sock->pool,
turn_sock->setting.max_pkt_size, 0);
/* Init send_key */
pj_ioqueue_op_key_init(&turn_sock->send_key, sizeof(turn_sock->send_key));
/* Send Allocate request */
status = pj_turn_session_alloc(turn_sock->sess, &turn_sock->alloc_param);
if (status != PJ_SUCCESS) {
sess_fail(turn_sock, "Error sending ALLOCATE", status);
pj_grp_lock_release(turn_sock->grp_lock);
return PJ_FALSE;
}
pj_grp_lock_release(turn_sock->grp_lock);
return PJ_TRUE;
}
PJ_DEF(void) pj_grp_lock_t::pj_grp_lock_dump()
{
#if PJ_GRP_LOCK_DEBUG
grp_lock_ref *ref = grp_lock->ref_list.next;
char info_buf[1000];
pj_str_t info;
info.ptr = info_buf;
info.slen = 0;
pj_grp_lock_acquire(grp_lock);
pj_enter_critical_section();
while (ref != &grp_lock->ref_list && info.slen < sizeof(info_buf)) {
char *start = info.ptr + info.slen;
int max_len = sizeof(info_buf) - info.slen;
int len;
len = pj_ansi_snprintf(start, max_len, "%s:%d ", ref->file, ref->line);
if (len < 1 || len >= max_len) {
len = strlen(ref->file);
if (len > max_len - 1)
len = max_len - 1;
memcpy(start, ref->file, len);
start[len++] = ' ';
}
info.slen += len;
ref = ref->next;
}
if (ref != &grp_lock->ref_list) {
int i;
for (i=0; i<4; ++i)
info_buf[sizeof(info_buf)-i-1] = '.';
}
info.ptr[info.slen-1] = '\0';
pj_leave_critical_section();
pj_grp_lock_release(grp_lock);
PJ_LOG(4,(THIS_FILE, "Group lock %p, ref_cnt=%d. Reference holders: %s",
grp_lock, pj_grp_lock_get_ref(grp_lock), info.ptr));
#endif
}
PJ_DEF(pj_status_t) pj_stun_session_set_credential(pj_stun_session *sess,
pj_stun_auth_type auth_type,
const pj_stun_auth_cred *cred)
{
PJ_ASSERT_RETURN(sess, PJ_EINVAL);
pj_grp_lock_acquire(sess->grp_lock);
sess->auth_type = auth_type;
if (cred) {
pj_stun_auth_cred_dup(sess->pool, &sess->cred, cred);
} else {
sess->auth_type = PJ_STUN_AUTH_NONE;
pj_bzero(&sess->cred, sizeof(sess->cred));
}
pj_grp_lock_release(sess->grp_lock);
return PJ_SUCCESS;
}
/* Retransmit timer callback */
static void retransmit_timer_callback(pj_timer_heap_t *timer_heap,
pj_timer_entry *timer)
{
pj_stun_client_tsx *tsx = (pj_stun_client_tsx *) timer->user_data;
pj_status_t status;
PJ_UNUSED_ARG(timer_heap);
pj_grp_lock_acquire(tsx->grp_lock);
if (tsx->transmit_count >= PJ_STUN_MAX_TRANSMIT_COUNT) {
/* tsx may be destroyed when calling the callback below */
pj_grp_lock_t *grp_lock = tsx->grp_lock;
/* Retransmission count exceeded. Transaction has failed */
tsx->retransmit_timer.id = 0;
PJ_LOG(4,(tsx->obj_name, "STUN timeout waiting for response"));
pj_log_push_indent();
if (!tsx->complete) {
tsx->complete = PJ_TRUE;
if (tsx->cb.on_complete) {
tsx->cb.on_complete(tsx, PJNATH_ESTUNTIMEDOUT, NULL, NULL, 0);
}
}
pj_grp_lock_release(grp_lock);
/* We might have been destroyed, don't try to access the object */
pj_log_pop_indent();
return;
}
tsx->retransmit_timer.id = 0;
status = tsx_transmit_msg(tsx, PJ_TRUE);
if (status != PJ_SUCCESS) {
tsx->retransmit_timer.id = 0;
if (!tsx->complete) {
tsx->complete = PJ_TRUE;
if (tsx->cb.on_complete) {
tsx->cb.on_complete(tsx, status, NULL, NULL, 0);
}
}
}
pj_grp_lock_release(tsx->grp_lock);
/* We might have been destroyed, don't try to access the object */
}
static void destroy(pj_turn_sock *turn_sock)
{
PJ_LOG(4,(turn_sock->obj_name, "TURN socket destroy request, ref_cnt=%d",
pj_grp_lock_get_ref(turn_sock->grp_lock)));
pj_grp_lock_acquire(turn_sock->grp_lock);
if (turn_sock->is_destroying) {
pj_grp_lock_release(turn_sock->grp_lock);
return;
}
turn_sock->is_destroying = PJ_TRUE;
if (turn_sock->sess)
pj_turn_session_shutdown(turn_sock->sess);
if (turn_sock->active_sock)
pj_activesock_close(turn_sock->active_sock);
pj_grp_lock_dec_ref(turn_sock->grp_lock);
pj_grp_lock_release(turn_sock->grp_lock);
}
/* Keep-alive timer callback */
static void ka_timer_cb(pj_timer_heap_t *th, pj_timer_entry *te)
{
pj_stun_sock *stun_sock;
stun_sock = (pj_stun_sock *) te->user_data;
PJ_UNUSED_ARG(th);
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Time to send STUN Binding request */
if (get_mapped_addr(stun_sock) != PJ_SUCCESS) {
pj_grp_lock_release(stun_sock->grp_lock);
return;
}
/* Next keep-alive timer will be scheduled once the request
* is complete.
*/
pj_grp_lock_release(stun_sock->grp_lock);
}
PJ_DEF(void) pj_turn_sock_destroy(pj_turn_sock *turn_sock)
{
pj_grp_lock_acquire(turn_sock->grp_lock);
if (turn_sock->is_destroying) {
pj_grp_lock_release(turn_sock->grp_lock);
return;
}
if (turn_sock->sess) {
pj_turn_session_shutdown(turn_sock->sess);
/* This will ultimately call our state callback, and when
* session state is DESTROYING we will schedule a timer to
* destroy ourselves.
*/
} else {
destroy(turn_sock);
}
pj_grp_lock_release(turn_sock->grp_lock);
}
static void stun_tsx_on_complete(pj_stun_client_tsx *tsx,
pj_status_t status,
const pj_stun_msg *response,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
pj_stun_session *sess;
pj_bool_t notify_user = PJ_TRUE;
pj_stun_tx_data *tdata;
tdata = (pj_stun_tx_data*) pj_stun_client_tsx_get_data(tsx);
sess = tdata->sess;
/* Lock the session and prevent user from destroying us in the callback */
pj_grp_lock_acquire(sess->grp_lock);
if (sess->is_destroying) {
pj_stun_msg_destroy_tdata(sess, tdata);
pj_grp_lock_release(sess->grp_lock);
return;
}
/* Handle authentication challenge */
handle_auth_challenge(sess, tdata, response, src_addr,
src_addr_len, ¬ify_user);
if (notify_user && sess->cb.on_request_complete) {
(*sess->cb.on_request_complete)(sess, status, tdata->token, tdata,
response, src_addr, src_addr_len);
}
/* Destroy the transmit data. This will remove the transaction
* from the pending list too.
*/
if (status == PJNATH_ESTUNTIMEDOUT)
destroy_tdata(tdata, PJ_TRUE);
else
destroy_tdata(tdata, PJ_FALSE);
tdata = NULL;
pj_grp_lock_release(sess->grp_lock);
}
PJ_DEF(pj_status_t) pj_stun_session_destroy(pj_stun_session *sess)
{
pj_stun_tx_data *tdata;
PJ_ASSERT_RETURN(sess, PJ_EINVAL);
TRACE_((SNAME(sess), "STUN session %p destroy request, ref_cnt=%d",
sess, pj_grp_lock_get_ref(sess->grp_lock)));
pj_grp_lock_acquire(sess->grp_lock);
if (sess->is_destroying) {
/* Prevent from decrementing the ref counter more than once */
pj_grp_lock_release(sess->grp_lock);
return PJ_EINVALIDOP;
}
sess->is_destroying = PJ_TRUE;
/* We need to stop transactions and cached response because they are
* holding the group lock's reference counter while retransmitting.
*/
tdata = sess->pending_request_list.next;
while (tdata != &sess->pending_request_list) {
if (tdata->client_tsx)
pj_stun_client_tsx_stop(tdata->client_tsx);
tdata = tdata->next;
}
tdata = sess->cached_response_list.next;
while (tdata != &sess->cached_response_list) {
pj_timer_heap_cancel_if_active(tdata->sess->cfg->timer_heap,
&tdata->res_timer, PJ_FALSE);
tdata = tdata->next;
}
pj_grp_lock_dec_ref(sess->grp_lock);
pj_grp_lock_release(sess->grp_lock);
return PJ_SUCCESS;
}
/* Callback from active socket about send status */
static pj_bool_t on_data_sent(pj_activesock_t *asock,
pj_ioqueue_op_key_t *send_key,
pj_ssize_t sent)
{
pj_stun_sock *stun_sock;
stun_sock = (pj_stun_sock*) pj_activesock_get_user_data(asock);
if (!stun_sock)
return PJ_FALSE;
/* Don't report to callback if this is internal message */
if (send_key == &stun_sock->int_send_key) {
return PJ_TRUE;
}
/* Report to callback */
if (stun_sock->cb.on_data_sent) {
pj_bool_t ret;
pj_grp_lock_acquire(stun_sock->grp_lock);
/* If app gives NULL send_key in sendto() function, then give
* NULL in the callback too
*/
if (send_key == &stun_sock->send_key)
send_key = NULL;
/* Call callback */
ret = (*stun_sock->cb.on_data_sent)(stun_sock, send_key, sent);
pj_grp_lock_release(stun_sock->grp_lock);
return ret;
}
return PJ_TRUE;
}
/* Callback to be called to handle new incoming requests. */
static pj_bool_t proxy_on_rx_request( pjsip_rx_data *rdata )
{
pjsip_transaction *uas_tsx, *uac_tsx;
struct uac_data *uac_data;
struct uas_data *uas_data;
pjsip_tx_data *tdata;
pj_status_t status;
if (rdata->msg_info.msg->line.req.method.id != PJSIP_CANCEL_METHOD) {
/* Verify incoming request */
status = proxy_verify_request(rdata);
if (status != PJ_SUCCESS) {
app_perror("RX invalid request", status);
return PJ_TRUE;
}
/*
* Request looks sane, next clone the request to create transmit data.
*/
status = pjsip_endpt_create_request_fwd(global.endpt, rdata, NULL,
NULL, 0, &tdata);
if (status != PJ_SUCCESS) {
pjsip_endpt_respond_stateless(global.endpt, rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL, NULL, NULL);
return PJ_TRUE;
}
/* Process routing */
status = proxy_process_routing(tdata);
if (status != PJ_SUCCESS) {
app_perror("Error processing route", status);
return PJ_TRUE;
}
/* Calculate target */
status = proxy_calculate_target(rdata, tdata);
if (status != PJ_SUCCESS) {
app_perror("Error calculating target", status);
return PJ_TRUE;
}
/* Everything is set to forward the request. */
/* If this is an ACK request, forward statelessly.
* This happens if the proxy records route and this ACK
* is sent for 2xx response. An ACK that is sent for non-2xx
* final response will be absorbed by transaction layer, and
* it will not be received by on_rx_request() callback.
*/
if (tdata->msg->line.req.method.id == PJSIP_ACK_METHOD) {
status = pjsip_endpt_send_request_stateless(global.endpt, tdata,
NULL, NULL);
if (status != PJ_SUCCESS) {
app_perror("Error forwarding request", status);
return PJ_TRUE;
}
return PJ_TRUE;
}
/* Create UAC transaction for forwarding the request.
* Set our module as the transaction user to receive further
* events from this transaction.
*/
status = pjsip_tsx_create_uac(&mod_tu, tdata, &uac_tsx);
if (status != PJ_SUCCESS) {
pjsip_tx_data_dec_ref(tdata);
pjsip_endpt_respond_stateless(global.endpt, rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL, NULL, NULL);
return PJ_TRUE;
}
/* Create UAS transaction to handle incoming request */
status = pjsip_tsx_create_uas(&mod_tu, rdata, &uas_tsx);
if (status != PJ_SUCCESS) {
pjsip_tx_data_dec_ref(tdata);
pjsip_endpt_respond_stateless(global.endpt, rdata,
PJSIP_SC_INTERNAL_SERVER_ERROR,
NULL, NULL, NULL);
pjsip_tsx_terminate(uac_tsx, PJSIP_SC_INTERNAL_SERVER_ERROR);
return PJ_TRUE;
}
/* Feed the request to the UAS transaction to drive it's state
* out of NULL state.
*/
pjsip_tsx_recv_msg(uas_tsx, rdata);
/* Attach a data to the UAC transaction, to be used to find the
* UAS transaction when we receive response in the UAC side.
*/
uac_data = (struct uac_data*)
pj_pool_alloc(uac_tsx->pool, sizeof(struct uac_data));
uac_data->uas_tsx = uas_tsx;
uac_tsx->mod_data[mod_tu.id] = (void*)uac_data;
/* Attach data to the UAS transaction, to find the UAC transaction
* when cancelling INVITE request.
*/
uas_data = (struct uas_data*)
pj_pool_alloc(uas_tsx->pool, sizeof(struct uas_data));
uas_data->uac_tsx = uac_tsx;
uas_tsx->mod_data[mod_tu.id] = (void*)uas_data;
/* Everything is setup, forward the request */
status = pjsip_tsx_send_msg(uac_tsx, tdata);
if (status != PJ_SUCCESS) {
pjsip_tx_data *err_res;
/* Fail to send request, for some reason */
/* Destroy transmit data */
pjsip_tx_data_dec_ref(tdata);
/* I think UAC transaction should have been destroyed when
* it fails to send request, so no need to destroy it.
pjsip_tsx_terminate(uac_tsx, PJSIP_SC_INTERNAL_SERVER_ERROR);
*/
/* Send 500/Internal Server Error to UAS transaction */
pjsip_endpt_create_response(global.endpt, rdata,
500, NULL, &err_res);
pjsip_tsx_send_msg(uas_tsx, err_res);
return PJ_TRUE;
}
/* Send 100/Trying if this is an INVITE */
if (rdata->msg_info.msg->line.req.method.id == PJSIP_INVITE_METHOD) {
pjsip_tx_data *res100;
pjsip_endpt_create_response(global.endpt, rdata, 100, NULL,
&res100);
pjsip_tsx_send_msg(uas_tsx, res100);
}
} else {
/* This is CANCEL request */
pjsip_transaction *invite_uas;
struct uas_data *uas_data2;
pj_str_t key;
/* Find the UAS INVITE transaction */
pjsip_tsx_create_key(rdata->tp_info.pool, &key, PJSIP_UAS_ROLE,
pjsip_get_invite_method(), rdata);
invite_uas = pjsip_tsx_layer_find_tsx(&key, PJ_TRUE);
if (!invite_uas) {
/* Invite transaction not found, respond CANCEL with 481 */
pjsip_endpt_respond_stateless(global.endpt, rdata, 481, NULL,
NULL, NULL);
return PJ_TRUE;
}
/* Respond 200 OK to CANCEL */
pjsip_endpt_respond(global.endpt, NULL, rdata, 200, NULL, NULL,
NULL, NULL);
/* Send CANCEL to cancel the UAC transaction.
* The UAS INVITE transaction will get final response when
* we receive final response from the UAC INVITE transaction.
*/
uas_data2 = (struct uas_data*) invite_uas->mod_data[mod_tu.id];
if (uas_data2->uac_tsx && uas_data2->uac_tsx->status_code < 200) {
pjsip_tx_data *cancel;
pj_grp_lock_acquire(uas_data2->uac_tsx->grp_lock);
pjsip_endpt_create_cancel(global.endpt, uas_data2->uac_tsx->last_tx,
&cancel);
pjsip_endpt_send_request(global.endpt, cancel, -1, NULL, NULL);
pj_grp_lock_release(uas_data2->uac_tsx->grp_lock);
}
/* Unlock UAS tsx because it is locked in find_tsx() */
pj_grp_lock_release(invite_uas->grp_lock);
}
return PJ_TRUE;
}
/*
* Send outgoing message and start STUN transaction.
*/
PJ_DEF(pj_status_t) pj_stun_client_tsx_send_msg(pj_stun_client_tsx *tsx,
pj_bool_t retransmit,
void *pkt,
unsigned pkt_len)
{
pj_status_t status;
PJ_ASSERT_RETURN(tsx && pkt && pkt_len, PJ_EINVAL);
PJ_ASSERT_RETURN(tsx->retransmit_timer.id == 0, PJ_EBUSY);
pj_grp_lock_acquire(tsx->grp_lock);
/* Encode message */
tsx->last_pkt = pkt;
tsx->last_pkt_size = pkt_len;
/* Update STUN retransmit flag */
tsx->require_retransmit = retransmit;
/* For TCP, schedule timeout timer after PJ_STUN_TIMEOUT_VALUE.
* Since we don't have timeout timer, simulate this by using
* retransmit timer.
*/
if (!retransmit) {
unsigned timeout;
pj_assert(tsx->retransmit_timer.id == 0);
tsx->transmit_count = PJ_STUN_MAX_TRANSMIT_COUNT;
timeout = tsx->rto_msec * 16;
tsx->retransmit_time.sec = timeout / 1000;
tsx->retransmit_time.msec = timeout % 1000;
/* Schedule timer first because when send_msg() failed we can
* cancel it (as opposed to when schedule_timer() failed we cannot
* cancel transmission).
*/;
status = pj_timer_heap_schedule_w_grp_lock(tsx->timer_heap,
&tsx->retransmit_timer,
&tsx->retransmit_time,
TIMER_ACTIVE,
tsx->grp_lock);
if (status != PJ_SUCCESS) {
tsx->retransmit_timer.id = TIMER_INACTIVE;
pj_grp_lock_release(tsx->grp_lock);
return status;
}
}
/* Send the message */
status = tsx_transmit_msg(tsx, PJ_TRUE);
if (status != PJ_SUCCESS) {
pj_timer_heap_cancel_if_active(tsx->timer_heap,
&tsx->retransmit_timer,
TIMER_INACTIVE);
pj_grp_lock_release(tsx->grp_lock);
return status;
}
pj_grp_lock_release(tsx->grp_lock);
return PJ_SUCCESS;
}
/* Start socket. */
PJ_DEF(pj_status_t) pj_stun_sock_start( pj_stun_sock *stun_sock,
const pj_str_t *domain,
pj_uint16_t default_port,
pj_dns_resolver *resolver)
{
pj_status_t status;
PJ_ASSERT_RETURN(stun_sock && domain && default_port, PJ_EINVAL);
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Check whether the domain contains IP address */
stun_sock->srv_addr.addr.sa_family = (pj_uint16_t)stun_sock->af;
status = pj_inet_pton(stun_sock->af, domain,
pj_sockaddr_get_addr(&stun_sock->srv_addr));
if (status != PJ_SUCCESS) {
stun_sock->srv_addr.addr.sa_family = (pj_uint16_t)0;
}
/* If resolver is set, try to resolve with DNS SRV first. It
* will fallback to DNS A/AAAA when no SRV record is found.
*/
if (status != PJ_SUCCESS && resolver) {
const pj_str_t res_name = pj_str("_stun._udp.");
unsigned opt;
pj_assert(stun_sock->q == NULL);
opt = PJ_DNS_SRV_FALLBACK_A;
if (stun_sock->af == pj_AF_INET6()) {
opt |= (PJ_DNS_SRV_RESOLVE_AAAA | PJ_DNS_SRV_FALLBACK_AAAA);
}
status = pj_dns_srv_resolve(domain, &res_name, default_port,
stun_sock->pool, resolver, opt,
stun_sock, &dns_srv_resolver_cb,
&stun_sock->q);
/* Processing will resume when the DNS SRV callback is called */
} else {
if (status != PJ_SUCCESS) {
pj_addrinfo ai;
unsigned cnt = 1;
status = pj_getaddrinfo(stun_sock->af, domain, &cnt, &ai);
if (status != PJ_SUCCESS)
return status;
pj_sockaddr_cp(&stun_sock->srv_addr, &ai.ai_addr);
}
pj_sockaddr_set_port(&stun_sock->srv_addr, (pj_uint16_t)default_port);
/* Start sending Binding request */
status = get_mapped_addr(stun_sock);
}
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/*
* Notification from ioqueue when incoming UDP packet is received.
*/
static pj_bool_t on_data_read(pj_activesock_t *asock,
void *data,
pj_size_t size,
pj_status_t status,
pj_size_t *remainder)
{
pj_turn_sock *turn_sock;
pj_bool_t ret = PJ_TRUE;
turn_sock = (pj_turn_sock*) pj_activesock_get_user_data(asock);
pj_grp_lock_acquire(turn_sock->grp_lock);
if (status == PJ_SUCCESS && turn_sock->sess && !turn_sock->is_destroying) {
/* Report incoming packet to TURN session, repeat while we have
* "packet" in the buffer (required for stream-oriented transports)
*/
unsigned pkt_len;
//PJ_LOG(5,(turn_sock->pool->obj_name,
// "Incoming data, %lu bytes total buffer", size));
while ((pkt_len=has_packet(turn_sock, data, size)) != 0) {
pj_size_t parsed_len;
//const pj_uint8_t *pkt = (const pj_uint8_t*)data;
//PJ_LOG(5,(turn_sock->pool->obj_name,
// "Packet start: %02X %02X %02X %02X",
// pkt[0], pkt[1], pkt[2], pkt[3]));
//PJ_LOG(5,(turn_sock->pool->obj_name,
// "Processing %lu bytes packet of %lu bytes total buffer",
// pkt_len, size));
parsed_len = (unsigned)size;
pj_turn_session_on_rx_pkt(turn_sock->sess, data, size, &parsed_len);
/* parsed_len may be zero if we have parsing error, so use our
* previous calculation to exhaust the bad packet.
*/
if (parsed_len == 0)
parsed_len = pkt_len;
if (parsed_len < (unsigned)size) {
*remainder = size - parsed_len;
pj_memmove(data, ((char*)data)+parsed_len, *remainder);
} else {
*remainder = 0;
}
size = *remainder;
//PJ_LOG(5,(turn_sock->pool->obj_name,
// "Buffer size now %lu bytes", size));
}
} else if (status != PJ_SUCCESS &&
turn_sock->conn_type != PJ_TURN_TP_UDP)
{
sess_fail(turn_sock, "TCP connection closed", status);
ret = PJ_FALSE;
goto on_return;
}
on_return:
pj_grp_lock_release(turn_sock->grp_lock);
return ret;
}
/* Get info */
PJ_DEF(pj_status_t) pj_stun_sock_get_info( pj_stun_sock *stun_sock,
pj_stun_sock_info *info)
{
int addr_len;
pj_status_t status;
PJ_ASSERT_RETURN(stun_sock && info, PJ_EINVAL);
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Copy STUN server address and mapped address */
pj_memcpy(&info->srv_addr, &stun_sock->srv_addr,
sizeof(pj_sockaddr));
pj_memcpy(&info->mapped_addr, &stun_sock->mapped_addr,
sizeof(pj_sockaddr));
/* Retrieve bound address */
addr_len = sizeof(info->bound_addr);
status = pj_sock_getsockname(stun_sock->sock_fd, &info->bound_addr,
&addr_len);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/* If socket is bound to a specific interface, then only put that
* interface in the alias list. Otherwise query all the interfaces
* in the host.
*/
if (pj_sockaddr_has_addr(&info->bound_addr)) {
info->alias_cnt = 1;
pj_sockaddr_cp(&info->aliases[0], &info->bound_addr);
} else {
pj_sockaddr def_addr;
pj_uint16_t port = pj_sockaddr_get_port(&info->bound_addr);
unsigned i;
/* Get the default address */
status = pj_gethostip(stun_sock->af, &def_addr);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
pj_sockaddr_set_port(&def_addr, port);
/* Enum all IP interfaces in the host */
info->alias_cnt = PJ_ARRAY_SIZE(info->aliases);
status = pj_enum_ip_interface(stun_sock->af, &info->alias_cnt,
info->aliases);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(stun_sock->grp_lock);
return status;
}
/* Set the port number for each address.
*/
for (i=0; i<info->alias_cnt; ++i) {
pj_sockaddr_set_port(&info->aliases[i], port);
}
/* Put the default IP in the first slot */
for (i=0; i<info->alias_cnt; ++i) {
if (pj_sockaddr_cmp(&info->aliases[i], &def_addr)==0) {
if (i!=0) {
pj_sockaddr_cp(&info->aliases[i], &info->aliases[0]);
pj_sockaddr_cp(&info->aliases[0], &def_addr);
}
break;
}
}
}
pj_grp_lock_release(stun_sock->grp_lock);
return PJ_SUCCESS;
}
/**
* Lock the TURN socket. Application may need to call this function to
* synchronize access to other objects to avoid deadlock.
*/
PJ_DEF(pj_status_t) pj_turn_sock_lock(pj_turn_sock *turn_sock)
{
return pj_grp_lock_acquire(turn_sock->grp_lock);
}
/* Callback from active socket when incoming packet is received */
static pj_bool_t on_data_recvfrom(pj_activesock_t *asock,
void *data,
pj_size_t size,
const pj_sockaddr_t *src_addr,
int addr_len,
pj_status_t status)
{
pj_stun_sock *stun_sock;
pj_stun_msg_hdr *hdr;
pj_uint16_t type;
stun_sock = (pj_stun_sock*) pj_activesock_get_user_data(asock);
if (!stun_sock)
return PJ_FALSE;
/* Log socket error */
if (status != PJ_SUCCESS) {
PJ_PERROR(2,(stun_sock->obj_name, status, "recvfrom() error"));
return PJ_TRUE;
}
pj_grp_lock_acquire(stun_sock->grp_lock);
/* Check that this is STUN message */
status = pj_stun_msg_check((const pj_uint8_t*)data, size,
PJ_STUN_IS_DATAGRAM | PJ_STUN_CHECK_PACKET);
if (status != PJ_SUCCESS) {
/* Not STUN -- give it to application */
goto process_app_data;
}
/* Treat packet as STUN header and copy the STUN message type.
* We don't want to access the type directly from the header
* since it may not be properly aligned.
*/
hdr = (pj_stun_msg_hdr*) data;
pj_memcpy(&type, &hdr->type, 2);
type = pj_ntohs(type);
/* If the packet is a STUN Binding response and part of the
* transaction ID matches our internal ID, then this is
* our internal STUN message (Binding request or keep alive).
* Give it to our STUN session.
*/
if (!PJ_STUN_IS_RESPONSE(type) ||
PJ_STUN_GET_METHOD(type) != PJ_STUN_BINDING_METHOD ||
pj_memcmp(hdr->tsx_id, stun_sock->tsx_id, 10) != 0)
{
/* Not STUN Binding response, or STUN transaction ID mismatch.
* This is not our message too -- give it to application.
*/
goto process_app_data;
}
/* This is our STUN Binding response. Give it to the STUN session */
status = pj_stun_session_on_rx_pkt(stun_sock->stun_sess, data, size,
PJ_STUN_IS_DATAGRAM, NULL, NULL,
src_addr, addr_len);
status = pj_grp_lock_release(stun_sock->grp_lock);
return status!=PJ_EGONE ? PJ_TRUE : PJ_FALSE;
process_app_data:
if (stun_sock->cb.on_rx_data) {
pj_bool_t ret;
ret = (*stun_sock->cb.on_rx_data)(stun_sock, data, size,
src_addr, addr_len);
status = pj_grp_lock_release(stun_sock->grp_lock);
return status!=PJ_EGONE ? PJ_TRUE : PJ_FALSE;
}
status = pj_grp_lock_release(stun_sock->grp_lock);
return status!=PJ_EGONE ? PJ_TRUE : PJ_FALSE;
}
/*
* Callback upon request completion.
*/
static void on_request_complete(pj_stun_session *stun_sess,
pj_status_t status,
void *token,
pj_stun_tx_data *tdata,
const pj_stun_msg *response,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
nat_detect_session *sess;
pj_stun_sockaddr_attr *mattr = NULL;
pj_stun_changed_addr_attr *ca = NULL;
pj_uint32_t *tsx_id;
int cmp;
unsigned test_id;
PJ_UNUSED_ARG(token);
PJ_UNUSED_ARG(tdata);
PJ_UNUSED_ARG(src_addr);
PJ_UNUSED_ARG(src_addr_len);
sess = (nat_detect_session*) pj_stun_session_get_user_data(stun_sess);
pj_grp_lock_acquire(sess->grp_lock);
/* Find errors in the response */
if (status == PJ_SUCCESS) {
/* Check error message */
if (PJ_STUN_IS_ERROR_RESPONSE(response->hdr.type)) {
pj_stun_errcode_attr *eattr;
int err_code;
eattr = (pj_stun_errcode_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_ERROR_CODE, 0);
if (eattr != NULL)
err_code = eattr->err_code;
else
err_code = PJ_STUN_SC_SERVER_ERROR;
status = PJ_STATUS_FROM_STUN_CODE(err_code);
} else {
/* Get MAPPED-ADDRESS or XOR-MAPPED-ADDRESS */
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_XOR_MAPPED_ADDR, 0);
if (mattr == NULL) {
mattr = (pj_stun_sockaddr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_MAPPED_ADDR, 0);
}
if (mattr == NULL) {
status = PJNATH_ESTUNNOMAPPEDADDR;
}
/* Get CHANGED-ADDRESS attribute */
ca = (pj_stun_changed_addr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_CHANGED_ADDR, 0);
if (ca == NULL) {
status = PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR);
}
}
}
/* Save the result */
tsx_id = (pj_uint32_t*) tdata->msg->hdr.tsx_id;
test_id = tsx_id[2];
if (test_id >= ST_MAX) {
PJ_LOG(4,(sess->pool->obj_name, "Invalid transaction ID %u in response",
test_id));
end_session(sess, PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_SERVER_ERROR),
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
goto on_return;
}
PJ_LOG(5,(sess->pool->obj_name, "Completed %s, status=%d",
test_names[test_id], status));
sess->result[test_id].complete = PJ_TRUE;
sess->result[test_id].status = status;
if (status == PJ_SUCCESS) {
pj_memcpy(&sess->result[test_id].ma, &mattr->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
pj_memcpy(&sess->result[test_id].ca, &ca->sockaddr.ipv4,
sizeof(pj_sockaddr_in));
}
/* Send Test 1B only when Test 2 completes. Must not send Test 1B
* before Test 2 completes to avoid creating mapping on the NAT.
*/
if (!sess->result[ST_TEST_1B].executed &&
sess->result[ST_TEST_2].complete &&
sess->result[ST_TEST_2].status != PJ_SUCCESS &&
sess->result[ST_TEST_1].complete &&
sess->result[ST_TEST_1].status == PJ_SUCCESS)
{
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0)
send_test(sess, ST_TEST_1B, &sess->result[ST_TEST_1].ca, 0);
}
if (test_completed(sess)<3 || test_completed(sess)!=test_executed(sess))
goto on_return;
/* Handle the test result according to RFC 3489 page 22:
+--------+
| Test |
| 1 |
+--------+
|
|
V
/\ /\
N / \ Y / \ Y +--------+
UDP <-------/Resp\--------->/ IP \------------->| Test |
Blocked \ ? / \Same/ | 2 |
\ / \? / +--------+
\/ \/ |
| N |
| V
V /\
+--------+ Sym. N / \
| Test | UDP <---/Resp\
| 2 | Firewall \ ? /
+--------+ \ /
| \/
V |Y
/\ /\ |
Symmetric N / \ +--------+ N / \ V
NAT <--- / IP \<-----| Test |<--- /Resp\ Open
\Same/ | 1B | \ ? / Internet
\? / +--------+ \ /
\/ \/
| |Y
| |
| V
| Full
| Cone
V /\
+--------+ / \ Y
| Test |------>/Resp\---->Restricted
| 3 | \ ? /
+--------+ \ /
\/
|N
| Port
+------>Restricted
Figure 2: Flow for type discovery process
*/
switch (sess->result[ST_TEST_1].status) {
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 1 has timed-out. Conclude with NAT_TYPE_BLOCKED.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_BLOCKED);
break;
case PJ_SUCCESS:
/*
* Test 1 is successful. Further tests are needed to detect
* NAT type. Compare the MAPPED-ADDRESS with the local address.
*/
cmp = pj_memcmp(&sess->local_addr, &sess->result[ST_TEST_1].ma,
sizeof(pj_sockaddr_in));
if (cmp==0) {
/*
* MAPPED-ADDRESS and local address is equal. Need one more
* test to determine NAT type.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is also successful. We're in the open.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_OPEN);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed out. We're behind somekind of UDP
* firewall.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_SYMMETRIC_UDP);
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
} else {
/*
* MAPPED-ADDRESS is different than local address.
* We're behind NAT.
*/
switch (sess->result[ST_TEST_2].status) {
case PJ_SUCCESS:
/*
* Test 2 is successful. We're behind a full-cone NAT.
*/
end_session(sess, PJ_SUCCESS, PJ_STUN_NAT_TYPE_FULL_CONE);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 2 has timed-out Check result of test 1B..
*/
switch (sess->result[ST_TEST_1B].status) {
case PJ_SUCCESS:
/*
* Compare the MAPPED-ADDRESS of test 1B with the
* MAPPED-ADDRESS returned in test 1..
*/
cmp = pj_memcmp(&sess->result[ST_TEST_1].ma,
&sess->result[ST_TEST_1B].ma,
sizeof(pj_sockaddr_in));
if (cmp != 0) {
/*
* MAPPED-ADDRESS is different, we're behind a
* symmetric NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_SYMMETRIC);
} else {
/*
* MAPPED-ADDRESS is equal. We're behind a restricted
* or port-restricted NAT, depending on the result of
* test 3.
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/*
* Test 3 is successful, we're behind a restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Test 3 failed, we're behind a port restricted
* NAT.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_PORT_RESTRICTED);
break;
default:
/*
* Got other error with test 3.
*/
end_session(sess, sess->result[ST_TEST_3].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
case PJNATH_ESTUNTIMEDOUT:
/*
* Strangely test 1B has failed. Maybe connectivity was
* lost? Or perhaps port 3489 (the usual port number in
* CHANGED-ADDRESS) is blocked?
*/
switch (sess->result[ST_TEST_3].status) {
case PJ_SUCCESS:
/* Although test 1B failed, test 3 was successful.
* It could be that port 3489 is blocked, while the
* NAT itself looks to be a Restricted one.
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_RESTRICTED);
break;
default:
/* Can't distinguish between Symmetric and Port
* Restricted, so set the type to Unknown
*/
end_session(sess, PJ_SUCCESS,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* Got other error with test 1B.
*/
end_session(sess, sess->result[ST_TEST_1B].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
break;
default:
/*
* We've got other error with Test 2.
*/
end_session(sess, sess->result[ST_TEST_2].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
}
break;
default:
/*
* We've got other error with Test 1.
*/
end_session(sess, sess->result[ST_TEST_1].status,
PJ_STUN_NAT_TYPE_ERR_UNKNOWN);
break;
}
on_return:
pj_grp_lock_release(sess->grp_lock);
}
