/**
* Perform additional INF checks used at time of login.
*
* @return 0 if success, <0 if error, >0 if authentication needed.
*/
int hub_handle_info_login(struct hub_info* hub, struct hub_user* user, struct adc_message* cmd)
{
int code = 0;
INF_CHECK(hub_perform_login_checks, hub, user, cmd);
/* Private ID must never be broadcasted - drop it! */
adc_msg_remove_named_argument(cmd, ADC_INF_FLAG_PRIVATE_ID);
code = set_credentials(hub, user, cmd);
/* Note: this must be done *after* set_credentials. */
if (check_is_hub_full(hub, user))
{
return status_msg_hub_full;
}
if (check_registered_users_only(hub, user))
{
return status_msg_hub_registered_users_only;
}
INF_CHECK(check_limits, hub, user, cmd);
/* strip off stuff if low_bandwidth_mode is enabled */
hub_handle_info_low_bandwidth(hub, user, cmd);
/* Set initial user info */
user_set_info(user, cmd);
return code;
}
static void bad_credentials_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, FALSE);
nice_agent_set_remote_credentials (lagent, global_ls_id,
"wrong", "wrong");
nice_agent_set_remote_credentials (ragent, global_rs_id,
"wrong2", "wrong2");
nice_agent_gather_candidates (lagent, global_ls_id);
while (!got_stun_packet)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
while (!ragent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (ragent_candidate_gathering_done);
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
while (global_lagent_state != NICE_COMPONENT_STATE_FAILED)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
// Set the correct credentials and swap candidates
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
while (!data_received)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (data_received);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
// Wait for lagent to finish gathering candidates
while (!lagent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (lagent_candidate_gathering_done);
cleanup (lagent, ragent);
}
static void bad_candidate_test(NiceAgent *lagent,NiceAgent *ragent)
{
NiceCandidate *cand = NULL;
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, FALSE);
nice_agent_gather_candidates (lagent, global_ls_id);
while (!got_stun_packet)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
while (!ragent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (ragent_candidate_gathering_done);
add_bad_candidate (lagent, global_ls_id, cand);
// lagent will finish candidate gathering causing this mainloop to quit
while (!lagent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
// connchecks will fail causing this mainloop to quit
while (global_lagent_state != NICE_COMPONENT_STATE_FAILED)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_FAILED &&
!data_received);
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
while (!data_received)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (lagent_candidate_gathering_done);
g_assert (global_lagent_state >= NICE_COMPONENT_STATE_CONNECTED);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
static void bad_credentials_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, FALSE);
nice_agent_set_remote_credentials (lagent, global_ls_id,
"wrong", "wrong");
nice_agent_set_remote_credentials (ragent, global_rs_id,
"wrong2", "wrong2");
nice_agent_gather_candidates (lagent, global_ls_id);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
if (!ragent_candidate_gathering_done) {
g_main_loop_run (global_mainloop);
g_assert (ragent_candidate_gathering_done);
}
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_FAILED);
// Set the correct credentials and swap candidates
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
g_main_loop_run (global_mainloop);
g_assert (data_received);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
// Wait for lagent to finish gathering candidates
g_main_loop_run (global_mainloop);
g_assert (lagent_candidate_gathering_done);
cleanup (lagent, ragent);
}
static void bad_candidate_test(NiceAgent *lagent,NiceAgent *ragent)
{
NiceCandidate *cand = NULL;
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, FALSE);
nice_agent_gather_candidates (lagent, global_ls_id);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
if (!ragent_candidate_gathering_done) {
g_main_loop_run (global_mainloop);
g_assert (ragent_candidate_gathering_done);
}
add_bad_candidate (lagent, global_ls_id, cand);
// lagent will finish candidate gathering causing this mainloop to quit
g_main_loop_run (global_mainloop);
// connchecks will fail causing this mainloop to quit
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_FAILED &&
!data_received);
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
FALSE);
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
g_main_loop_run (global_mainloop);
g_assert (lagent_candidate_gathering_done);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
static void standard_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
got_stun_packet = FALSE;
init_test (lagent, ragent, FALSE);
nice_agent_gather_candidates (lagent, global_ls_id);
while (!got_stun_packet)
g_main_context_iteration (NULL, TRUE);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
while (!ragent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (ragent_candidate_gathering_done);
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
g_debug ("Setting local candidates of ragent as remote candidates of lagent");
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
TRUE);
while (!data_received)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (global_lagent_state >= NICE_COMPONENT_STATE_CONNECTED &&
data_received);
g_debug ("Setting local candidates of lagent as remote candidates of ragent");
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
while (!lagent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (lagent_candidate_gathering_done);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
nsapi_error_t PPPCellularInterface::connect(const char *sim_pin, const char *apn, const char *uname, const char *pwd)
{
if (!sim_pin) {
return NSAPI_ERROR_PARAMETER;
}
_pin = sim_pin;
if (apn) {
if (pwd && !uname) {
return NSAPI_ERROR_PARAMETER;
}
set_credentials(apn, uname, pwd);
}
return connect();
}
nsapi_error_t EasyCellularConnection::connect(const char *sim_pin, const char *apn, const char *uname, const char *pwd)
{
if (_is_connected) {
return NSAPI_ERROR_IS_CONNECTED;
}
set_credentials(apn, uname, pwd);
if (_credentials_err) {
return _credentials_err;
}
if (sim_pin) {
_cellularConnectionFSM->set_sim_pin(sim_pin);
}
return connect();
}
static void new_candidate_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, TRUE);
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
nice_agent_gather_candidates (lagent, global_ls_id);
while (!got_stun_packet)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
while (!ragent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
// Wait for data
while (!data_received)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (data_received);
// Data arrived, signal STUN thread to send STUN response
g_mutex_lock (stun_mutex_ptr);
send_stun = TRUE;
g_cond_signal (stun_signal_ptr);
g_mutex_unlock (stun_mutex_ptr);
// Wait for lagent to finish gathering candidates
while (!lagent_candidate_gathering_done ||
!lagent_candidate_gathering_done)
g_main_context_iteration (NULL, TRUE);
g_cancellable_reset (global_cancellable);
g_assert (lagent_candidate_gathering_done);
g_assert (ragent_candidate_gathering_done);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
static void standard_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, FALSE);
nice_agent_gather_candidates (lagent, global_ls_id);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
if (!ragent_candidate_gathering_done) {
g_main_loop_run (global_mainloop);
g_assert (ragent_candidate_gathering_done);
}
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
g_debug ("Setting local candidates of ragent as remote candidates of lagent");
swap_candidates (ragent, global_rs_id,
lagent, global_ls_id,
TRUE);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state >= NICE_COMPONENT_STATE_CONNECTED &&
data_received);
g_debug ("Setting local candidates of lagent as remote candidates of ragent");
swap_candidates (lagent, global_ls_id,
ragent, global_rs_id,
FALSE);
g_main_loop_run (global_mainloop);
g_assert (lagent_candidate_gathering_done);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
static void new_candidate_test(NiceAgent *lagent, NiceAgent *ragent)
{
g_debug ("test-dribblemode:%s", G_STRFUNC);
init_test (lagent, ragent, TRUE);
set_credentials (lagent, global_ls_id, ragent, global_rs_id);
nice_agent_gather_candidates (lagent, global_ls_id);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_GATHERING &&
!lagent_candidate_gathering_done);
nice_agent_gather_candidates (ragent, global_rs_id);
if (!ragent_candidate_gathering_done) {
g_main_loop_run (global_mainloop);
}
// Wait for data
g_main_loop_run (global_mainloop);
g_assert (data_received);
// Data arrived, signal STUN thread to send STUN response
g_mutex_lock (stun_mutex_ptr);
g_cond_signal (stun_signal_ptr);
g_mutex_unlock (stun_mutex_ptr);
// Wait for lagent to finish gathering candidates
g_main_loop_run (global_mainloop);
g_assert (lagent_candidate_gathering_done);
g_assert (ragent_candidate_gathering_done);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state >= NICE_COMPONENT_STATE_CONNECTED);
cleanup (lagent, ragent);
}
/*
* This function is invoked in a forked process to run a server.
* If the service is internal the appropriate function is invoked
* otherwise the server program is exec'ed.
* This function also logs the remote user id if appropriate
*/
void child_process( struct server *serp )
{
struct service *sp = SERVER_SERVICE( serp ) ;
connection_s *cp = SERVER_CONNECTION( serp ) ;
struct service_config *scp = SVC_CONF( sp ) ;
const char *func = "child_process" ;
signal_default_state();
if ((signals_pending[0] >= 0 && Sclose(signals_pending[0])) ||
(signals_pending[1] >= 0 && Sclose(signals_pending[1])))
{
msg(LOG_ERR, func, "Failed to close the signal pipe: %m");
_exit(1);
}
signals_pending[0] = -1;
signals_pending[1] = -1;
Sclose(0);
Sclose(1);
Sclose(2);
#ifdef DEBUG_SERVER
if ( debug.on )
{
msg( LOG_DEBUG, func, "Process %d is sleeping", getpid() ) ;
sleep( 10 ) ;
}
#endif
if ( ! SC_IS_INTERCEPTED( scp ) )
{
set_credentials( scp ) ;
if ( SC_SPECIFIED( scp, A_NICE ) )
(void) nice( SC_NICE( scp ) ) ;
}
if ( svc_child_access_control(sp, cp) != OK )
exit(0);
if ( SERVER_LOGUSER( serp ) )
{
unsigned timeout ;
idresult_e result ;
/*
* We use LOGUSER_SUCCESS_TIMEOUT unless the service requires
* identification, in which case we use an infinite timeout
*/
timeout = SC_MUST_IDENTIFY( scp ) ? 0 : LOGUSER_SUCCESS_TIMEOUT ;
result = log_remote_user( serp, timeout ) ;
if ( result != IDR_OK && SC_MUST_IDENTIFY( scp ) )
{
svc_logprint( sp, NOID_ENTRY, "%s %s",
conn_addrstr( SERVER_CONNECTION( serp ) ),
idresult_explain( result ) ) ;
_exit( 0 ) ;
}
}
#ifdef HAVE_SESSIONCREATE
if ( scp->sc_sessioncreate == YES )
{
if ( SessionCreate(0, sessionHasTTY|sessionIsRemote) != noErr )
svc_logprint( sp, "SessionCreate", "SessionCreate() failed!" );
}
#endif
/* this is where the server gets executed -bbraun */
if ( ! SC_IS_INTERNAL( scp ) )
{
if( scp->sc_redir_addr != NULL )
{
redir_handler( serp );
}
else
{
#if defined(HAVE_SETENV)
char buff[1024];
strx_sprint(buff, sizeof(buff)-1, "REMOTE_HOST=%s", conn_addrstr(cp));
if( env_addstr(SC_ENV(scp)->env_handle, buff) != ENV_OK ) {
msg( LOG_ERR, func, "Error adding REMOTE_HOST variable for %s: %m", SC_NAME(scp) );
_exit( 1 ) ;
}
#endif
exec_server( serp ) ;
}
}
else
{
char name[ 180 ] ;
/*
* We don't bother to disassociate from the controlling terminal
* (we have a controlling terminal only if debug.on is TRUE)
*
* Also, for interceptor processes, we give them the name:
* <program_name> <service-id> interceptor
*/
if ( SC_IS_INTERCEPTED( scp ) )
strx_print( INT_NULL, name, sizeof( name ) - 1,
"%s %s interceptor", program_name, SC_ID( scp ) ) ;
else
{
int namelen = sizeof( name ) - 1 ; /* leave space for the NUL */
char host[NI_MAXHOST];
size_t hostlen = NI_MAXHOST;
socklen_t addrlen = 0;
union xsockaddr *sinp = CONN_XADDRESS(SERVER_CONNECTION(serp));
int len;
if( sinp == NULL )
exit(0);
if( SC_IPV6(scp) ) addrlen = sizeof(struct sockaddr_in6);
else if( SC_IPV4(scp) ) addrlen = sizeof(struct sockaddr_in);
len = strx_nprint(name, namelen, "(%s service) %s", program_name,
SC_ID( scp ) ) ;
if( getnameinfo( SA(sinp), addrlen, host, hostlen, NULL, 0, 0) != 0 )
strcpy(host, "unknown");
if ( SC_IPV6(scp) && SC_ACCEPTS_CONNECTIONS( scp ) &&
!IN6_IS_ADDR_UNSPECIFIED(&sinp->sa_in6.sin6_addr) )
strx_print( INT_NULL, &name[ len ], namelen - len, " %s" , host ) ;
if ( SC_IPV4(scp) && SC_ACCEPTS_CONNECTIONS( scp ) )
strx_print( INT_NULL, &name[ len ], namelen - len, " %s", host ) ;
}
rename_process( name ) ;
SVC_INTERNAL( sp, serp ) ;
}
_exit( 0 ) ;
/* NOTREACHED */
}
static int run_full_test_wrong_password (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr)
{
guint ls_id, rs_id;
/* XXX: dear compiler, this is for you */
(void)baseaddr;
global_components_ready = 0;
global_components_ready_exit = 0;
global_components_failed = 0;
global_components_failed_exit = 2;
global_lagent_state[0] = global_lagent_state[1] =
global_ragent_state[0] = global_ragent_state[1]
= NICE_COMPONENT_STATE_LAST;
global_lagent_gathering_done =
global_ragent_gathering_done = FALSE;
global_lagent_cands =
global_ragent_cands = 0;
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
/* step: add one stream, with one component, to each agent */
ls_id = nice_agent_add_stream (lagent, 1);
rs_id = nice_agent_add_stream (ragent, 1);
g_assert (ls_id > 0);
g_assert (rs_id > 0);
#if USE_TURN
nice_agent_set_relay_info(lagent, ls_id, 1,
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
nice_agent_set_relay_info(ragent, rs_id, 1,
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
#endif
nice_agent_gather_candidates (lagent, ls_id);
nice_agent_gather_candidates (ragent, rs_id);
/* step: attach to mainloop (needed to register the fds) */
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
/* step: run mainloop until local candidates are ready
* (see timer_cb() above) */
if (global_lagent_gathering_done != TRUE ||
global_ragent_gathering_done != TRUE) {
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
g_main_loop_run (global_mainloop);
g_assert (global_lagent_gathering_done == TRUE);
g_assert (global_ragent_gathering_done == TRUE);
}
g_debug ("test-fullmode: Got local candidates...");
set_credentials (lagent, ls_id, ragent, rs_id);
nice_agent_set_remote_credentials (ragent, rs_id, "wrong", "password");
nice_agent_set_remote_credentials (lagent, ls_id, "wrong2", "password2");
/* step: pass the remote candidates to agents */
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTP, USE_TURN);
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTP, USE_TURN);
g_debug ("test-fullmode: Set properties, next running mainloop until connectivity checks succeed...");
/* step: run the mainloop until connectivity checks succeed
* (see timer_cb() above) */
g_main_loop_run (global_mainloop);
/* note: verify that correct number of local candidates were reported */
g_assert (global_lagent_cands == 0);
g_assert (global_ragent_cands == 0);
g_debug ("test-fullmode: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
return 0;
}
/*
* Simulate the case where answer to the offer is delayed and
* some STUN connectivity checks reach the offering party
* before it gets the remote SDP information.
*/
static int run_full_test_delayed_answer (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, guint ready, guint failed)
{
guint ls_id, rs_id;
gint ret;
/* XXX: dear compiler, this is for you */
(void)baseaddr;
/* step: initialize variables modified by the callbacks */
global_components_ready = 0;
global_components_ready_exit = ready;
global_components_failed = 0;
global_components_failed_exit = failed;
global_lagent_gathering_done = FALSE;
global_ragent_gathering_done = FALSE;
global_lagent_ibr_received =
global_ragent_ibr_received = FALSE;
global_exit_when_ibr_received = 1;
global_lagent_cands =
global_ragent_cands = 0;
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
/* step: add one stream, with RTP+RTCP components, to each agent */
ls_id = nice_agent_add_stream (lagent, 2);
rs_id = nice_agent_add_stream (ragent, 2);
g_assert (ls_id > 0);
g_assert (rs_id > 0);
/* We don't try this with TURN because as long as both agents don't
have the remote candidates, they won't be able to create the
permission on the TURN server, so the connchecks will never go through */
nice_agent_gather_candidates (lagent, ls_id);
nice_agent_gather_candidates (ragent, rs_id);
/* step: attach to mainloop (needed to register the fds) */
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
/* step: run mainloop until local candidates are ready
* (see timer_cb() above) */
if (global_lagent_gathering_done != TRUE ||
global_ragent_gathering_done != TRUE) {
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
g_main_loop_run (global_mainloop);
g_assert (global_lagent_gathering_done == TRUE);
g_assert (global_ragent_gathering_done == TRUE);
}
set_credentials (lagent, ls_id, ragent, rs_id);
/* step: set remote candidates for agent R (answering party) */
/* We have to disable TURN for this test because with the delayed answer,
we can't create turn permissions, so we won't receive any connchecks */
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTP, FALSE);
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, FALSE);
g_debug ("test-fullmode: Set properties, next running mainloop until first check is received...");
/* step: run the mainloop until first connectivity check receveid */
g_main_loop_run (global_mainloop);
global_exit_when_ibr_received = 0;
/* note: verify that STUN binding requests were sent */
g_assert (global_lagent_ibr_received == TRUE);
g_debug ("test-fullmode: Delayed answer received, continuing processing..");
/* step: pass remove candidates to agent L (offering party) */
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTP, FALSE);
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, FALSE);
g_debug ("test-fullmode: Running mainloop until connectivity checks succeeed.");
g_main_loop_run (global_mainloop);
g_assert (global_ragent_ibr_received == TRUE);
g_assert (global_components_failed == 0);
/* note: test payload send and receive */
global_ragent_read = 0;
ret = nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678");
{
gboolean reliable = FALSE;
g_object_get (G_OBJECT (lagent), "reliable", &reliable, NULL);
if (reliable) {
gulong signal_handler;
signal_handler = g_signal_connect (G_OBJECT (lagent),
"reliable-transport-writable", G_CALLBACK (cb_writable), NULL);
g_main_loop_run (global_mainloop);
g_signal_handler_disconnect(G_OBJECT (lagent), signal_handler);
ret = nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678");
}
}
global_ragent_read = 0;
g_assert (ret == 16);
g_main_loop_run (global_mainloop);
g_assert (global_ragent_read == 16);
g_debug ("test-fullmode: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
return 0;
}
static int run_full_test (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, guint ready, guint failed)
{
guint ls_id, rs_id;
gint ret;
/* XXX: dear compiler, this is for you */
(void)baseaddr;
/* step: initialize variables modified by the callbacks */
global_components_ready = 0;
global_components_ready_exit = ready;
global_components_failed = 0;
global_components_failed_exit = failed;
global_lagent_gathering_done = FALSE;
global_ragent_gathering_done = FALSE;
global_lagent_ibr_received =
global_ragent_ibr_received = FALSE;
global_lagent_cands =
global_ragent_cands = 0;
global_ready_reached = FALSE;
g_object_set (G_OBJECT (lagent), "controlling-mode", TRUE, NULL);
g_object_set (G_OBJECT (ragent), "controlling-mode", FALSE, NULL);
/* step: add one stream, with RTP+RTCP components, to each agent */
ls_id = nice_agent_add_stream (lagent, 2);
rs_id = nice_agent_add_stream (ragent, 2);
g_assert (ls_id > 0);
g_assert (rs_id > 0);
/* Gather candidates */
g_assert (nice_agent_gather_candidates (lagent, ls_id) == TRUE);
g_assert (nice_agent_gather_candidates (ragent, rs_id) == TRUE);
{
GSList *cands = NULL, *i;
NiceCandidate *cand = NULL;
cands = nice_agent_get_local_candidates (lagent, ls_id, 1);
g_assert (g_slist_length (cands) == 2);
cand = cands->data;
g_assert (cand->type == NICE_CANDIDATE_TYPE_HOST);
g_assert (cand->transport == NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE ||
cand->transport == NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE);
cand = cands->next->data;
g_assert (cand->type == NICE_CANDIDATE_TYPE_HOST);
g_assert (cand->transport == NICE_CANDIDATE_TRANSPORT_TCP_ACTIVE ||
cand->transport == NICE_CANDIDATE_TRANSPORT_TCP_PASSIVE);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
}
/* step: attach to mainloop (needed to register the fds) */
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
/* step: run mainloop until local candidates are ready
* (see timer_cb() above) */
if (global_lagent_gathering_done != TRUE ||
global_ragent_gathering_done != TRUE) {
g_debug ("test-icetcp: Added streams, running mainloop until 'candidate-gathering-done'...");
g_main_loop_run (global_mainloop);
g_assert (global_lagent_gathering_done == TRUE);
g_assert (global_ragent_gathering_done == TRUE);
}
set_credentials (lagent, ls_id, ragent, rs_id);
/* step: pass the remote candidates to agents */
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTCP);
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTCP);
g_debug ("test-icetcp: Set properties, next running mainloop until connectivity checks succeed...");
/* step: run the mainloop until connectivity checks succeed
* (see timer_cb() above) */
g_main_loop_run (global_mainloop);
/* note: verify that STUN binding requests were sent */
g_assert (global_lagent_ibr_received == TRUE);
g_assert (global_ragent_ibr_received == TRUE);
/* note: test payload send and receive */
global_ragent_read = 0;
ret = nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678");
if (ret == -1)
{
gboolean reliable = FALSE;
g_object_get (G_OBJECT (lagent), "reliable", &reliable, NULL);
g_debug ("Sending data returned -1 in %s mode", reliable?"Reliable":"Non-reliable");
if (reliable) {
gulong signal_handler;
signal_handler = g_signal_connect (G_OBJECT (lagent),
"reliable-transport-writable", G_CALLBACK (cb_writable), NULL);
g_debug ("Running mainloop until transport is writable");
g_main_loop_run (global_mainloop);
g_signal_handler_disconnect(G_OBJECT (lagent), signal_handler);
ret = nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678");
}
}
g_debug ("Sent %d bytes", ret);
g_assert (ret == 16);
g_main_loop_run (global_mainloop);
g_assert (global_ragent_read == 16);
g_debug ("test-icetcp: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
return 0;
}
static int run_full_test_control_conflict (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, gboolean role)
{
guint ls_id, rs_id;
/* XXX: dear compiler, this is for you */
(void)baseaddr;
global_components_ready = 0;
global_components_ready_exit = 2;
global_components_failed = 0;
global_components_failed_exit = 0;
global_lagent_gathering_done =
global_ragent_gathering_done = FALSE;
global_lagent_cands =
global_ragent_cands = 0;
global_lagent_ibr_received =
global_ragent_ibr_received = FALSE;
g_object_set (G_OBJECT (lagent), "controlling-mode", role, NULL);
g_object_set (G_OBJECT (ragent), "controlling-mode", role, NULL);
/* step: add one stream, with one component, to each agent */
ls_id = nice_agent_add_stream (lagent, 1);
rs_id = nice_agent_add_stream (ragent, 1);
g_assert (ls_id > 0);
g_assert (rs_id > 0);
#if USE_TURN
nice_agent_set_relay_info(lagent, ls_id, 1,
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
nice_agent_set_relay_info(ragent, rs_id, 1,
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
#endif
nice_agent_gather_candidates (lagent, ls_id);
nice_agent_gather_candidates (ragent, rs_id);
/* step: attach to mainloop (needed to register the fds) */
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (1));
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv,
GUINT_TO_POINTER (2));
/* step: run mainloop until local candidates are ready
* (see timer_cb() above) */
if (global_lagent_gathering_done != TRUE ||
global_ragent_gathering_done != TRUE) {
g_debug ("test-fullmode: Added streams, running mainloop until 'candidate-gathering-done'...");
g_main_loop_run (global_mainloop);
g_assert (global_lagent_gathering_done == TRUE);
g_assert (global_ragent_gathering_done == TRUE);
}
g_debug ("test-fullmode: Got local candidates...");
set_credentials (lagent, ls_id, ragent, rs_id);
/* step: pass the remote candidates to agents */
set_candidates (ragent, rs_id, lagent, ls_id, NICE_COMPONENT_TYPE_RTP, USE_TURN);
set_candidates (lagent, ls_id, ragent, rs_id, NICE_COMPONENT_TYPE_RTP, USE_TURN);
g_debug ("test-fullmode: Set properties, next running mainloop until connectivity checks succeed...");
/* step: run the mainloop until connectivity checks succeed
* (see timer_cb() above) */
g_main_loop_run (global_mainloop);
/* When using TURN, we get peer reflexive candidates for the host cands
that we removed so we can get another new_selected_pair signal later
depending on timing/racing, we could double (or not) the amount we expected
*/
#if !(USE_TURN)
/* note: verify that correct number of local candidates were reported */
g_assert (global_lagent_cands == 1);
g_assert (global_ragent_cands == 1);
#endif
g_debug ("test-fullmode: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
return 0;
}
void Gobby::Server::open(unsigned int port,
InfXmppConnectionSecurityPolicy security_policy,
InfCertificateCredentials* creds,
InfSaslContext* context,
const char* sasl_mechanisms)
{
// If we can open one of tcp4 or tcp6 that's a success.
InfdTcpServer* tcp4;
InfdTcpServer* tcp6;
// If the server is already open and we do not need to change the
// port, then just change the credentials and SASL context without
// doing anything else.
if(is_open() && get_port() == port)
{
set_credentials(security_policy, creds);
set_sasl_context(context, sasl_mechanisms);
return;
}
static const guint8 ANY6_ADDR[16] =
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
InfIpAddress* any6 = inf_ip_address_new_raw6(ANY6_ADDR);
tcp4 = INFD_TCP_SERVER(g_object_new(
INFD_TYPE_TCP_SERVER,
"io", m_io, "local-address", NULL,
"local-port", port,
NULL));
tcp6 = INFD_TCP_SERVER(g_object_new(
INFD_TYPE_TCP_SERVER,
"io", m_io, "local-address", any6,
"local-port", port,
NULL));
inf_ip_address_free(any6);
if(!infd_tcp_server_open(tcp6, NULL))
{
g_object_unref(tcp6);
tcp6 = NULL;
GError* error = NULL;
if(!infd_tcp_server_open(tcp4, &error))
{
g_object_unref(tcp4);
const std::string message = error->message;
g_error_free(error);
throw std::runtime_error(message);
}
}
else
{
if(!infd_tcp_server_open(tcp4, NULL))
{
g_object_unref(tcp4);
tcp4 = NULL;
}
}
// We have the new server open, from this point on there is nothing
// that can go wrong anymore. Therefore, close the old server and
// take over the new one.
if(is_open()) close();
InfXmppConnectionSecurityPolicy policy =
INF_XMPP_CONNECTION_SECURITY_ONLY_UNSECURED;
if(creds != NULL) policy = security_policy;
if(tcp4)
{
m_xmpp4 = infd_xmpp_server_new(
tcp4, security_policy, creds,
context, sasl_mechanisms);
g_object_unref(tcp4);
}
if(tcp6)
{
m_xmpp6 = infd_xmpp_server_new(
tcp6, security_policy, creds,
context, sasl_mechanisms);
g_object_unref(tcp6);
}
if(m_pool)
{
if(m_xmpp4 != NULL)
{
infd_server_pool_add_server(
m_pool, INFD_XML_SERVER(m_xmpp4));
infd_server_pool_add_local_publisher(
m_pool, m_xmpp4, m_publisher);
}
if(m_xmpp6 != NULL)
{
infd_server_pool_add_server(
m_pool, INFD_XML_SERVER(m_xmpp6));
infd_server_pool_add_local_publisher(
m_pool, m_xmpp6, m_publisher);
}
}
}
