Gitiles
Code Review Sign In
review.jami.net / jami-client-android / 3874e557ab7b54f78566363f6deeb3d08933f5dd / . / jni / pjproject-android / .svn / pristine / 2b / 2b2269be59bc35ef4d83540cb54e40b0da457901.svn-base
blob: 6eca28530fe69fa41f83697a0a10ce703bfe6d31 [file] [log] [blame]
/* $Id$ */
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <pjnath/ice_session.h>
#include <pj/addr_resolv.h>
#include <pj/array.h>
#include <pj/assert.h>
#include <pj/guid.h>
#include <pj/hash.h>
#include <pj/log.h>
#include <pj/os.h>
#include <pj/pool.h>
#include <pj/rand.h>
#include <pj/string.h>
/* String names for candidate types */
static const char *cand_type_names[] =
{
"host",
"srflx",
"prflx",
"relay"
};
/* String names for pj_ice_sess_check_state */
#if PJ_LOG_MAX_LEVEL >= 4
static const char *check_state_name[] =
{
"Frozen",
"Waiting",
"In Progress",
"Succeeded",
"Failed"
};
static const char *clist_state_name[] =
{
"Idle",
"Running",
"Completed"
};
#endif /* PJ_LOG_MAX_LEVEL >= 4 */
static const char *role_names[] =
{
"Unknown",
"Controlled",
"Controlling"
};
enum timer_type
{
TIMER_NONE, /**< Timer not active */
TIMER_COMPLETION_CALLBACK, /**< Call on_ice_complete() callback */
TIMER_CONTROLLED_WAIT_NOM, /**< Controlled agent is waiting for
controlling agent to send connectivity
check with nominated flag after it has
valid check for every components. */
TIMER_START_NOMINATED_CHECK,/**< Controlling agent start connectivity
checks with USE-CANDIDATE flag. */
TIMER_KEEP_ALIVE /**< ICE keep-alive timer. */
};
/* Candidate type preference */
static pj_uint8_t cand_type_prefs[4] =
{
#if PJ_ICE_CAND_TYPE_PREF_BITS < 8
/* Keep it to 2 bits */
3, /**< PJ_ICE_HOST_PREF */
1, /**< PJ_ICE_SRFLX_PREF. */
2, /**< PJ_ICE_PRFLX_PREF */
0 /**< PJ_ICE_RELAYED_PREF */
#else
/* Default ICE session preferences, according to draft-ice */
126, /**< PJ_ICE_HOST_PREF */
100, /**< PJ_ICE_SRFLX_PREF. */
110, /**< PJ_ICE_PRFLX_PREF */
0 /**< PJ_ICE_RELAYED_PREF */
#endif
};
#define THIS_FILE "ice_session.c"
#define CHECK_NAME_LEN 128
#define LOG4(expr) PJ_LOG(4,expr)
#define LOG5(expr) PJ_LOG(4,expr)
#define GET_LCAND_ID(cand) (unsigned)(cand - ice->lcand)
#define GET_CHECK_ID(cl, chk) (chk - (cl)->checks)
/* The data that will be attached to the STUN session on each
* component.
*/
typedef struct stun_data
{
pj_ice_sess *ice;
unsigned comp_id;
pj_ice_sess_comp *comp;
} stun_data;
/* The data that will be attached to the timer to perform
* periodic check.
*/
typedef struct timer_data
{
pj_ice_sess *ice;
pj_ice_sess_checklist *clist;
} timer_data;
/* This is the data that will be attached as token to outgoing
* STUN messages.
*/
/* Forward declarations */
static void on_timer(pj_timer_heap_t *th, pj_timer_entry *te);
static void on_ice_complete(pj_ice_sess *ice, pj_status_t status);
static void ice_keep_alive(pj_ice_sess *ice, pj_bool_t send_now);
static void ice_on_destroy(void *obj);
static void destroy_ice(pj_ice_sess *ice,
pj_status_t reason);
static pj_status_t start_periodic_check(pj_timer_heap_t *th,
pj_timer_entry *te);
static void start_nominated_check(pj_ice_sess *ice);
static void periodic_timer(pj_timer_heap_t *th,
pj_timer_entry *te);
static void handle_incoming_check(pj_ice_sess *ice,
const pj_ice_rx_check *rcheck);
/* These are the callbacks registered to the STUN sessions */
static pj_status_t on_stun_send_msg(pj_stun_session *sess,
void *token,
const void *pkt,
pj_size_t pkt_size,
const pj_sockaddr_t *dst_addr,
unsigned addr_len);
static pj_status_t on_stun_rx_request(pj_stun_session *sess,
const pj_uint8_t *pkt,
unsigned pkt_len,
const pj_stun_rx_data *rdata,
void *token,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len);
static void on_stun_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);
static pj_status_t on_stun_rx_indication(pj_stun_session *sess,
const pj_uint8_t *pkt,
unsigned pkt_len,
const pj_stun_msg *msg,
void *token,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len);
/* These are the callbacks for performing STUN authentication */
static pj_status_t stun_auth_get_auth(void *user_data,
pj_pool_t *pool,
pj_str_t *realm,
pj_str_t *nonce);
static pj_status_t stun_auth_get_cred(const pj_stun_msg *msg,
void *user_data,
pj_pool_t *pool,
pj_str_t *realm,
pj_str_t *username,
pj_str_t *nonce,
pj_stun_passwd_type *data_type,
pj_str_t *data);
static pj_status_t stun_auth_get_password(const pj_stun_msg *msg,
void *user_data,
const pj_str_t *realm,
const pj_str_t *username,
pj_pool_t *pool,
pj_stun_passwd_type *data_type,
pj_str_t *data);
PJ_DEF(const char*) pj_ice_get_cand_type_name(pj_ice_cand_type type)
{
PJ_ASSERT_RETURN(type <= PJ_ICE_CAND_TYPE_RELAYED, "???");
return cand_type_names[type];
}
PJ_DEF(const char*) pj_ice_sess_role_name(pj_ice_sess_role role)
{
switch (role) {
case PJ_ICE_SESS_ROLE_UNKNOWN:
return "Unknown";
case PJ_ICE_SESS_ROLE_CONTROLLED:
return "Controlled";
case PJ_ICE_SESS_ROLE_CONTROLLING:
return "Controlling";
default:
return "??";
}
}
/* Get the prefix for the foundation */
static int get_type_prefix(pj_ice_cand_type type)
{
switch (type) {
case PJ_ICE_CAND_TYPE_HOST: return 'H';
case PJ_ICE_CAND_TYPE_SRFLX: return 'S';
case PJ_ICE_CAND_TYPE_PRFLX: return 'P';
case PJ_ICE_CAND_TYPE_RELAYED: return 'R';
default:
pj_assert(!"Invalid type");
return 'U';
}
}
/* Calculate foundation:
* Two candidates have the same foundation when they are "similar" - of
* the same type and obtained from the same host candidate and STUN
* server using the same protocol. Otherwise, their foundation is
* different.
*/
PJ_DEF(void) pj_ice_calc_foundation(pj_pool_t *pool,
pj_str_t *foundation,
pj_ice_cand_type type,
const pj_sockaddr *base_addr)
{
#if PJNATH_ICE_PRIO_STD
char buf[64];
pj_uint32_t val;
if (base_addr->addr.sa_family == pj_AF_INET()) {
val = pj_ntohl(base_addr->ipv4.sin_addr.s_addr);
} else {
val = pj_hash_calc(0, pj_sockaddr_get_addr(base_addr),
pj_sockaddr_get_addr_len(base_addr));
}
pj_ansi_snprintf(buf, sizeof(buf), "%c%x",
get_type_prefix(type), val);
pj_strdup2(pool, foundation, buf);
#else
/* Much shorter version, valid for candidates added by
* pj_ice_strans.
*/
foundation->ptr = (char*) pj_pool_alloc(pool, 1);
*foundation->ptr = (char)get_type_prefix(type);
foundation->slen = 1;
PJ_UNUSED_ARG(base_addr);
#endif
}
/* Init component */
static pj_status_t init_comp(pj_ice_sess *ice,
unsigned comp_id,
pj_ice_sess_comp *comp)
{
pj_stun_session_cb sess_cb;
pj_stun_auth_cred auth_cred;
stun_data *sd;
pj_status_t status;
/* Init STUN callbacks */
pj_bzero(&sess_cb, sizeof(sess_cb));
sess_cb.on_request_complete = &on_stun_request_complete;
sess_cb.on_rx_indication = &on_stun_rx_indication;
sess_cb.on_rx_request = &on_stun_rx_request;
sess_cb.on_send_msg = &on_stun_send_msg;
/* Create STUN session for this candidate */
status = pj_stun_session_create(&ice->stun_cfg, NULL,
&sess_cb, PJ_TRUE,
ice->grp_lock,
&comp->stun_sess);
if (status != PJ_SUCCESS)
return status;
/* Associate data with this STUN session */
sd = PJ_POOL_ZALLOC_T(ice->pool, struct stun_data);
sd->ice = ice;
sd->comp_id = comp_id;
sd->comp = comp;
pj_stun_session_set_user_data(comp->stun_sess, sd);
/* Init STUN authentication credential */
pj_bzero(&auth_cred, sizeof(auth_cred));
auth_cred.type = PJ_STUN_AUTH_CRED_DYNAMIC;
auth_cred.data.dyn_cred.get_auth = &stun_auth_get_auth;
auth_cred.data.dyn_cred.get_cred = &stun_auth_get_cred;
auth_cred.data.dyn_cred.get_password = &stun_auth_get_password;
auth_cred.data.dyn_cred.user_data = comp->stun_sess;
pj_stun_session_set_credential(comp->stun_sess, PJ_STUN_AUTH_SHORT_TERM,
&auth_cred);
return PJ_SUCCESS;
}
/* Init options with default values */
PJ_DEF(void) pj_ice_sess_options_default(pj_ice_sess_options *opt)
{
opt->aggressive = PJ_TRUE;
opt->nominated_check_delay = PJ_ICE_NOMINATED_CHECK_DELAY;
opt->controlled_agent_want_nom_timeout =
ICE_CONTROLLED_AGENT_WAIT_NOMINATION_TIMEOUT;
}
/*
* Create ICE session.
*/
PJ_DEF(pj_status_t) pj_ice_sess_create(pj_stun_config *stun_cfg,
const char *name,
pj_ice_sess_role role,
unsigned comp_cnt,
const pj_ice_sess_cb *cb,
const pj_str_t *local_ufrag,
const pj_str_t *local_passwd,
pj_grp_lock_t *grp_lock,
pj_ice_sess **p_ice)
{
pj_pool_t *pool;
pj_ice_sess *ice;
unsigned i;
pj_status_t status;
PJ_ASSERT_RETURN(stun_cfg && cb && p_ice, PJ_EINVAL);
if (name == NULL)
name = "icess%p";
pool = pj_pool_create(stun_cfg->pf, name, PJNATH_POOL_LEN_ICE_SESS,
PJNATH_POOL_INC_ICE_SESS, NULL);
ice = PJ_POOL_ZALLOC_T(pool, pj_ice_sess);
ice->pool = pool;
ice->role = role;
ice->tie_breaker.u32.hi = pj_rand();
ice->tie_breaker.u32.lo = pj_rand();
ice->prefs = cand_type_prefs;
pj_ice_sess_options_default(&ice->opt);
pj_timer_entry_init(&ice->timer, TIMER_NONE, (void*)ice, &on_timer);
pj_ansi_snprintf(ice->obj_name, sizeof(ice->obj_name),
name, ice);
if (grp_lock) {
ice->grp_lock = grp_lock;
} else {
status = pj_grp_lock_create(pool, NULL, &ice->grp_lock);
if (status != PJ_SUCCESS) {
pj_pool_release(pool);
return status;
}
}
pj_grp_lock_add_ref(ice->grp_lock);
pj_grp_lock_add_handler(ice->grp_lock, pool, ice,
&ice_on_destroy);
pj_memcpy(&ice->cb, cb, sizeof(*cb));
pj_memcpy(&ice->stun_cfg, stun_cfg, sizeof(*stun_cfg));
ice->comp_cnt = comp_cnt;
for (i=0; i<comp_cnt; ++i) {
pj_ice_sess_comp *comp;
comp = &ice->comp[i];
comp->valid_check = NULL;
comp->nominated_check = NULL;
status = init_comp(ice, i+1, comp);
if (status != PJ_SUCCESS) {
destroy_ice(ice, status);
return status;
}
}
/* Initialize transport datas */
for (i=0; i<PJ_ARRAY_SIZE(ice->tp_data); ++i) {
ice->tp_data[i].transport_id = i;
ice->tp_data[i].has_req_data = PJ_FALSE;
}
if (local_ufrag == NULL) {
ice->rx_ufrag.ptr = (char*) pj_pool_alloc(ice->pool, PJ_ICE_UFRAG_LEN);
pj_create_random_string(ice->rx_ufrag.ptr, PJ_ICE_UFRAG_LEN);
ice->rx_ufrag.slen = PJ_ICE_UFRAG_LEN;
} else {
pj_strdup(ice->pool, &ice->rx_ufrag, local_ufrag);
}
if (local_passwd == NULL) {
ice->rx_pass.ptr = (char*) pj_pool_alloc(ice->pool, PJ_ICE_UFRAG_LEN);
pj_create_random_string(ice->rx_pass.ptr, PJ_ICE_UFRAG_LEN);
ice->rx_pass.slen = PJ_ICE_UFRAG_LEN;
} else {
pj_strdup(ice->pool, &ice->rx_pass, local_passwd);
}
pj_list_init(&ice->early_check);
/* Done */
*p_ice = ice;
LOG4((ice->obj_name,
"ICE session created, comp_cnt=%d, role is %s agent",
comp_cnt, role_names[ice->role]));
return PJ_SUCCESS;
}
/*
* Get the value of various options of the ICE session.
*/
PJ_DEF(pj_status_t) pj_ice_sess_get_options(pj_ice_sess *ice,
pj_ice_sess_options *opt)
{
PJ_ASSERT_RETURN(ice, PJ_EINVAL);
pj_memcpy(opt, &ice->opt, sizeof(*opt));
return PJ_SUCCESS;
}
/*
* Specify various options for this ICE session.
*/
PJ_DEF(pj_status_t) pj_ice_sess_set_options(pj_ice_sess *ice,
const pj_ice_sess_options *opt)
{
PJ_ASSERT_RETURN(ice && opt, PJ_EINVAL);
pj_memcpy(&ice->opt, opt, sizeof(*opt));
LOG5((ice->obj_name, "ICE nomination type set to %s",
(ice->opt.aggressive ? "aggressive" : "regular")));
return PJ_SUCCESS;
}
/*
* Callback to really destroy the session
*/
static void ice_on_destroy(void *obj)
{
pj_ice_sess *ice = (pj_ice_sess*) obj;
if (ice->pool) {
pj_pool_t *pool = ice->pool;
ice->pool = NULL;
pj_pool_release(pool);
}
LOG4((THIS_FILE, "ICE session %p destroyed", ice));
}
/*
* Destroy
*/
static void destroy_ice(pj_ice_sess *ice,
pj_status_t reason)
{
unsigned i;
if (reason == PJ_SUCCESS) {
LOG4((ice->obj_name, "Destroying ICE session %p", ice));
}
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
pj_grp_lock_release(ice->grp_lock);
return;
}
ice->is_destroying = PJ_TRUE;
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap,
&ice->timer, PJ_FALSE);
for (i=0; i<ice->comp_cnt; ++i) {
if (ice->comp[i].stun_sess) {
pj_stun_session_destroy(ice->comp[i].stun_sess);
ice->comp[i].stun_sess = NULL;
}
}
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap,
&ice->clist.timer,
PJ_FALSE);
pj_grp_lock_dec_ref(ice->grp_lock);
pj_grp_lock_release(ice->grp_lock);
}
/*
* Destroy
*/
PJ_DEF(pj_status_t) pj_ice_sess_destroy(pj_ice_sess *ice)
{
PJ_ASSERT_RETURN(ice, PJ_EINVAL);
destroy_ice(ice, PJ_SUCCESS);
return PJ_SUCCESS;
}
/*
* Change session role.
*/
PJ_DEF(pj_status_t) pj_ice_sess_change_role(pj_ice_sess *ice,
pj_ice_sess_role new_role)
{
PJ_ASSERT_RETURN(ice, PJ_EINVAL);
if (new_role != ice->role) {
ice->role = new_role;
LOG4((ice->obj_name, "Role changed to %s", role_names[new_role]));
}
return PJ_SUCCESS;
}
/*
* Change type preference
*/
PJ_DEF(pj_status_t) pj_ice_sess_set_prefs(pj_ice_sess *ice,
const pj_uint8_t prefs[4])
{
unsigned i;
PJ_ASSERT_RETURN(ice && prefs, PJ_EINVAL);
ice->prefs = (pj_uint8_t*) pj_pool_calloc(ice->pool, PJ_ARRAY_SIZE(prefs),
sizeof(pj_uint8_t));
for (i=0; i<4; ++i) {
#if PJ_ICE_CAND_TYPE_PREF_BITS < 8
pj_assert(prefs[i] < (2 << PJ_ICE_CAND_TYPE_PREF_BITS));
#endif
ice->prefs[i] = prefs[i];
}
return PJ_SUCCESS;
}
/* Find component by ID */
static pj_ice_sess_comp *find_comp(const pj_ice_sess *ice, unsigned comp_id)
{
pj_assert(comp_id > 0 && comp_id <= ice->comp_cnt);
return (pj_ice_sess_comp*) &ice->comp[comp_id-1];
}
/* Callback by STUN authentication when it needs to send 401 */
static pj_status_t stun_auth_get_auth(void *user_data,
pj_pool_t *pool,
pj_str_t *realm,
pj_str_t *nonce)
{
PJ_UNUSED_ARG(user_data);
PJ_UNUSED_ARG(pool);
realm->slen = 0;
nonce->slen = 0;
return PJ_SUCCESS;
}
/* Get credential to be sent with outgoing message */
static pj_status_t stun_auth_get_cred(const pj_stun_msg *msg,
void *user_data,
pj_pool_t *pool,
pj_str_t *realm,
pj_str_t *username,
pj_str_t *nonce,
pj_stun_passwd_type *data_type,
pj_str_t *data)
{
pj_stun_session *sess = (pj_stun_session *)user_data;
stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
pj_ice_sess *ice = sd->ice;
PJ_UNUSED_ARG(pool);
realm->slen = nonce->slen = 0;
if (PJ_STUN_IS_RESPONSE(msg->hdr.type)) {
/* Outgoing responses need to have the same credential as
* incoming requests.
*/
*username = ice->rx_uname;
*data_type = PJ_STUN_PASSWD_PLAIN;
*data = ice->rx_pass;
}
else {
*username = ice->tx_uname;
*data_type = PJ_STUN_PASSWD_PLAIN;
*data = ice->tx_pass;
}
return PJ_SUCCESS;
}
/* Get password to be used to authenticate incoming message */
static pj_status_t stun_auth_get_password(const pj_stun_msg *msg,
void *user_data,
const pj_str_t *realm,
const pj_str_t *username,
pj_pool_t *pool,
pj_stun_passwd_type *data_type,
pj_str_t *data)
{
pj_stun_session *sess = (pj_stun_session *)user_data;
stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
pj_ice_sess *ice = sd->ice;
PJ_UNUSED_ARG(realm);
PJ_UNUSED_ARG(pool);
if (PJ_STUN_IS_SUCCESS_RESPONSE(msg->hdr.type) ||
PJ_STUN_IS_ERROR_RESPONSE(msg->hdr.type))
{
/* Incoming response is authenticated with TX credential */
/* Verify username */
if (pj_strcmp(username, &ice->tx_uname) != 0)
return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_UNAUTHORIZED);
*data_type = PJ_STUN_PASSWD_PLAIN;
*data = ice->tx_pass;
} else {
/* Incoming request is authenticated with RX credential */
/* The agent MUST accept a credential if the username consists
* of two values separated by a colon, where the first value is
* equal to the username fragment generated by the agent in an offer
* or answer for a session in-progress, and the MESSAGE-INTEGRITY
* is the output of a hash of the password and the STUN packet's
* contents.
*/
const char *pos;
pj_str_t ufrag;
pos = (const char*)pj_memchr(username->ptr, ':', username->slen);
if (pos == NULL)
return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_UNAUTHORIZED);
ufrag.ptr = (char*)username->ptr;
ufrag.slen = (pos - username->ptr);
if (pj_strcmp(&ufrag, &ice->rx_ufrag) != 0)
return PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_UNAUTHORIZED);
*data_type = PJ_STUN_PASSWD_PLAIN;
*data = ice->rx_pass;
}
return PJ_SUCCESS;
}
static pj_uint32_t CALC_CAND_PRIO(pj_ice_sess *ice,
pj_ice_cand_type type,
pj_uint32_t local_pref,
pj_uint32_t comp_id)
{
#if PJNATH_ICE_PRIO_STD
return ((ice->prefs[type] & 0xFF) << 24) +
((local_pref & 0xFFFF) << 8) +
(((256 - comp_id) & 0xFF) << 0);
#else
enum {
type_mask = ((2 << PJ_ICE_CAND_TYPE_PREF_BITS) - 1),
local_mask = ((2 << PJ_ICE_LOCAL_PREF_BITS) - 1),
comp_mask = ((2 << PJ_ICE_COMP_BITS) - 1),
comp_shift = 0,
local_shift = (PJ_ICE_COMP_BITS),
type_shift = (comp_shift + local_shift),
max_comp = (2<<PJ_ICE_COMP_BITS),
};
return ((ice->prefs[type] & type_mask) << type_shift) +
((local_pref & local_mask) << local_shift) +
(((max_comp - comp_id) & comp_mask) << comp_shift);
#endif
}
/*
* Add ICE candidate
*/
PJ_DEF(pj_status_t) pj_ice_sess_add_cand(pj_ice_sess *ice,
unsigned comp_id,
unsigned transport_id,
pj_ice_cand_type type,
pj_uint16_t local_pref,
const pj_str_t *foundation,
const pj_sockaddr_t *addr,
const pj_sockaddr_t *base_addr,
const pj_sockaddr_t *rel_addr,
int addr_len,
unsigned *p_cand_id)
{
pj_ice_sess_cand *lcand;
pj_status_t status = PJ_SUCCESS;
char address[PJ_INET6_ADDRSTRLEN];
PJ_ASSERT_RETURN(ice && comp_id &&
foundation && addr && base_addr && addr_len,
PJ_EINVAL);
PJ_ASSERT_RETURN(comp_id <= ice->comp_cnt, PJ_EINVAL);
pj_grp_lock_acquire(ice->grp_lock);
if (ice->lcand_cnt >= PJ_ARRAY_SIZE(ice->lcand)) {
status = PJ_ETOOMANY;
goto on_error;
}
lcand = &ice->lcand[ice->lcand_cnt];
lcand->comp_id = (pj_uint8_t)comp_id;
lcand->transport_id = (pj_uint8_t)transport_id;
lcand->type = type;
pj_strdup(ice->pool, &lcand->foundation, foundation);
lcand->prio = CALC_CAND_PRIO(ice, type, local_pref, lcand->comp_id);
pj_sockaddr_cp(&lcand->addr, addr);
pj_sockaddr_cp(&lcand->base_addr, base_addr);
if (rel_addr == NULL)
rel_addr = base_addr;
pj_memcpy(&lcand->rel_addr, rel_addr, addr_len);
pj_ansi_strcpy(ice->tmp.txt, pj_sockaddr_print(&lcand->addr, address,
sizeof(address), 0));
LOG4((ice->obj_name,
"Candidate %d added: comp_id=%d, type=%s, foundation=%.*s, "
"addr=%s:%d, base=%s:%d, prio=0x%x (%u)",
ice->lcand_cnt,
lcand->comp_id,
cand_type_names[lcand->type],
(int)lcand->foundation.slen,
lcand->foundation.ptr,
ice->tmp.txt,
pj_sockaddr_get_port(&lcand->addr),
pj_sockaddr_print(&lcand->base_addr, address, sizeof(address), 0),
pj_sockaddr_get_port(&lcand->base_addr),
lcand->prio, lcand->prio));
if (p_cand_id)
*p_cand_id = ice->lcand_cnt;
++ice->lcand_cnt;
on_error:
pj_grp_lock_release(ice->grp_lock);
return status;
}
/* Find default candidate ID for the component */
PJ_DEF(pj_status_t) pj_ice_sess_find_default_cand(pj_ice_sess *ice,
unsigned comp_id,
int *cand_id)
{
unsigned i;
PJ_ASSERT_RETURN(ice && comp_id && cand_id, PJ_EINVAL);
PJ_ASSERT_RETURN(comp_id <= ice->comp_cnt, PJ_EINVAL);
*cand_id = -1;
pj_grp_lock_acquire(ice->grp_lock);
/* First find in valid list if we have nominated pair */
for (i=0; i<ice->valid_list.count; ++i) {
pj_ice_sess_check *check = &ice->valid_list.checks[i];
if (check->lcand->comp_id == comp_id) {
*cand_id = GET_LCAND_ID(check->lcand);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
}
/* If there's no nominated pair, find relayed candidate */
for (i=0; i<ice->lcand_cnt; ++i) {
pj_ice_sess_cand *lcand = &ice->lcand[i];
if (lcand->comp_id==comp_id &&
lcand->type == PJ_ICE_CAND_TYPE_RELAYED)
{
*cand_id = GET_LCAND_ID(lcand);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
}
/* If there's no relayed candidate, find reflexive candidate */
for (i=0; i<ice->lcand_cnt; ++i) {
pj_ice_sess_cand *lcand = &ice->lcand[i];
if (lcand->comp_id==comp_id &&
(lcand->type == PJ_ICE_CAND_TYPE_SRFLX ||
lcand->type == PJ_ICE_CAND_TYPE_PRFLX))
{
*cand_id = GET_LCAND_ID(lcand);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
}
/* Otherwise return host candidate */
for (i=0; i<ice->lcand_cnt; ++i) {
pj_ice_sess_cand *lcand = &ice->lcand[i];
if (lcand->comp_id==comp_id &&
lcand->type == PJ_ICE_CAND_TYPE_HOST)
{
*cand_id = GET_LCAND_ID(lcand);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
}
/* Still no candidate is found! :( */
pj_grp_lock_release(ice->grp_lock);
pj_assert(!"Should have a candidate by now");
return PJ_EBUG;
}
#ifndef MIN
# define MIN(a,b) (a < b ? a : b)
#endif
#ifndef MAX
# define MAX(a,b) (a > b ? a : b)
#endif
static pj_timestamp CALC_CHECK_PRIO(const pj_ice_sess *ice,
const pj_ice_sess_cand *lcand,
const pj_ice_sess_cand *rcand)
{
pj_uint32_t O, A;
pj_timestamp prio;
/* Original formula:
* pair priority = 2^32*MIN(O,A) + 2*MAX(O,A) + (O>A?1:0)
*/
if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLING) {
O = lcand->prio;
A = rcand->prio;
} else {
O = rcand->prio;
A = lcand->prio;
}
/*
return ((pj_uint64_t)1 << 32) * MIN(O, A) +
(pj_uint64_t)2 * MAX(O, A) + (O>A ? 1 : 0);
*/
prio.u32.hi = MIN(O,A);
prio.u32.lo = (MAX(O, A) << 1) + (O>A ? 1 : 0);
return prio;
}
PJ_INLINE(int) CMP_CHECK_PRIO(const pj_ice_sess_check *c1,
const pj_ice_sess_check *c2)
{
return pj_cmp_timestamp(&c1->prio, &c2->prio);
}
#if PJ_LOG_MAX_LEVEL >= 4
static const char *dump_check(char *buffer, unsigned bufsize,
const pj_ice_sess_checklist *clist,
const pj_ice_sess_check *check)
{
const pj_ice_sess_cand *lcand = check->lcand;
const pj_ice_sess_cand *rcand = check->rcand;
char laddr[PJ_INET6_ADDRSTRLEN], raddr[PJ_INET6_ADDRSTRLEN];
int len;
PJ_CHECK_STACK();
pj_ansi_strcpy(laddr, pj_sockaddr_print(&lcand->addr, laddr,
sizeof(laddr), 0));
len = pj_ansi_snprintf(buffer, bufsize,
"%d: [%d] %s:%d-->%s:%d",
(int)GET_CHECK_ID(clist, check),
check->lcand->comp_id,
pj_sockaddr_print(&lcand->addr, laddr,
sizeof(laddr), 0),
pj_sockaddr_get_port(&lcand->addr),
pj_sockaddr_print(&rcand->addr, raddr,
sizeof(raddr), 0),
pj_sockaddr_get_port(&rcand->addr));
if (len < 0)
len = 0;
else if (len >= (int)bufsize)
len = bufsize - 1;
buffer[len] = '\0';
return buffer;
}
static void dump_checklist(const char *title, pj_ice_sess *ice,
const pj_ice_sess_checklist *clist)
{
unsigned i;
LOG4((ice->obj_name, "%s", title));
for (i=0; i<clist->count; ++i) {
const pj_ice_sess_check *c = &clist->checks[i];
LOG4((ice->obj_name, " %s (%s, state=%s)",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), clist, c),
(c->nominated ? "nominated" : "not nominated"),
check_state_name[c->state]));
}
}
#else
#define dump_checklist(title, ice, clist)
#endif
static void check_set_state(pj_ice_sess *ice, pj_ice_sess_check *check,
pj_ice_sess_check_state st,
pj_status_t err_code)
{
pj_assert(check->state < PJ_ICE_SESS_CHECK_STATE_SUCCEEDED);
LOG5((ice->obj_name, "Check %s: state changed from %s to %s",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), &ice->clist, check),
check_state_name[check->state],
check_state_name[st]));
check->state = st;
check->err_code = err_code;
}
static void clist_set_state(pj_ice_sess *ice, pj_ice_sess_checklist *clist,
pj_ice_sess_checklist_state st)
{
if (clist->state != st) {
LOG5((ice->obj_name, "Checklist: state changed from %s to %s",
clist_state_name[clist->state],
clist_state_name[st]));
clist->state = st;
}
}
/* Sort checklist based on priority */
static void sort_checklist(pj_ice_sess *ice, pj_ice_sess_checklist *clist)
{
unsigned i;
pj_ice_sess_check **check_ptr[PJ_ICE_MAX_COMP*2];
unsigned check_ptr_cnt = 0;
for (i=0; i<ice->comp_cnt; ++i) {
if (ice->comp[i].valid_check) {
check_ptr[check_ptr_cnt++] = &ice->comp[i].valid_check;
}
if (ice->comp[i].nominated_check) {
check_ptr[check_ptr_cnt++] = &ice->comp[i].nominated_check;
}
}
pj_assert(clist->count > 0);
for (i=0; i<clist->count-1; ++i) {
unsigned j, highest = i;
for (j=i+1; j<clist->count; ++j) {
if (CMP_CHECK_PRIO(&clist->checks[j], &clist->checks[highest]) > 0) {
highest = j;
}
}
if (highest != i) {
pj_ice_sess_check tmp;
unsigned k;
pj_memcpy(&tmp, &clist->checks[i], sizeof(pj_ice_sess_check));
pj_memcpy(&clist->checks[i], &clist->checks[highest],
sizeof(pj_ice_sess_check));
pj_memcpy(&clist->checks[highest], &tmp,
sizeof(pj_ice_sess_check));
/* Update valid and nominated check pointers, since we're moving
* around checks
*/
for (k=0; k<check_ptr_cnt; ++k) {
if (*check_ptr[k] == &clist->checks[highest])
*check_ptr[k] = &clist->checks[i];
else if (*check_ptr[k] == &clist->checks[i])
*check_ptr[k] = &clist->checks[highest];
}
}
}
}
/* Prune checklist, this must have been done after the checklist
* is sorted.
*/
static pj_status_t prune_checklist(pj_ice_sess *ice,
pj_ice_sess_checklist *clist)
{
unsigned i;
/* Since an agent cannot send requests directly from a reflexive
* candidate, but only from its base, the agent next goes through the
* sorted list of candidate pairs. For each pair where the local
* candidate is server reflexive, the server reflexive candidate MUST be
* replaced by its base. Once this has been done, the agent MUST prune
* the list. This is done by removing a pair if its local and remote
* candidates are identical to the local and remote candidates of a pair
* higher up on the priority list. The result is a sequence of ordered
* candidate pairs, called the check list for that media stream.
*/
/* First replace SRFLX candidates with their base */
for (i=0; i<clist->count; ++i) {
pj_ice_sess_cand *srflx = clist->checks[i].lcand;
if (clist->checks[i].lcand->type == PJ_ICE_CAND_TYPE_SRFLX) {
/* Find the base for this candidate */
unsigned j;
for (j=0; j<ice->lcand_cnt; ++j) {
pj_ice_sess_cand *host = &ice->lcand[j];
if (host->type != PJ_ICE_CAND_TYPE_HOST)
continue;
if (pj_sockaddr_cmp(&srflx->base_addr, &host->addr) == 0) {
/* Replace this SRFLX with its BASE */
clist->checks[i].lcand = host;
break;
}
}
if (j==ice->lcand_cnt) {
char baddr[PJ_INET6_ADDRSTRLEN];
/* Host candidate not found this this srflx! */
LOG4((ice->obj_name,
"Base candidate %s:%d not found for srflx candidate %d",
pj_sockaddr_print(&srflx->base_addr, baddr,
sizeof(baddr), 0),
pj_sockaddr_get_port(&srflx->base_addr),
GET_LCAND_ID(clist->checks[i].lcand)));
return PJNATH_EICENOHOSTCAND;
}
}
}
/* Next remove a pair if its local and remote candidates are identical
* to the local and remote candidates of a pair higher up on the priority
* list
*/
/*
* Not in ICE!
* Remove host candidates if their base are the the same!
*/
for (i=0; i<clist->count; ++i) {
pj_ice_sess_cand *licand = clist->checks[i].lcand;
pj_ice_sess_cand *ricand = clist->checks[i].rcand;
unsigned j;
for (j=i+1; j<clist->count;) {
pj_ice_sess_cand *ljcand = clist->checks[j].lcand;
pj_ice_sess_cand *rjcand = clist->checks[j].rcand;
const char *reason = NULL;
if ((licand == ljcand) && (ricand == rjcand)) {
reason = "duplicate found";
} else if ((rjcand == ricand) &&
(pj_sockaddr_cmp(&ljcand->base_addr,
&licand->base_addr)==0))
{
reason = "equal base";
}
if (reason != NULL) {
/* Found duplicate, remove it */
LOG5((ice->obj_name, "Check %s pruned (%s)",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, &clist->checks[j]),
reason));
pj_array_erase(clist->checks, sizeof(clist->checks[0]),
clist->count, j);
--clist->count;
} else {
++j;
}
}
}
return PJ_SUCCESS;
}
/* Timer callback */
static void on_timer(pj_timer_heap_t *th, pj_timer_entry *te)
{
pj_ice_sess *ice = (pj_ice_sess*) te->user_data;
enum timer_type type = (enum timer_type)te->id;
PJ_UNUSED_ARG(th);
pj_grp_lock_acquire(ice->grp_lock);
te->id = TIMER_NONE;
if (ice->is_destroying) {
/* Stray timer, could happen when destroy is invoked while callback
* is pending. */
pj_grp_lock_release(ice->grp_lock);
return;
}
switch (type) {
case TIMER_CONTROLLED_WAIT_NOM:
LOG4((ice->obj_name,
"Controlled agent timed-out in waiting for the controlling "
"agent to send nominated check. Setting state to fail now.."));
on_ice_complete(ice, PJNATH_EICENOMTIMEOUT);
break;
case TIMER_COMPLETION_CALLBACK:
{
void (*on_ice_complete)(pj_ice_sess *ice, pj_status_t status);
pj_status_t ice_status;
/* Start keep-alive timer but don't send any packets yet.
* Need to do it here just in case app destroy the session
* in the callback.
*/
if (ice->ice_status == PJ_SUCCESS)
ice_keep_alive(ice, PJ_FALSE);
/* Release mutex in case app destroy us in the callback */
ice_status = ice->ice_status;
on_ice_complete = ice->cb.on_ice_complete;
/* Notify app about ICE completion*/
if (on_ice_complete)
(*on_ice_complete)(ice, ice_status);
}
break;
case TIMER_START_NOMINATED_CHECK:
start_nominated_check(ice);
break;
case TIMER_KEEP_ALIVE:
ice_keep_alive(ice, PJ_TRUE);
break;
case TIMER_NONE:
/* Nothing to do, just to get rid of gcc warning */
break;
}
pj_grp_lock_release(ice->grp_lock);
}
/* Send keep-alive */
static void ice_keep_alive(pj_ice_sess *ice, pj_bool_t send_now)
{
if (send_now) {
/* Send Binding Indication for the component */
pj_ice_sess_comp *comp = &ice->comp[ice->comp_ka];
pj_stun_tx_data *tdata;
pj_ice_sess_check *the_check;
pj_ice_msg_data *msg_data;
int addr_len;
pj_bool_t saved;
pj_status_t status;
/* Must have nominated check by now */
pj_assert(comp->nominated_check != NULL);
the_check = comp->nominated_check;
/* Create the Binding Indication */
status = pj_stun_session_create_ind(comp->stun_sess,
PJ_STUN_BINDING_INDICATION,
&tdata);
if (status != PJ_SUCCESS)
goto done;
/* Need the transport_id */
msg_data = PJ_POOL_ZALLOC_T(tdata->pool, pj_ice_msg_data);
msg_data->transport_id = the_check->lcand->transport_id;
/* Temporarily disable FINGERPRINT. The Binding Indication
* SHOULD NOT contain any attributes.
*/
saved = pj_stun_session_use_fingerprint(comp->stun_sess, PJ_FALSE);
/* Send to session */
addr_len = pj_sockaddr_get_len(&the_check->rcand->addr);
status = pj_stun_session_send_msg(comp->stun_sess, msg_data,
PJ_FALSE, PJ_FALSE,
&the_check->rcand->addr,
addr_len, tdata);
/* Restore FINGERPRINT usage */
pj_stun_session_use_fingerprint(comp->stun_sess, saved);
done:
ice->comp_ka = (ice->comp_ka + 1) % ice->comp_cnt;
}
if (ice->timer.id == TIMER_NONE) {
pj_time_val delay = { 0, 0 };
delay.msec = (PJ_ICE_SESS_KEEP_ALIVE_MIN +
(pj_rand() % PJ_ICE_SESS_KEEP_ALIVE_MAX_RAND)) * 1000 /
ice->comp_cnt;
pj_time_val_normalize(&delay);
pj_timer_heap_schedule_w_grp_lock(ice->stun_cfg.timer_heap,
&ice->timer, &delay,
TIMER_KEEP_ALIVE,
ice->grp_lock);
} else {
pj_assert(!"Not expected any timer active");
}
}
/* This function is called when ICE processing completes */
static void on_ice_complete(pj_ice_sess *ice, pj_status_t status)
{
if (!ice->is_complete) {
ice->is_complete = PJ_TRUE;
ice->ice_status = status;
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap, &ice->timer,
TIMER_NONE);
/* Log message */
LOG4((ice->obj_name, "ICE process complete, status=%s",
pj_strerror(status, ice->tmp.errmsg,
sizeof(ice->tmp.errmsg)).ptr));
dump_checklist("Valid list", ice, &ice->valid_list);
/* Call callback */
if (ice->cb.on_ice_complete) {
pj_time_val delay = {0, 0};
pj_timer_heap_schedule_w_grp_lock(ice->stun_cfg.timer_heap,
&ice->timer, &delay,
TIMER_COMPLETION_CALLBACK,
ice->grp_lock);
}
}
}
/* Update valid check and nominated check for the candidate */
static void update_comp_check(pj_ice_sess *ice, unsigned comp_id,
pj_ice_sess_check *check)
{
pj_ice_sess_comp *comp;
comp = find_comp(ice, comp_id);
if (comp->valid_check == NULL) {
comp->valid_check = check;
} else {
if (CMP_CHECK_PRIO(comp->valid_check, check) < 0)
comp->valid_check = check;
}
if (check->nominated) {
/* Update the nominated check for the component */
if (comp->nominated_check == NULL) {
comp->nominated_check = check;
} else {
if (CMP_CHECK_PRIO(comp->nominated_check, check) < 0)
comp->nominated_check = check;
}
}
}
/* This function is called when one check completes */
static pj_bool_t on_check_complete(pj_ice_sess *ice,
pj_ice_sess_check *check)
{
pj_ice_sess_comp *comp;
unsigned i;
pj_assert(check->state >= PJ_ICE_SESS_CHECK_STATE_SUCCEEDED);
comp = find_comp(ice, check->lcand->comp_id);
/* 7.1.2.2.2. Updating Pair States
*
* The agent sets the state of the pair that generated the check to
* Succeeded. The success of this check might also cause the state of
* other checks to change as well. The agent MUST perform the following
* two steps:
*
* 1. The agent changes the states for all other Frozen pairs for the
* same media stream and same foundation to Waiting. Typically
* these other pairs will have different component IDs but not
* always.
*/
if (check->err_code==PJ_SUCCESS) {
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (pj_strcmp(&c->lcand->foundation, &check->lcand->foundation)==0
&& c->state == PJ_ICE_SESS_CHECK_STATE_FROZEN)
{
check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_WAITING, 0);
}
}
LOG5((ice->obj_name, "Check %d is successful%s",
GET_CHECK_ID(&ice->clist, check),
(check->nominated ? " and nominated" : "")));
}
/* 8.2. Updating States
*
* For both controlling and controlled agents, the state of ICE
* processing depends on the presence of nominated candidate pairs in
* the valid list and on the state of the check list:
*
* o If there are no nominated pairs in the valid list for a media
* stream and the state of the check list is Running, ICE processing
* continues.
*
* o If there is at least one nominated pair in the valid list:
*
* - The agent MUST remove all Waiting and Frozen pairs in the check
* list for the same component as the nominated pairs for that
* media stream
*
* - If an In-Progress pair in the check list is for the same
* component as a nominated pair, the agent SHOULD cease
* retransmissions for its check if its pair priority is lower
* than the lowest priority nominated pair for that component
*/
if (check->err_code==PJ_SUCCESS && check->nominated) {
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (c->lcand->comp_id == check->lcand->comp_id) {
if (c->state < PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
/* Just fail Frozen/Waiting check */
LOG5((ice->obj_name,
"Check %s to be failed because state is %s",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, c),
check_state_name[c->state]));
check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_FAILED,
PJ_ECANCELLED);
} else if (c->state == PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS
&& (PJ_ICE_CANCEL_ALL ||
CMP_CHECK_PRIO(c, check) < 0)) {
/* State is IN_PROGRESS, cancel transaction */
if (c->tdata) {
LOG5((ice->obj_name,
"Cancelling check %s (In Progress)",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, c)));
pj_stun_session_cancel_req(comp->stun_sess,
c->tdata, PJ_FALSE, 0);
c->tdata = NULL;
check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_FAILED,
PJ_ECANCELLED);
}
}
}
}
}
/* Still in 8.2. Updating States
*
* o Once there is at least one nominated pair in the valid list for
* every component of at least one media stream and the state of the
* check list is Running:
*
* * The agent MUST change the state of processing for its check
* list for that media stream to Completed.
*
* * The agent MUST continue to respond to any checks it may still
* receive for that media stream, and MUST perform triggered
* checks if required by the processing of Section 7.2.
*
* * The agent MAY begin transmitting media for this media stream as
* described in Section 11.1
*/
/* See if all components have nominated pair. If they do, then mark
* ICE processing as success, otherwise wait.
*/
for (i=0; i<ice->comp_cnt; ++i) {
if (ice->comp[i].nominated_check == NULL)
break;
}
if (i == ice->comp_cnt) {
/* All components have nominated pair */
on_ice_complete(ice, PJ_SUCCESS);
return PJ_TRUE;
}
/* Note: this is the stuffs that we don't do in 7.1.2.2.2, since our
* ICE session only supports one media stream for now:
*
* 7.1.2.2.2. Updating Pair States
*
* 2. If there is a pair in the valid list for every component of this
* media stream (where this is the actual number of components being
* used, in cases where the number of components signaled in the SDP
* differs from offerer to answerer), the success of this check may
* unfreeze checks for other media streams.
*/
/* 7.1.2.3. Check List and Timer State Updates
* Regardless of whether the check was successful or failed, the
* completion of the transaction may require updating of check list and
* timer states.
*
* If all of the pairs in the check list are now either in the Failed or
* Succeeded state, and there is not a pair in the valid list for each
* component of the media stream, the state of the check list is set to
* Failed.
*/
/*
* See if all checks in the checklist have completed. If we do,
* then mark ICE processing as failed.
*/
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (c->state < PJ_ICE_SESS_CHECK_STATE_SUCCEEDED) {
break;
}
}
if (i == ice->clist.count) {
/* All checks have completed, but we don't have nominated pair.
* If agent's role is controlled, check if all components have
* valid pair. If it does, this means the controlled agent has
* finished the check list and it's waiting for controlling
* agent to send checks with USE-CANDIDATE flag set.
*/
if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLED) {
for (i=0; i < ice->comp_cnt; ++i) {
if (ice->comp[i].valid_check == NULL)
break;
}
if (i < ice->comp_cnt) {
/* This component ID doesn't have valid pair.
* Mark ICE as failed.
*/
on_ice_complete(ice, PJNATH_EICEFAILED);
return PJ_TRUE;
} else {
/* All components have a valid pair.
* We should wait until we receive nominated checks.
*/
if (ice->timer.id == TIMER_NONE &&
ice->opt.controlled_agent_want_nom_timeout >= 0)
{
pj_time_val delay;
delay.sec = 0;
delay.msec = ice->opt.controlled_agent_want_nom_timeout;
pj_time_val_normalize(&delay);
pj_timer_heap_schedule_w_grp_lock(
ice->stun_cfg.timer_heap,
&ice->timer, &delay,
TIMER_CONTROLLED_WAIT_NOM,
ice->grp_lock);
LOG5((ice->obj_name,
"All checks have completed. Controlled agent now "
"waits for nomination from controlling agent "
"(timeout=%d msec)",
ice->opt.controlled_agent_want_nom_timeout));
}
return PJ_FALSE;
}
/* Unreached */
} else if (ice->is_nominating) {
/* We are controlling agent and all checks have completed but
* there's at least one component without nominated pair (or
* more likely we don't have any nominated pairs at all).
*/
on_ice_complete(ice, PJNATH_EICEFAILED);
return PJ_TRUE;
} else {
/* We are controlling agent and all checks have completed. If
* we have valid list for every component, then move on to
* sending nominated check, otherwise we have failed.
*/
for (i=0; i<ice->comp_cnt; ++i) {
if (ice->comp[i].valid_check == NULL)
break;
}
if (i < ice->comp_cnt) {
/* At least one component doesn't have a valid check. Mark
* ICE as failed.
*/
on_ice_complete(ice, PJNATH_EICEFAILED);
return PJ_TRUE;
}
/* Now it's time to send connectivity check with nomination
* flag set.
*/
LOG4((ice->obj_name,
"All checks have completed, starting nominated checks now"));
start_nominated_check(ice);
return PJ_FALSE;
}
}
/* If this connectivity check has been successful, scan all components
* and see if they have a valid pair, if we are controlling and we haven't
* started our nominated check yet.
*/
if (check->err_code == PJ_SUCCESS &&
ice->role==PJ_ICE_SESS_ROLE_CONTROLLING &&
!ice->is_nominating &&
ice->timer.id == TIMER_NONE)
{
pj_time_val delay;
for (i=0; i<ice->comp_cnt; ++i) {
if (ice->comp[i].valid_check == NULL)
break;
}
if (i < ice->comp_cnt) {
/* Some components still don't have valid pair, continue
* processing.
*/
return PJ_FALSE;
}
LOG4((ice->obj_name,
"Scheduling nominated check in %d ms",
ice->opt.nominated_check_delay));
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap, &ice->timer,
TIMER_NONE);
/* All components have valid pair. Let connectivity checks run for
* a little bit more time, then start our nominated check.
*/
delay.sec = 0;
delay.msec = ice->opt.nominated_check_delay;
pj_time_val_normalize(&delay);
pj_timer_heap_schedule_w_grp_lock(ice->stun_cfg.timer_heap,
&ice->timer, &delay,
TIMER_START_NOMINATED_CHECK,
ice->grp_lock);
return PJ_FALSE;
}
/* We still have checks to perform */
return PJ_FALSE;
}
/* Create checklist by pairing local candidates with remote candidates */
PJ_DEF(pj_status_t) pj_ice_sess_create_check_list(
pj_ice_sess *ice,
const pj_str_t *rem_ufrag,
const pj_str_t *rem_passwd,
unsigned rcand_cnt,
const pj_ice_sess_cand rcand[])
{
pj_ice_sess_checklist *clist;
char buf[128];
pj_str_t username;
timer_data *td;
unsigned i, j;
unsigned highest_comp = 0;
pj_status_t status;
PJ_ASSERT_RETURN(ice && rem_ufrag && rem_passwd && rcand_cnt && rcand,
PJ_EINVAL);
PJ_ASSERT_RETURN(rcand_cnt + ice->rcand_cnt <= PJ_ICE_MAX_CAND,
PJ_ETOOMANY);
pj_grp_lock_acquire(ice->grp_lock);
/* Save credentials */
username.ptr = buf;
pj_strcpy(&username, rem_ufrag);
pj_strcat2(&username, ":");
pj_strcat(&username, &ice->rx_ufrag);
pj_strdup(ice->pool, &ice->tx_uname, &username);
pj_strdup(ice->pool, &ice->tx_ufrag, rem_ufrag);
pj_strdup(ice->pool, &ice->tx_pass, rem_passwd);
pj_strcpy(&username, &ice->rx_ufrag);
pj_strcat2(&username, ":");
pj_strcat(&username, rem_ufrag);
pj_strdup(ice->pool, &ice->rx_uname, &username);
/* Save remote candidates */
ice->rcand_cnt = 0;
for (i=0; i<rcand_cnt; ++i) {
pj_ice_sess_cand *cn = &ice->rcand[ice->rcand_cnt];
/* Ignore candidate which has no matching component ID */
if (rcand[i].comp_id==0 || rcand[i].comp_id > ice->comp_cnt) {
continue;
}
if (rcand[i].comp_id > highest_comp)
highest_comp = rcand[i].comp_id;
pj_memcpy(cn, &rcand[i], sizeof(pj_ice_sess_cand));
pj_strdup(ice->pool, &cn->foundation, &rcand[i].foundation);
ice->rcand_cnt++;
}
/* Generate checklist */
clist = &ice->clist;
for (i=0; i<ice->lcand_cnt; ++i) {
for (j=0; j<ice->rcand_cnt; ++j) {
pj_ice_sess_cand *lcand = &ice->lcand[i];
pj_ice_sess_cand *rcand = &ice->rcand[j];
pj_ice_sess_check *chk = &clist->checks[clist->count];
if (clist->count >= PJ_ICE_MAX_CHECKS) {
pj_grp_lock_release(ice->grp_lock);
return PJ_ETOOMANY;
}
/* A local candidate is paired with a remote candidate if
* and only if the two candidates have the same component ID
* and have the same IP address version.
*/
if ((lcand->comp_id != rcand->comp_id) ||
(lcand->addr.addr.sa_family != rcand->addr.addr.sa_family))
{
continue;
}
chk->lcand = lcand;
chk->rcand = rcand;
chk->state = PJ_ICE_SESS_CHECK_STATE_FROZEN;
chk->prio = CALC_CHECK_PRIO(ice, lcand, rcand);
clist->count++;
}
}
/* This could happen if candidates have no matching address families */
if (clist->count == 0) {
LOG4((ice->obj_name, "Error: no checklist can be created"));
pj_grp_lock_release(ice->grp_lock);
return PJ_ENOTFOUND;
}
/* Sort checklist based on priority */
sort_checklist(ice, clist);
/* Prune the checklist */
status = prune_checklist(ice, clist);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(ice->grp_lock);
return status;
}
/* Disable our components which don't have matching component */
for (i=highest_comp; i<ice->comp_cnt; ++i) {
if (ice->comp[i].stun_sess) {
pj_stun_session_destroy(ice->comp[i].stun_sess);
pj_bzero(&ice->comp[i], sizeof(ice->comp[i]));
}
}
ice->comp_cnt = highest_comp;
/* Init timer entry in the checklist. Initially the timer ID is FALSE
* because timer is not running.
*/
clist->timer.id = PJ_FALSE;
td = PJ_POOL_ZALLOC_T(ice->pool, timer_data);
td->ice = ice;
td->clist = clist;
clist->timer.user_data = (void*)td;
clist->timer.cb = &periodic_timer;
/* Log checklist */
dump_checklist("Checklist created:", ice, clist);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
/* Perform check on the specified candidate pair. */
static pj_status_t perform_check(pj_ice_sess *ice,
pj_ice_sess_checklist *clist,
unsigned check_id,
pj_bool_t nominate)
{
pj_ice_sess_comp *comp;
pj_ice_msg_data *msg_data;
pj_ice_sess_check *check;
const pj_ice_sess_cand *lcand;
const pj_ice_sess_cand *rcand;
pj_uint32_t prio;
pj_status_t status;
check = &clist->checks[check_id];
lcand = check->lcand;
rcand = check->rcand;
comp = find_comp(ice, lcand->comp_id);
LOG5((ice->obj_name,
"Sending connectivity check for check %s",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt), clist, check)));
pj_log_push_indent();
/* Create request */
status = pj_stun_session_create_req(comp->stun_sess,
PJ_STUN_BINDING_REQUEST, PJ_STUN_MAGIC,
NULL, &check->tdata);
if (status != PJ_SUCCESS) {
pjnath_perror(ice->obj_name, "Error creating STUN request", status);
pj_log_pop_indent();
return status;
}
/* Attach data to be retrieved later when STUN request transaction
* completes and on_stun_request_complete() callback is called.
*/
msg_data = PJ_POOL_ZALLOC_T(check->tdata->pool, pj_ice_msg_data);
msg_data->transport_id = lcand->transport_id;
msg_data->has_req_data = PJ_TRUE;
msg_data->data.req.ice = ice;
msg_data->data.req.clist = clist;
msg_data->data.req.ckid = check_id;
/* Add PRIORITY */
#if PJNATH_ICE_PRIO_STD
prio = CALC_CAND_PRIO(ice, PJ_ICE_CAND_TYPE_PRFLX, 65535,
lcand->comp_id);
#else
prio = CALC_CAND_PRIO(ice, PJ_ICE_CAND_TYPE_PRFLX, 0,
lcand->comp_id);
#endif
pj_stun_msg_add_uint_attr(check->tdata->pool, check->tdata->msg,
PJ_STUN_ATTR_PRIORITY, prio);
/* Add USE-CANDIDATE and set this check to nominated.
* Also add ICE-CONTROLLING or ICE-CONTROLLED
*/
if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLING) {
if (nominate) {
pj_stun_msg_add_empty_attr(check->tdata->pool, check->tdata->msg,
PJ_STUN_ATTR_USE_CANDIDATE);
check->nominated = PJ_TRUE;
}
pj_stun_msg_add_uint64_attr(check->tdata->pool, check->tdata->msg,
PJ_STUN_ATTR_ICE_CONTROLLING,
&ice->tie_breaker);
} else {
pj_stun_msg_add_uint64_attr(check->tdata->pool, check->tdata->msg,
PJ_STUN_ATTR_ICE_CONTROLLED,
&ice->tie_breaker);
}
/* Note that USERNAME and MESSAGE-INTEGRITY will be added by the
* STUN session.
*/
/* Initiate STUN transaction to send the request */
status = pj_stun_session_send_msg(comp->stun_sess, msg_data, PJ_FALSE,
PJ_TRUE, &rcand->addr,
pj_sockaddr_get_len(&rcand->addr),
check->tdata);
if (status != PJ_SUCCESS) {
check->tdata = NULL;
pjnath_perror(ice->obj_name, "Error sending STUN request", status);
pj_log_pop_indent();
return status;
}
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS,
PJ_SUCCESS);
pj_log_pop_indent();
return PJ_SUCCESS;
}
/* Start periodic check for the specified checklist.
* This callback is called by timer on every Ta (20msec by default)
*/
static pj_status_t start_periodic_check(pj_timer_heap_t *th,
pj_timer_entry *te)
{
timer_data *td;
pj_ice_sess *ice;
pj_ice_sess_checklist *clist;
unsigned i, start_count=0;
pj_status_t status;
td = (struct timer_data*) te->user_data;
ice = td->ice;
clist = td->clist;
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
/* Set timer ID to FALSE first */
te->id = PJ_FALSE;
/* Set checklist state to Running */
clist_set_state(ice, clist, PJ_ICE_SESS_CHECKLIST_ST_RUNNING);
LOG5((ice->obj_name, "Starting checklist periodic check"));
pj_log_push_indent();
/* Send STUN Binding request for check with highest priority on
* Waiting state.
*/
for (i=0; i<clist->count; ++i) {
pj_ice_sess_check *check = &clist->checks[i];
if (check->state == PJ_ICE_SESS_CHECK_STATE_WAITING) {
status = perform_check(ice, clist, i, ice->is_nominating);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(ice->grp_lock);
pj_log_pop_indent();
return status;
}
++start_count;
break;
}
}
/* If we don't have anything in Waiting state, perform check to
* highest priority pair that is in Frozen state.
*/
if (start_count==0) {
for (i=0; i<clist->count; ++i) {
pj_ice_sess_check *check = &clist->checks[i];
if (check->state == PJ_ICE_SESS_CHECK_STATE_FROZEN) {
status = perform_check(ice, clist, i, ice->is_nominating);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(ice->grp_lock);
pj_log_pop_indent();
return status;
}
++start_count;
break;
}
}
}
/* Cannot start check because there's no suitable candidate pair.
*/
if (start_count!=0) {
/* Schedule for next timer */
pj_time_val timeout = {0, PJ_ICE_TA_VAL};
pj_time_val_normalize(&timeout);
pj_timer_heap_schedule_w_grp_lock(th, te, &timeout, PJ_TRUE,
ice->grp_lock);
}
pj_grp_lock_release(ice->grp_lock);
pj_log_pop_indent();
return PJ_SUCCESS;
}
/* Start sending connectivity check with USE-CANDIDATE */
static void start_nominated_check(pj_ice_sess *ice)
{
pj_time_val delay;
unsigned i;
pj_status_t status;
LOG4((ice->obj_name, "Starting nominated check.."));
pj_log_push_indent();
pj_assert(ice->is_nominating == PJ_FALSE);
/* Stop our timer if it's active */
if (ice->timer.id == TIMER_START_NOMINATED_CHECK) {
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap, &ice->timer,
TIMER_NONE);
}
/* For each component, set the check state of valid check with
* highest priority to Waiting (it should have Success state now).
*/
for (i=0; i<ice->comp_cnt; ++i) {
unsigned j;
const pj_ice_sess_check *vc = ice->comp[i].valid_check;
pj_assert(ice->comp[i].nominated_check == NULL);
pj_assert(vc->err_code == PJ_SUCCESS);
for (j=0; j<ice->clist.count; ++j) {
pj_ice_sess_check *c = &ice->clist.checks[j];
if (c->lcand->transport_id == vc->lcand->transport_id &&
c->rcand == vc->rcand)
{
pj_assert(c->err_code == PJ_SUCCESS);
c->state = PJ_ICE_SESS_CHECK_STATE_FROZEN;
check_set_state(ice, c, PJ_ICE_SESS_CHECK_STATE_WAITING,
PJ_SUCCESS);
break;
}
}
}
/* And (re)start the periodic check */
pj_timer_heap_cancel_if_active(ice->stun_cfg.timer_heap,
&ice->clist.timer, PJ_FALSE);
delay.sec = delay.msec = 0;
status = pj_timer_heap_schedule_w_grp_lock(ice->stun_cfg.timer_heap,
&ice->clist.timer, &delay,
PJ_TRUE,
ice->grp_lock);
if (status == PJ_SUCCESS) {
LOG5((ice->obj_name, "Periodic timer rescheduled.."));
}
ice->is_nominating = PJ_TRUE;
pj_log_pop_indent();
}
/* Timer callback to perform periodic check */
static void periodic_timer(pj_timer_heap_t *th,
pj_timer_entry *te)
{
start_periodic_check(th, te);
}
/* Utility: find string in string array */
const pj_str_t *find_str(const pj_str_t *strlist[], unsigned count,
const pj_str_t *str)
{
unsigned i;
for (i=0; i<count; ++i) {
if (pj_strcmp(strlist[i], str)==0)
return strlist[i];
}
return NULL;
}
/*
* Start ICE periodic check. This function will return immediately, and
* application will be notified about the connectivity check status in
* #pj_ice_sess_cb callback.
*/
PJ_DEF(pj_status_t) pj_ice_sess_start_check(pj_ice_sess *ice)
{
pj_ice_sess_checklist *clist;
const pj_ice_sess_cand *cand0;
const pj_str_t *flist[PJ_ICE_MAX_CAND]; // XXX
pj_ice_rx_check *rcheck;
unsigned i, flist_cnt = 0;
pj_time_val delay;
pj_status_t status;
PJ_ASSERT_RETURN(ice, PJ_EINVAL);
/* Checklist must have been created */
PJ_ASSERT_RETURN(ice->clist.count > 0, PJ_EINVALIDOP);
/* Lock session */
pj_grp_lock_acquire(ice->grp_lock);
LOG4((ice->obj_name, "Starting ICE check.."));
pj_log_push_indent();
/* If we are using aggressive nomination, set the is_nominating state */
if (ice->opt.aggressive)
ice->is_nominating = PJ_TRUE;
/* The agent examines the check list for the first media stream (a
* media stream is the first media stream when it is described by
* the first m-line in the SDP offer and answer). For that media
* stream, it:
*
* - Groups together all of the pairs with the same foundation,
*
* - For each group, sets the state of the pair with the lowest
* component ID to Waiting. If there is more than one such pair,
* the one with the highest priority is used.
*/
clist = &ice->clist;
/* Pickup the first pair for component 1. */
for (i=0; i<clist->count; ++i) {
if (clist->checks[i].lcand->comp_id == 1)
break;
}
if (i == clist->count) {
pj_assert(!"Unable to find checklist for component 1");
pj_grp_lock_release(ice->grp_lock);
pj_log_pop_indent();
return PJNATH_EICEINCOMPID;
}
/* Set this check to WAITING only if state is frozen. It may be possible
* that this check has already been started by a trigger check
*/
if (clist->checks[i].state == PJ_ICE_SESS_CHECK_STATE_FROZEN) {
check_set_state(ice, &clist->checks[i],
PJ_ICE_SESS_CHECK_STATE_WAITING, PJ_SUCCESS);
}
cand0 = clist->checks[i].lcand;
flist[flist_cnt++] = &clist->checks[i].lcand->foundation;
/* Find all of the other pairs in that check list with the same
* component ID, but different foundations, and sets all of their
* states to Waiting as well.
*/
for (++i; i<clist->count; ++i) {
const pj_ice_sess_cand *cand1;
cand1 = clist->checks[i].lcand;
if (cand1->comp_id==cand0->comp_id &&
find_str(flist, flist_cnt, &cand1->foundation)==NULL)
{
if (clist->checks[i].state == PJ_ICE_SESS_CHECK_STATE_FROZEN) {
check_set_state(ice, &clist->checks[i],
PJ_ICE_SESS_CHECK_STATE_WAITING, PJ_SUCCESS);
}
flist[flist_cnt++] = &cand1->foundation;
}
}
/* First, perform all pending triggered checks, simultaneously. */
rcheck = ice->early_check.next;
while (rcheck != &ice->early_check) {
LOG4((ice->obj_name,
"Performing delayed triggerred check for component %d",
rcheck->comp_id));
pj_log_push_indent();
handle_incoming_check(ice, rcheck);
rcheck = rcheck->next;
pj_log_pop_indent();
}
pj_list_init(&ice->early_check);
/* Start periodic check */
/* We could start it immediately like below, but lets schedule timer
* instead to reduce stack usage:
* return start_periodic_check(ice->stun_cfg.timer_heap, &clist->timer);
*/
delay.sec = delay.msec = 0;
status = pj_timer_heap_schedule_w_grp_lock(ice->stun_cfg.timer_heap,
&clist->timer, &delay,
PJ_TRUE, ice->grp_lock);
if (status != PJ_SUCCESS) {
clist->timer.id = PJ_FALSE;
}
pj_grp_lock_release(ice->grp_lock);
pj_log_pop_indent();
return status;
}
//////////////////////////////////////////////////////////////////////////////
/* Callback called by STUN session to send the STUN message.
* STUN session also doesn't have a transport, remember?!
*/
static pj_status_t on_stun_send_msg(pj_stun_session *sess,
void *token,
const void *pkt,
pj_size_t pkt_size,
const pj_sockaddr_t *dst_addr,
unsigned addr_len)
{
stun_data *sd = (stun_data*) pj_stun_session_get_user_data(sess);
pj_ice_sess *ice = sd->ice;
pj_ice_msg_data *msg_data = (pj_ice_msg_data*) token;
pj_status_t status;
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
/* Stray retransmit timer that could happen while
* we're being destroyed */
pj_grp_lock_release(ice->grp_lock);
return PJ_EINVALIDOP;
}
status = (*ice->cb.on_tx_pkt)(ice, sd->comp_id, msg_data->transport_id,
pkt, pkt_size, dst_addr, addr_len);
pj_grp_lock_release(ice->grp_lock);
return status;
}
/* This callback is called when outgoing STUN request completed */
static void on_stun_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)
{
pj_ice_msg_data *msg_data = (pj_ice_msg_data*) token;
pj_ice_sess *ice;
pj_ice_sess_check *check, *new_check;
pj_ice_sess_cand *lcand;
pj_ice_sess_checklist *clist;
pj_stun_xor_mapped_addr_attr *xaddr;
unsigned i;
PJ_UNUSED_ARG(stun_sess);
PJ_UNUSED_ARG(src_addr_len);
pj_assert(msg_data->has_req_data);
ice = msg_data->data.req.ice;
clist = msg_data->data.req.clist;
check = &clist->checks[msg_data->data.req.ckid];
/* Mark STUN transaction as complete */
pj_assert(tdata == check->tdata);
check->tdata = NULL;
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
/* Not sure if this is possible but just in case */
pj_grp_lock_release(ice->grp_lock);
return;
}
/* Init lcand to NULL. lcand will be found from the mapped address
* found in the response.
*/
lcand = NULL;
if (status != PJ_SUCCESS) {
char errmsg[PJ_ERR_MSG_SIZE];
if (status==PJ_STATUS_FROM_STUN_CODE(PJ_STUN_SC_ROLE_CONFLICT)) {
/* Role conclict response.
*
* 7.1.2.1. Failure Cases:
*
* If the request had contained the ICE-CONTROLLED attribute,
* the agent MUST switch to the controlling role if it has not
* already done so. If the request had contained the
* ICE-CONTROLLING attribute, the agent MUST switch to the
* controlled role if it has not already done so. Once it has
* switched, the agent MUST immediately retry the request with
* the ICE-CONTROLLING or ICE-CONTROLLED attribute reflecting
* its new role.
*/
pj_ice_sess_role new_role = PJ_ICE_SESS_ROLE_UNKNOWN;
pj_stun_msg *req = tdata->msg;
if (pj_stun_msg_find_attr(req, PJ_STUN_ATTR_ICE_CONTROLLING, 0)) {
new_role = PJ_ICE_SESS_ROLE_CONTROLLED;
} else if (pj_stun_msg_find_attr(req, PJ_STUN_ATTR_ICE_CONTROLLED,
0)) {
new_role = PJ_ICE_SESS_ROLE_CONTROLLING;
} else {
pj_assert(!"We should have put CONTROLLING/CONTROLLED attr!");
new_role = PJ_ICE_SESS_ROLE_CONTROLLED;
}
if (new_role != ice->role) {
LOG4((ice->obj_name,
"Changing role because of role conflict response"));
pj_ice_sess_change_role(ice, new_role);
}
/* Resend request */
LOG4((ice->obj_name, "Resending check because of role conflict"));
pj_log_push_indent();
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_WAITING, 0);
perform_check(ice, clist, msg_data->data.req.ckid,
check->nominated || ice->is_nominating);
pj_log_pop_indent();
pj_grp_lock_release(ice->grp_lock);
return;
}
pj_strerror(status, errmsg, sizeof(errmsg));
LOG4((ice->obj_name,
"Check %s%s: connectivity check FAILED: %s",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, check),
(check->nominated ? " (nominated)" : " (not nominated)"),
errmsg));
pj_log_push_indent();
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, status);
on_check_complete(ice, check);
pj_log_pop_indent();
pj_grp_lock_release(ice->grp_lock);
return;
}
/* 7.1.2.1. Failure Cases
*
* The agent MUST check that the source IP address and port of the
* response equals the destination IP address and port that the Binding
* Request was sent to, and that the destination IP address and port of
* the response match the source IP address and port that the Binding
* Request was sent from.
*/
if (pj_sockaddr_cmp(&check->rcand->addr, (const pj_sockaddr*)src_addr)!=0)
{
status = PJNATH_EICEINSRCADDR;
LOG4((ice->obj_name,
"Check %s%s: connectivity check FAILED: source address mismatch",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, check),
(check->nominated ? " (nominated)" : " (not nominated)")));
pj_log_push_indent();
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED, status);
on_check_complete(ice, check);
pj_log_pop_indent();
pj_grp_lock_release(ice->grp_lock);
return;
}
/* 7.1.2.2. Success Cases
*
* A check is considered to be a success if all of the following are
* true:
*
* o the STUN transaction generated a success response
*
* o the source IP address and port of the response equals the
* destination IP address and port that the Binding Request was sent
* to
*
* o the destination IP address and port of the response match the
* source IP address and port that the Binding Request was sent from
*/
LOG4((ice->obj_name,
"Check %s%s: connectivity check SUCCESS",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->clist, check),
(check->nominated ? " (nominated)" : " (not nominated)")));
/* Get the STUN XOR-MAPPED-ADDRESS attribute. */
xaddr = (pj_stun_xor_mapped_addr_attr*)
pj_stun_msg_find_attr(response, PJ_STUN_ATTR_XOR_MAPPED_ADDR,0);
if (!xaddr) {
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED,
PJNATH_ESTUNNOMAPPEDADDR);
on_check_complete(ice, check);
pj_grp_lock_release(ice->grp_lock);
return;
}
/* Find local candidate that matches the XOR-MAPPED-ADDRESS */
pj_assert(lcand == NULL);
for (i=0; i<ice->lcand_cnt; ++i) {
if (pj_sockaddr_cmp(&xaddr->sockaddr, &ice->lcand[i].addr) == 0) {
/* Match */
lcand = &ice->lcand[i];
break;
}
}
/* 7.1.2.2.1. Discovering Peer Reflexive Candidates
* If the transport address returned in XOR-MAPPED-ADDRESS does not match
* any of the local candidates that the agent knows about, the mapped
* address represents a new candidate - a peer reflexive candidate.
*/
if (lcand == NULL) {
unsigned cand_id;
pj_str_t foundation;
pj_ice_calc_foundation(ice->pool, &foundation, PJ_ICE_CAND_TYPE_PRFLX,
&check->lcand->base_addr);
/* Still in 7.1.2.2.1. Discovering Peer Reflexive Candidates
* Its priority is set equal to the value of the PRIORITY attribute
* in the Binding Request.
*
* I think the priority calculated by add_cand() should be the same
* as the one calculated in perform_check(), so there's no need to
* get the priority from the PRIORITY attribute.
*/
/* Add new peer reflexive candidate */
status = pj_ice_sess_add_cand(ice, check->lcand->comp_id,
msg_data->transport_id,
PJ_ICE_CAND_TYPE_PRFLX,
65535, &foundation,
&xaddr->sockaddr,
&check->lcand->base_addr,
&check->lcand->base_addr,
pj_sockaddr_get_len(&xaddr->sockaddr),
&cand_id);
if (status != PJ_SUCCESS) {
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_FAILED,
status);
on_check_complete(ice, check);
pj_grp_lock_release(ice->grp_lock);
return;
}
/* Update local candidate */
lcand = &ice->lcand[cand_id];
}
/* 7.1.2.2.3. Constructing a Valid Pair
* Next, the agent constructs a candidate pair whose local candidate
* equals the mapped address of the response, and whose remote candidate
* equals the destination address to which the request was sent.
*/
/* Add pair to valid list, if it's not there, otherwise just update
* nominated flag
*/
for (i=0; i<ice->valid_list.count; ++i) {
if (ice->valid_list.checks[i].lcand == lcand &&
ice->valid_list.checks[i].rcand == check->rcand)
break;
}
if (i==ice->valid_list.count) {
pj_assert(ice->valid_list.count < PJ_ICE_MAX_CHECKS);
new_check = &ice->valid_list.checks[ice->valid_list.count++];
new_check->lcand = lcand;
new_check->rcand = check->rcand;
new_check->prio = CALC_CHECK_PRIO(ice, lcand, check->rcand);
new_check->state = PJ_ICE_SESS_CHECK_STATE_SUCCEEDED;
new_check->nominated = check->nominated;
new_check->err_code = PJ_SUCCESS;
} else {
new_check = &ice->valid_list.checks[i];
ice->valid_list.checks[i].nominated = check->nominated;
}
/* Update valid check and nominated check for the component */
update_comp_check(ice, new_check->lcand->comp_id, new_check);
/* Sort valid_list (must do so after update_comp_check(), otherwise
* new_check will point to something else (#953)
*/
sort_checklist(ice, &ice->valid_list);
/* 7.1.2.2.2. Updating Pair States
*
* The agent sets the state of the pair that generated the check to
* Succeeded. The success of this check might also cause the state of
* other checks to change as well.
*/
check_set_state(ice, check, PJ_ICE_SESS_CHECK_STATE_SUCCEEDED,
PJ_SUCCESS);
/* Perform 7.1.2.2.2. Updating Pair States.
* This may terminate ICE processing.
*/
if (on_check_complete(ice, check)) {
/* ICE complete! */
pj_grp_lock_release(ice->grp_lock);
return;
}
pj_grp_lock_release(ice->grp_lock);
}
/* This callback is called by the STUN session associated with a candidate
* when it receives incoming request.
*/
static pj_status_t on_stun_rx_request(pj_stun_session *sess,
const pj_uint8_t *pkt,
unsigned pkt_len,
const pj_stun_rx_data *rdata,
void *token,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
stun_data *sd;
const pj_stun_msg *msg = rdata->msg;
pj_ice_msg_data *msg_data;
pj_ice_sess *ice;
pj_stun_priority_attr *prio_attr;
pj_stun_use_candidate_attr *uc_attr;
pj_stun_uint64_attr *role_attr;
pj_stun_tx_data *tdata;
pj_ice_rx_check *rcheck, tmp_rcheck;
pj_status_t status;
PJ_UNUSED_ARG(pkt);
PJ_UNUSED_ARG(pkt_len);
/* Reject any requests except Binding request */
if (msg->hdr.type != PJ_STUN_BINDING_REQUEST) {
pj_stun_session_respond(sess, rdata, PJ_STUN_SC_BAD_REQUEST,
NULL, token, PJ_TRUE,
src_addr, src_addr_len);
return PJ_SUCCESS;
}
sd = (stun_data*) pj_stun_session_get_user_data(sess);
ice = sd->ice;
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
pj_grp_lock_release(ice->grp_lock);
return PJ_EINVALIDOP;
}
/*
* Note:
* Be aware that when STUN request is received, we might not get
* SDP answer yet, so we might not have remote candidates and
* checklist yet. This case will be handled after we send
* a response.
*/
/* Get PRIORITY attribute */
prio_attr = (pj_stun_priority_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_PRIORITY, 0);
if (prio_attr == NULL) {
LOG5((ice->obj_name, "Received Binding request with no PRIORITY"));
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
/* Get USE-CANDIDATE attribute */
uc_attr = (pj_stun_use_candidate_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_USE_CANDIDATE, 0);
/* Get ICE-CONTROLLING or ICE-CONTROLLED */
role_attr = (pj_stun_uint64_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_ICE_CONTROLLING, 0);
if (role_attr == NULL) {
role_attr = (pj_stun_uint64_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_ICE_CONTROLLED, 0);
}
/* Handle the case when request comes before answer is received.
* We need to put credential in the response, and since we haven't
* got the response, copy the username from the request.
*/
if (ice->rcand_cnt == 0) {
pj_stun_string_attr *uname_attr;
uname_attr = (pj_stun_string_attr*)
pj_stun_msg_find_attr(msg, PJ_STUN_ATTR_USERNAME, 0);
pj_assert(uname_attr != NULL);
pj_strdup(ice->pool, &ice->rx_uname, &uname_attr->value);
}
/* 7.2.1.1. Detecting and Repairing Role Conflicts
*/
if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLING &&
role_attr && role_attr->hdr.type == PJ_STUN_ATTR_ICE_CONTROLLING)
{
if (pj_cmp_timestamp(&ice->tie_breaker, &role_attr->value) < 0) {
/* Switch role to controlled */
LOG4((ice->obj_name,
"Changing role because of ICE-CONTROLLING attribute"));
pj_ice_sess_change_role(ice, PJ_ICE_SESS_ROLE_CONTROLLED);
} else {
/* Generate 487 response */
pj_stun_session_respond(sess, rdata, PJ_STUN_SC_ROLE_CONFLICT,
NULL, token, PJ_TRUE,
src_addr, src_addr_len);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
} else if (ice->role == PJ_ICE_SESS_ROLE_CONTROLLED &&
role_attr && role_attr->hdr.type == PJ_STUN_ATTR_ICE_CONTROLLED)
{
if (pj_cmp_timestamp(&ice->tie_breaker, &role_attr->value) < 0) {
/* Generate 487 response */
pj_stun_session_respond(sess, rdata, PJ_STUN_SC_ROLE_CONFLICT,
NULL, token, PJ_TRUE,
src_addr, src_addr_len);
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
} else {
/* Switch role to controlled */
LOG4((ice->obj_name,
"Changing role because of ICE-CONTROLLED attribute"));
pj_ice_sess_change_role(ice, PJ_ICE_SESS_ROLE_CONTROLLING);
}
}
/*
* First send response to this request
*/
status = pj_stun_session_create_res(sess, rdata, 0, NULL, &tdata);
if (status != PJ_SUCCESS) {
pj_grp_lock_release(ice->grp_lock);
return status;
}
/* Add XOR-MAPPED-ADDRESS attribute */
status = pj_stun_msg_add_sockaddr_attr(tdata->pool, tdata->msg,
PJ_STUN_ATTR_XOR_MAPPED_ADDR,
PJ_TRUE, src_addr, src_addr_len);
/* Create a msg_data to be associated with this response */
msg_data = PJ_POOL_ZALLOC_T(tdata->pool, pj_ice_msg_data);
msg_data->transport_id = ((pj_ice_msg_data*)token)->transport_id;
msg_data->has_req_data = PJ_FALSE;
/* Send the response */
status = pj_stun_session_send_msg(sess, msg_data, PJ_TRUE, PJ_TRUE,
src_addr, src_addr_len, tdata);
/*
* Handling early check.
*
* It's possible that we receive this request before we receive SDP
* answer. In this case, we can't perform trigger check since we
* don't have checklist yet, so just save this check in a pending
* triggered check array to be acted upon later.
*/
if (ice->rcand_cnt == 0) {
rcheck = PJ_POOL_ZALLOC_T(ice->pool, pj_ice_rx_check);
} else {
rcheck = &tmp_rcheck;
}
/* Init rcheck */
rcheck->comp_id = sd->comp_id;
rcheck->transport_id = ((pj_ice_msg_data*)token)->transport_id;
rcheck->src_addr_len = src_addr_len;
pj_sockaddr_cp(&rcheck->src_addr, src_addr);
rcheck->use_candidate = (uc_attr != NULL);
rcheck->priority = prio_attr->value;
rcheck->role_attr = role_attr;
if (ice->rcand_cnt == 0) {
/* We don't have answer yet, so keep this request for later */
LOG4((ice->obj_name, "Received an early check for comp %d",
rcheck->comp_id));
pj_list_push_back(&ice->early_check, rcheck);
} else {
/* Handle this check */
handle_incoming_check(ice, rcheck);
}
pj_grp_lock_release(ice->grp_lock);
return PJ_SUCCESS;
}
/* Handle incoming Binding request and perform triggered check.
* This function may be called by on_stun_rx_request(), or when
* SDP answer is received and we have received early checks.
*/
static void handle_incoming_check(pj_ice_sess *ice,
const pj_ice_rx_check *rcheck)
{
pj_ice_sess_comp *comp;
pj_ice_sess_cand *lcand = NULL;
pj_ice_sess_cand *rcand;
unsigned i;
comp = find_comp(ice, rcheck->comp_id);
/* Find remote candidate based on the source transport address of
* the request.
*/
for (i=0; i<ice->rcand_cnt; ++i) {
if (pj_sockaddr_cmp(&rcheck->src_addr, &ice->rcand[i].addr)==0)
break;
}
/* 7.2.1.3. Learning Peer Reflexive Candidates
* If the source transport address of the request does not match any
* existing remote candidates, it represents a new peer reflexive remote
* candidate.
*/
if (i == ice->rcand_cnt) {
char raddr[PJ_INET6_ADDRSTRLEN];
if (ice->rcand_cnt >= PJ_ICE_MAX_CAND) {
LOG4((ice->obj_name,
"Unable to add new peer reflexive candidate: too many "
"candidates already (%d)", PJ_ICE_MAX_CAND));
return;
}
rcand = &ice->rcand[ice->rcand_cnt++];
rcand->comp_id = (pj_uint8_t)rcheck->comp_id;
rcand->type = PJ_ICE_CAND_TYPE_PRFLX;
rcand->prio = rcheck->priority;
pj_sockaddr_cp(&rcand->addr, &rcheck->src_addr);
/* Foundation is random, unique from other foundation */
rcand->foundation.ptr = (char*) pj_pool_alloc(ice->pool, 36);
rcand->foundation.slen = pj_ansi_snprintf(rcand->foundation.ptr, 36,
"f%p",
rcand->foundation.ptr);
LOG4((ice->obj_name,
"Added new remote candidate from the request: %s:%d",
pj_sockaddr_print(&rcand->addr, raddr, sizeof(raddr), 0),
pj_sockaddr_get_port(&rcand->addr)));
} else {
/* Remote candidate found */
rcand = &ice->rcand[i];
}
#if 0
/* Find again the local candidate by matching the base address
* with the local candidates in the checklist. Checks may have
* been pruned before, so it's possible that if we use the lcand
* as it is, we wouldn't be able to find the check in the checklist
* and we will end up creating a new check unnecessarily.
*/
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (/*c->lcand == lcand ||*/
pj_sockaddr_cmp(&c->lcand->base_addr, &lcand->base_addr)==0)
{
lcand = c->lcand;
break;
}
}
#else
/* Just get candidate with the highest priority and same transport ID
* for the specified component ID in the checklist.
*/
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (c->lcand->comp_id == rcheck->comp_id &&
c->lcand->transport_id == rcheck->transport_id)
{
lcand = c->lcand;
break;
}
}
if (lcand == NULL) {
/* Should not happen, but just in case remote is sending a
* Binding request for a component which it doesn't have.
*/
LOG4((ice->obj_name,
"Received Binding request but no local candidate is found!"));
return;
}
#endif
/*
* Create candidate pair for this request.
*/
/*
* 7.2.1.4. Triggered Checks
*
* Now that we have local and remote candidate, check if we already
* have this pair in our checklist.
*/
for (i=0; i<ice->clist.count; ++i) {
pj_ice_sess_check *c = &ice->clist.checks[i];
if (c->lcand == lcand && c->rcand == rcand)
break;
}
/* If the pair is already on the check list:
* - If the state of that pair is Waiting or Frozen, its state is
* changed to In-Progress and a check for that pair is performed
* immediately. This is called a triggered check.
*
* - If the state of that pair is In-Progress, the agent SHOULD
* generate an immediate retransmit of the Binding Request for the
* check in progress. This is to facilitate rapid completion of
* ICE when both agents are behind NAT.
*
* - If the state of that pair is Failed or Succeeded, no triggered
* check is sent.
*/
if (i != ice->clist.count) {
pj_ice_sess_check *c = &ice->clist.checks[i];
/* If USE-CANDIDATE is present, set nominated flag
* Note: DO NOT overwrite nominated flag if one is already set.
*/
c->nominated = ((rcheck->use_candidate) || c->nominated);
if (c->state == PJ_ICE_SESS_CHECK_STATE_FROZEN ||
c->state == PJ_ICE_SESS_CHECK_STATE_WAITING)
{
/* See if we shall nominate this check */
pj_bool_t nominate = (c->nominated || ice->is_nominating);
LOG5((ice->obj_name, "Performing triggered check for check %d",i));
pj_log_push_indent();
perform_check(ice, &ice->clist, i, nominate);
pj_log_pop_indent();
} else if (c->state == PJ_ICE_SESS_CHECK_STATE_IN_PROGRESS) {
/* Should retransmit immediately
*/
LOG5((ice->obj_name, "Triggered check for check %d not performed "
"because it's in progress. Retransmitting", i));
pj_log_push_indent();
pj_stun_session_retransmit_req(comp->stun_sess, c->tdata, PJ_FALSE);
pj_log_pop_indent();
} else if (c->state == PJ_ICE_SESS_CHECK_STATE_SUCCEEDED) {
/* Check complete for this component.
* Note this may end ICE process.
*/
pj_bool_t complete;
unsigned j;
/* If this check is nominated, scan the valid_list for the
* same check and update the nominated flag. A controlled
* agent might have finished the check earlier.
*/
if (rcheck->use_candidate) {
for (j=0; j<ice->valid_list.count; ++j) {
pj_ice_sess_check *vc = &ice->valid_list.checks[j];
if (vc->lcand->transport_id == c->lcand->transport_id &&
vc->rcand == c->rcand)
{
/* Set nominated flag */
vc->nominated = PJ_TRUE;
/* Update valid check and nominated check for the component */
update_comp_check(ice, vc->lcand->comp_id, vc);
LOG5((ice->obj_name, "Valid check %s is nominated",
dump_check(ice->tmp.txt, sizeof(ice->tmp.txt),
&ice->valid_list, vc)));
}
}
}
LOG5((ice->obj_name, "Triggered check for check %d not performed "
"because it's completed", i));
pj_log_push_indent();
complete = on_check_complete(ice, c);
pj_log_pop_indent();
if (complete) {
return;
}
}
}
/* If the pair is not already on the check list:
* - The pair is inserted into the check list based on its priority.
* - Its state is set to In-Progress
* - A triggered check for that pair is performed immediately.
*/
/* Note: only do this if we don't have too many checks in checklist */
else if (ice->clist.count < PJ_ICE_MAX_CHECKS) {
pj_ice_sess_check *c = &ice->clist.checks[ice->clist.count];
pj_bool_t nominate;
c->lcand = lcand;
c->rcand = rcand;
c->prio = CALC_CHECK_PRIO(ice, lcand, rcand);
c->state = PJ_ICE_SESS_CHECK_STATE_WAITING;
c->nominated = rcheck->use_candidate;
c->err_code = PJ_SUCCESS;
nominate = (c->nominated || ice->is_nominating);
LOG4((ice->obj_name, "New triggered check added: %d",
ice->clist.count));
pj_log_push_indent();
perform_check(ice, &ice->clist, ice->clist.count++, nominate);
pj_log_pop_indent();
} else {
LOG4((ice->obj_name, "Error: unable to perform triggered check: "
"TOO MANY CHECKS IN CHECKLIST!"));
}
}
static pj_status_t on_stun_rx_indication(pj_stun_session *sess,
const pj_uint8_t *pkt,
unsigned pkt_len,
const pj_stun_msg *msg,
void *token,
const pj_sockaddr_t *src_addr,
unsigned src_addr_len)
{
struct stun_data *sd;
PJ_UNUSED_ARG(sess);
PJ_UNUSED_ARG(pkt);
PJ_UNUSED_ARG(pkt_len);
PJ_UNUSED_ARG(msg);
PJ_UNUSED_ARG(token);
PJ_UNUSED_ARG(src_addr);
PJ_UNUSED_ARG(src_addr_len);
sd = (struct stun_data*) pj_stun_session_get_user_data(sess);
pj_log_push_indent();
if (msg->hdr.type == PJ_STUN_BINDING_INDICATION) {
LOG5((sd->ice->obj_name, "Received Binding Indication keep-alive "
"for component %d", sd->comp_id));
} else {
LOG4((sd->ice->obj_name, "Received unexpected %s indication "
"for component %d", pj_stun_get_method_name(msg->hdr.type),
sd->comp_id));
}
pj_log_pop_indent();
return PJ_SUCCESS;
}
PJ_DEF(pj_status_t) pj_ice_sess_send_data(pj_ice_sess *ice,
unsigned comp_id,
const void *data,
pj_size_t data_len)
{
pj_status_t status = PJ_SUCCESS;
pj_ice_sess_comp *comp;
pj_ice_sess_cand *cand;
pj_uint8_t transport_id;
pj_sockaddr addr;
PJ_ASSERT_RETURN(ice && comp_id, PJ_EINVAL);
/* It is possible that comp_cnt is less than comp_id, when remote
* doesn't support all the components that we have.
*/
if (comp_id > ice->comp_cnt) {
return PJNATH_EICEINCOMPID;
}
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
pj_grp_lock_release(ice->grp_lock);
return PJ_EINVALIDOP;
}
comp = find_comp(ice, comp_id);
if (comp == NULL) {
status = PJNATH_EICEINCOMPID;
pj_grp_lock_release(ice->grp_lock);
goto on_return;
}
if (comp->valid_check == NULL) {
status = PJNATH_EICEINPROGRESS;
pj_grp_lock_release(ice->grp_lock);
goto on_return;
}
cand = comp->valid_check->lcand;
transport_id = cand->transport_id;
pj_sockaddr_cp(&addr, &comp->valid_check->rcand->addr);
/* Release the mutex now to avoid deadlock (see ticket #1451). */
pj_grp_lock_release(ice->grp_lock);
PJ_RACE_ME(5);
status = (*ice->cb.on_tx_pkt)(ice, comp_id, transport_id,
data, data_len,
&addr,
pj_sockaddr_get_len(&addr));
on_return:
return status;
}
PJ_DEF(pj_status_t) pj_ice_sess_on_rx_pkt(pj_ice_sess *ice,
unsigned comp_id,
unsigned transport_id,
void *pkt,
pj_size_t pkt_size,
const pj_sockaddr_t *src_addr,
int src_addr_len)
{
pj_status_t status = PJ_SUCCESS;
pj_ice_sess_comp *comp;
pj_ice_msg_data *msg_data = NULL;
unsigned i;
PJ_ASSERT_RETURN(ice, PJ_EINVAL);
pj_grp_lock_acquire(ice->grp_lock);
if (ice->is_destroying) {
pj_grp_lock_release(ice->grp_lock);
return PJ_EINVALIDOP;
}
comp = find_comp(ice, comp_id);
if (comp == NULL) {
pj_grp_lock_release(ice->grp_lock);
return PJNATH_EICEINCOMPID;
}
/* Find transport */
for (i=0; i<PJ_ARRAY_SIZE(ice->tp_data); ++i) {
if (ice->tp_data[i].transport_id == transport_id) {
msg_data = &ice->tp_data[i];
break;
}
}
if (msg_data == NULL) {
pj_assert(!"Invalid transport ID");
pj_grp_lock_release(ice->grp_lock);
return PJ_EINVAL;
}
/* Don't check fingerprint. We only need to distinguish STUN and non-STUN
* packets. We don't need to verify the STUN packet too rigorously, that
* will be done by the user.
*/
status = pj_stun_msg_check((const pj_uint8_t*)pkt, pkt_size,
PJ_STUN_IS_DATAGRAM |
PJ_STUN_NO_FINGERPRINT_CHECK);
if (status == PJ_SUCCESS) {
status = pj_stun_session_on_rx_pkt(comp->stun_sess, pkt, pkt_size,
PJ_STUN_IS_DATAGRAM, msg_data,
NULL, src_addr, src_addr_len);
if (status != PJ_SUCCESS) {
pj_strerror(status, ice->tmp.errmsg, sizeof(ice->tmp.errmsg));
LOG4((ice->obj_name, "Error processing incoming message: %s",
ice->tmp.errmsg));
}
pj_grp_lock_release(ice->grp_lock);
} else {
/* Not a STUN packet. Call application's callback instead, but release
* the mutex now or otherwise we may get deadlock.
*/
pj_grp_lock_release(ice->grp_lock);
PJ_RACE_ME(5);
(*ice->cb.on_rx_data)(ice, comp_id, transport_id, pkt, pkt_size,
src_addr, src_addr_len);
status = PJ_SUCCESS;
}
return status;
}