static void set_credentials (NiceAgent *lagent, guint lstream,
NiceAgent *ragent, guint rstream)
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, lstream, &ufrag, &password);
nice_agent_set_remote_credentials (ragent, rstream, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rstream, &ufrag, &password);
nice_agent_set_remote_credentials (lagent, lstream, ufrag, password);
g_free (ufrag);
g_free (password);
}
static void
kms_ice_nice_agent_get_local_credentials (KmsIceBaseAgent * self,
const char *stream_id, gchar ** ufrag, gchar ** pwd)
{
KmsIceNiceAgent *nice_agent = KMS_ICE_NICE_AGENT (self);
guint id = atoi (stream_id);
nice_agent_get_local_credentials (nice_agent->priv->agent, id, ufrag, pwd);
}
int _video_send_print_local_data(NiceAgent *agent, guint stream_id, guint component_id)
{
int result = EXIT_FAILURE;
gchar *local_ufrag = NULL;
gchar *local_password = NULL;
gchar ipaddr[INET6_ADDRSTRLEN];
GSList *cands = NULL, *item;
if (!nice_agent_get_local_credentials(agent, stream_id,
&local_ufrag, &local_password))
goto end;
cands = nice_agent_get_local_candidates(agent, stream_id, component_id);
if (cands == NULL)
goto end;
mInfo_SendVideo = (gchar*)malloc(181*sizeof(gchar));
//printf("%s %s", local_ufrag, local_password);
sprintf(mInfo_SendVideo, "%s %s", local_ufrag, local_password);
for (item = cands; item; item = item->next) {
NiceCandidate *c = (NiceCandidate *)item->data;
nice_address_to_string(&c->addr, ipaddr);
// (foundation),(prio),(addr),(port),(type)
/*printf(" %s,%u,%s,%u,%s",
c->foundation,
c->priority,
ipaddr,
nice_address_get_port(&c->addr),
candidate_type_name[c->type]);*/
sprintf(mInfo_SendVideo + strlen(mInfo_SendVideo), " %s,%u,%s,%u,%s",
c->foundation,
c->priority,
ipaddr,
nice_address_get_port(&c->addr),
candidate_type_name[c->type]);
}
printf("\n");
//printf("\nmInfo_SendVideo:\n");
//printf("%s\n", mInfo_SendVideo);
result = EXIT_SUCCESS;
end:
if (local_ufrag)
g_free(local_ufrag);
if (local_password)
g_free(local_password);
if (cands)
g_slist_free_full(cands, (GDestroyNotify)&nice_candidate_free);
return result;
}
void
local_credentials_to_string(NiceAgent *agent, guint stream_id, guint component_id, gchar** out) {
gchar buf[1024];
gchar tmp[1024];
gchar *local_ufrag = NULL;
gchar *local_password = NULL;
gchar ipaddr[INET6_ADDRSTRLEN];
GSList *cands = NULL, *item;
if(!nice_agent_get_local_credentials(agent, stream_id,
&local_ufrag, &local_password)) {
g_critical("Error reading local credentials!");
g_object_unref(agent);
exit(1);
}
cands = nice_agent_get_local_candidates(agent, stream_id, component_id);
if(cands == NULL) {
g_critical("Error reading local candidates!");
g_object_unref(agent);
exit(1);
}
sprintf(buf, "%s %s", local_ufrag, local_password);
for (item = cands; item; item = item->next) {
NiceCandidate *c = (NiceCandidate *)item->data;
nice_address_to_string(&c->addr, ipaddr);
// (foundation),(prio),(addr),(port),(type)
sprintf(tmp, " %s,%u,%s,%u,%s",
c->foundation,
c->priority,
ipaddr,
nice_address_get_port(&c->addr),
candidate_type_name[c->type]);
strcat(buf, tmp);
}
sprintf(tmp, "\n");
strcat(buf, tmp);
g_free(local_ufrag);
g_free(local_password);
g_slist_free_full(cands, (GDestroyNotify)&nice_candidate_free);
*out = g_malloc(strlen(buf)+1);
strcpy(*out, buf);
}
static void add_bad_candidate (NiceAgent *agent, guint stream_id, NiceCandidate *cand)
{
NiceAddress bad_addr;
GSList *cand_list = NULL;
g_assert (nice_address_set_from_string (&bad_addr, "172.1.0.1"));
cand = nice_candidate_new (NICE_CANDIDATE_TYPE_HOST);
cand->stream_id = stream_id;
cand->component_id = NICE_COMPONENT_TYPE_RTP;
cand->addr = bad_addr;
nice_agent_get_local_credentials (agent, stream_id,
&cand->username, &cand->password);
cand_list = g_slist_prepend (cand_list, cand);
g_debug ("Adding buggy candidate to the agent %p", agent);
g_assert (nice_agent_set_remote_candidates (agent, stream_id,
NICE_COMPONENT_TYPE_RTP,
cand_list));
g_slist_free_full (cand_list, (GDestroyNotify) nice_candidate_free);
}
void NiceConnection::gatheringDone(uint stream_id) {
int currentCompId = 1;
lcands = nice_agent_get_local_candidates(agent_, stream_id, currentCompId++);
NiceCandidate *cand;
GSList* iterator;
gchar *ufrag = NULL, *upass = NULL;
nice_agent_get_local_credentials(agent_, stream_id, &ufrag, &upass);
//////False candidate for testing when there is no network (like in the train) :)
/*
NiceCandidate* thecandidate = nice_candidate_new(NICE_CANDIDATE_TYPE_HOST);
NiceAddress* naddr = nice_address_new();
nice_address_set_from_string(naddr, "127.0.0.1");
nice_address_set_port(naddr, 50000);
thecandidate->addr = *naddr;
char* uname = (char*) malloc(50);
char* pass = (char*) malloc(50);
sprintf(thecandidate->foundation, "%s", "1");
sprintf(uname, "%s", "Pedro");
sprintf(pass, "%s", "oooo");
thecandidate->username = uname;
thecandidate->password = pass;
thecandidate->stream_id = (guint) 1;
thecandidate->component_id = 1;
thecandidate->priority = 1000;
thecandidate->transport = NICE_CANDIDATE_TRANSPORT_UDP;
lcands = g_slist_append(lcands, thecandidate);
*/
// ELOG_DEBUG("gathering done %u",stream_id);
//ELOG_DEBUG("Candidates---------------------------------------------------->");
while (lcands != NULL) {
for (iterator = lcands; iterator; iterator = iterator->next) {
char address[40], baseAddress[40];
cand = (NiceCandidate*) iterator->data;
nice_address_to_string(&cand->addr, address);
nice_address_to_string(&cand->base_addr, baseAddress);
if (strstr(address, ":") != NULL) {
ELOG_DEBUG("Ignoring IPV6 candidate %s", address);
continue;
}
// ELOG_DEBUG("foundation %s", cand->foundation);
// ELOG_DEBUG("compid %u", cand->component_id);
// ELOG_DEBUG("stream_id %u", cand->stream_id);
// ELOG_DEBUG("priority %u", cand->priority);
// ELOG_DEBUG("username %s", cand->username);
// ELOG_DEBUG("password %s", cand->password);
CandidateInfo cand_info;
cand_info.componentId = cand->component_id;
cand_info.foundation = cand->foundation;
cand_info.priority = cand->priority;
cand_info.hostAddress = std::string(address);
cand_info.hostPort = nice_address_get_port(&cand->addr);
cand_info.mediaType = mediaType;
/*
* NICE_CANDIDATE_TYPE_HOST,
* NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE,
* NICE_CANDIDATE_TYPE_PEER_REFLEXIVE,
* NICE_CANDIDATE_TYPE_RELAYED,
*/
switch (cand->type) {
case NICE_CANDIDATE_TYPE_HOST:
cand_info.hostType = HOST;
break;
case NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE:
cand_info.hostType = SRLFX;
cand_info.baseAddress = std::string(baseAddress);
cand_info.basePort = nice_address_get_port(&cand->base_addr);
break;
case NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:
cand_info.hostType = PRFLX;
break;
case NICE_CANDIDATE_TYPE_RELAYED:
ELOG_DEBUG("WARNING TURN NOT IMPLEMENTED YET");
cand_info.hostType = RELAY;
break;
default:
break;
}
cand_info.netProtocol = "udp";
cand_info.transProtocol = std::string(*transportName);
cand_info.username = std::string(ufrag);
cand_info.password = std::string(upass);
/*
if (cand->username)
cand_info.username = std::string(cand->username);
else
cand_info.username = std::string("(null)");
if (cand->password)
cand_info.password = std::string(cand->password);
else
cand_info.password = std::string("(null)");
*/
localCandidates->push_back(cand_info);
}
lcands = nice_agent_get_local_candidates(agent_, stream_id,
currentCompId++);
}
ELOG_INFO("candidate_gathering done with %d candidates", localCandidates->size());
if (localCandidates->size()==0) {
ELOG_WARN("No local candidates found, check your network connection");
exit(0);
}
updateIceState(NICE_CANDIDATES_GATHERED);
}
int main (void)
{
NiceAgent *lagent, *ragent; /* agent's L and R */
NiceAddress baseaddr;
guint timer_id;
GSList *cands, *i;
guint ls_id, rs_id;
g_type_init ();
g_thread_init (NULL);
global_mainloop = g_main_loop_new (NULL, FALSE);
/* step: create the agents L and R */
lagent = nice_agent_new (g_main_loop_get_context (global_mainloop),
NICE_COMPATIBILITY_GOOGLE);
ragent = nice_agent_new (g_main_loop_get_context (global_mainloop),
NICE_COMPATIBILITY_GOOGLE);
if (!nice_address_set_from_string (&baseaddr, "127.0.0.1"))
g_assert_not_reached ();
nice_agent_add_local_address (lagent, &baseaddr);
nice_agent_add_local_address (ragent, &baseaddr);
/* step: add a timer to catch state changes triggered by signals */
timer_id = g_timeout_add (30000, timer_cb, NULL);
g_signal_connect (G_OBJECT (lagent), "candidate-gathering-done",
G_CALLBACK (cb_candidate_gathering_done), GUINT_TO_POINTER(1));
g_signal_connect (G_OBJECT (ragent), "candidate-gathering-done",
G_CALLBACK (cb_candidate_gathering_done), GUINT_TO_POINTER (2));
g_signal_connect (G_OBJECT (lagent), "component-state-changed",
G_CALLBACK (cb_component_state_changed), GUINT_TO_POINTER (1));
g_signal_connect (G_OBJECT (ragent), "component-state-changed",
G_CALLBACK (cb_component_state_changed), GUINT_TO_POINTER (2));
g_signal_connect (G_OBJECT (lagent), "new-selected-pair",
G_CALLBACK (cb_new_selected_pair), GUINT_TO_POINTER(1));
g_signal_connect (G_OBJECT (ragent), "new-selected-pair",
G_CALLBACK (cb_new_selected_pair), GUINT_TO_POINTER (2));
g_signal_connect (G_OBJECT (lagent), "new-candidate",
G_CALLBACK (cb_new_candidate), GUINT_TO_POINTER (1));
g_signal_connect (G_OBJECT (ragent), "new-candidate",
G_CALLBACK (cb_new_candidate), GUINT_TO_POINTER (2));
g_signal_connect (G_OBJECT (lagent), "initial-binding-request-received",
G_CALLBACK (cb_initial_binding_request_received),
GUINT_TO_POINTER (1));
g_signal_connect (G_OBJECT (ragent), "initial-binding-request-received",
G_CALLBACK (cb_initial_binding_request_received),
GUINT_TO_POINTER (2));
/* step: run test */
g_debug ("test-dribble: running test");
/* step: initialize variables modified by the callbacks */
global_components_ready = 0;
global_components_ready_exit = 2;
global_components_failed = 0;
global_components_failed_exit = 0;
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;
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, 1);
rs_id = nice_agent_add_stream (ragent, 1);
g_assert (ls_id > 0);
g_assert (rs_id > 0);
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-dribble: 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);
}
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
cands = nice_agent_get_local_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
cands = nice_agent_get_local_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
g_debug ("test-dribble: 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);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state == NICE_COMPONENT_STATE_READY);
/* note: verify that correct number of local candidates were reported */
g_assert (global_lagent_cands == 1);
g_assert (global_ragent_cands == 1);
g_debug ("test-dribble: agents are ready.. now adding new buggy candidate");
g_timeout_add (500, quit_loop_cb, NULL);
g_main_loop_run (global_mainloop);
global_components_ready--;
cands = nice_agent_get_local_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
nice_address_set_port(&((NiceCandidate *) cands->data)->addr, 80);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_CONNECTED);
g_main_loop_run (global_mainloop);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
/*
g_debug ("test-dribble: buggy candidate worked, testing lower priority cand");
cands = nice_agent_get_local_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
nice_address_set_port(&((NiceCandidate *) cands->data)->addr, 80);
((NiceCandidate *) cands->data)->priority -= 100;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);*/
/* note: test payload send and receive */
global_ragent_read = 0;
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 16);
g_main_loop_run (global_mainloop);
g_assert (global_ragent_read == 16);
g_debug ("test-dribble: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
priv_print_global_status ();
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state == NICE_COMPONENT_STATE_READY);
/* note: verify that correct number of local candidates were reported */
g_assert (global_lagent_cands == 1);
g_assert (global_ragent_cands == 1);
g_object_unref (lagent);
g_object_unref (ragent);
g_main_loop_unref (global_mainloop);
global_mainloop = NULL;
g_source_remove (timer_id);
return 0;
}
static int run_restart_test (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr)
{
NiceAddress laddr, raddr, laddr_rtcp, raddr_rtcp;
NiceCandidate cdes;
GSList *cands;
guint ls_id, rs_id;
guint64 tie_breaker;
/* XXX: dear compiler, these are for you: */
(void)baseaddr;
memset (&cdes, 0, sizeof(NiceCandidate));
cdes.priority = 10000;
strcpy (cdes.foundation, "1");
cdes.type = NICE_CANDIDATE_TYPE_HOST;
cdes.transport = NICE_CANDIDATE_TRANSPORT_UDP;
/* step: initialize variables modified by the callbacks */
global_components_ready = 0;
global_components_ready_exit = 4;
global_components_failed = 0;
global_components_failed_exit = 4;
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_ragent_read_exit = -1;
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);
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, (gpointer)1);
nice_agent_attach_recv (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv, (gpointer)1);
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTP,
g_main_loop_get_context (global_mainloop), cb_nice_recv, (gpointer)2);
nice_agent_attach_recv (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP,
g_main_loop_get_context (global_mainloop), cb_nice_recv, (gpointer)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-restart: 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);
}
/* step: find out the local candidates of each agent */
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, &raddr);
g_debug ("test-restart: local RTP port R %u",
nice_address_get_port (&raddr));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, &laddr);
g_debug ("test-restart: local RTP port L %u",
nice_address_get_port (&laddr));
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, &raddr_rtcp);
g_debug ("test-restart: local RTCP port R %u",
nice_address_get_port (&raddr_rtcp));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, &laddr_rtcp);
g_debug ("test-restart: local RTCP port L %u",
nice_address_get_port (&laddr_rtcp));
/* step: pass the remote candidates to agents */
cands = g_slist_append (NULL, &cdes);
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
cdes.component_id = NICE_COMPONENT_TYPE_RTP;
cdes.addr = raddr;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.addr = laddr;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
cdes.addr = raddr_rtcp;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
cdes.addr = laddr_rtcp;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
g_debug ("test-restart: 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: verify that correct number of local candidates were reported */
g_assert (global_lagent_cands == 2);
g_assert (global_ragent_cands == 2);
/* note: verify that agents are in correct state */
g_assert (global_lagent_state == NICE_COMPONENT_STATE_READY);
g_assert (global_ragent_state == NICE_COMPONENT_STATE_READY);
/* step: next send a packet (should work during restart) and
* then request an ICE restart by resetting the remote
* candidates for agent R */
g_debug ("-------------------------------------------\n"
"test-restart: Requesting a RESTART...");
/* step: send a new test packet from L ot R */
global_ragent_read = 0;
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 16);
/* step: restart agents, exchange updated credentials */
tie_breaker = ragent->tie_breaker;
nice_agent_restart (ragent);
g_assert (tie_breaker != ragent->tie_breaker);
nice_agent_restart (lagent);
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
/* send another packet after restart */
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 16);
/* step: reset state variables */
global_lagent_ibr_received = FALSE;
global_ragent_ibr_received = FALSE;
global_components_ready = 0;
/* step: exchange remote candidates */
cdes.component_id = NICE_COMPONENT_TYPE_RTP;
cdes.addr = raddr;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.addr = laddr;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
cdes.addr = raddr_rtcp;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
cdes.addr = laddr_rtcp;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
g_main_loop_run (global_mainloop);
/* note: verify that payload was succesfully received */
g_assert (global_ragent_read == 32);
/* note: verify binding requests were resent after restart */
g_assert (global_lagent_ibr_received == TRUE);
g_assert (global_ragent_ibr_received == TRUE);
g_debug ("test-restart: Ran mainloop, removing streams...");
/* step: clean up resources and exit */
g_slist_free (cands);
nice_agent_remove_stream (lagent, ls_id);
nice_agent_remove_stream (ragent, rs_id);
return 0;
}
void NiceConnection::gatheringDone(uint stream_id) {
if (this->checkIceState() >= NICE_FINISHED) {
ELOG_DEBUG("gathering Done after FINISHED");
nice_agent_remove_stream (agent_,1);
return;
}
ELOG_DEBUG("Gathering Done %p", this);
int currentCompId = 1;
GSList* lcands = nice_agent_get_local_candidates(agent_, stream_id, currentCompId++);
gchar *ufrag = NULL, *upass = NULL;
nice_agent_get_local_credentials(agent_, stream_id, &ufrag, &upass);
while (lcands != NULL) {
for (GSList* iterator = lcands; iterator; iterator = iterator->next) {
char address[NICE_ADDRESS_STRING_LEN], baseAddress[NICE_ADDRESS_STRING_LEN];
NiceCandidate *cand = (NiceCandidate*) iterator->data;
nice_address_to_string(&cand->addr, address);
nice_address_to_string(&cand->base_addr, baseAddress);
if (strstr(address, ":") != NULL) {
ELOG_DEBUG("Ignoring IPV6 candidate %s %p", address, this);
continue;
}
CandidateInfo cand_info;
cand_info.componentId = cand->component_id;
cand_info.foundation = cand->foundation;
cand_info.priority = cand->priority;
cand_info.hostAddress = std::string(address);
cand_info.hostPort = nice_address_get_port(&cand->addr);
cand_info.mediaType = mediaType;
/*
* NICE_CANDIDATE_TYPE_HOST,
* NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE,
* NICE_CANDIDATE_TYPE_PEER_REFLEXIVE,
* NICE_CANDIDATE_TYPE_RELAYED,
*/
switch (cand->type) {
case NICE_CANDIDATE_TYPE_HOST:
cand_info.hostType = HOST;
break;
case NICE_CANDIDATE_TYPE_SERVER_REFLEXIVE:
cand_info.hostType = SRFLX;
cand_info.rAddress = std::string(baseAddress);
cand_info.rPort = nice_address_get_port(&cand->base_addr);
break;
case NICE_CANDIDATE_TYPE_PEER_REFLEXIVE:
cand_info.hostType = PRFLX;
break;
case NICE_CANDIDATE_TYPE_RELAYED:
char turnAddres[NICE_ADDRESS_STRING_LEN];
ELOG_DEBUG("TURN LOCAL CANDIDATE");
nice_address_to_string(&cand->turn->server,turnAddres);
ELOG_DEBUG("address %s", address);
ELOG_DEBUG("baseAddress %s", baseAddress);
ELOG_DEBUG("stream_id %u", cand->stream_id);
ELOG_DEBUG("priority %u", cand->priority);
ELOG_DEBUG("TURN ADDRESS %s", turnAddres);
cand_info.hostType = RELAY;
cand_info.rAddress = std::string(baseAddress);
cand_info.rPort = nice_address_get_port(&cand->base_addr);
break;
default:
break;
}
cand_info.netProtocol = "udp";
cand_info.transProtocol = std::string(*transportName.get());
cand_info.username = std::string(ufrag);
cand_info.password = std::string(upass);
localCandidates->push_back(cand_info);
}
// for nice_agent_get_local_candidates, the caller owns the returned GSList as well as the candidates contained within it.
// let's free everything in the list, as well as the list.
g_slist_free_full(lcands, (GDestroyNotify)&nice_candidate_free);
lcands = nice_agent_get_local_candidates(agent_, stream_id, currentCompId++);
}
// According to libnice, this is how these must be free'd
g_free(ufrag);
g_free(upass);
ELOG_INFO("candidate_gathering done with %lu candidates %p", localCandidates->size(), this);
if (localCandidates->size()==0){
ELOG_WARN("No local candidates found, check your network connection");
exit(0);
}
updateIceState(NICE_CANDIDATES_GATHERED);
}
char *janus_sdp_merge(janus_ice_handle *handle, const char *origsdp) {
if(handle == NULL || origsdp == NULL)
return NULL;
sdp_session_t *anon = NULL;
sdp_parser_t *parser = sdp_parse(home, origsdp, strlen(origsdp), 0);
if(!(anon = sdp_session(parser))) {
JANUS_LOG(LOG_ERR, "[%"SCNu64"] Error parsing/merging SDP: %s\n", handle->handle_id, sdp_parsing_error(parser));
sdp_parser_free(parser);
return NULL;
}
/* Prepare SDP to merge */
gchar buffer[512];
memset(buffer, 0, 512);
char *sdp = (char*)calloc(BUFSIZE, sizeof(char));
if(sdp == NULL) {
JANUS_LOG(LOG_FATAL, "Memory error!\n");
sdp_parser_free(parser);
return NULL;
}
sdp[0] = '\0';
/* FIXME Any Plan B to take into account? */
int planb = strstr(origsdp, "a=planb:") ? 1 : 0;
if(planb) {
janus_flags_set(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_PLAN_B);
} else {
janus_flags_clear(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_PLAN_B);
}
/* Version v= */
g_strlcat(sdp,
"v=0\r\n", BUFSIZE);
/* Origin o= */
if(anon->sdp_origin) {
g_snprintf(buffer, 512,
"o=%s %"SCNu64" %"SCNu64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */
anon->sdp_origin->o_username ? anon->sdp_origin->o_username : "******",
anon->sdp_origin->o_id, anon->sdp_origin->o_version);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
gint64 sessid = janus_get_monotonic_time();
gint64 version = sessid; /* FIXME This needs to be increased when it changes, so time should be ok */
g_snprintf(buffer, 512,
"o=%s %"SCNi64" %"SCNi64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */
"-", sessid, version);
g_strlcat(sdp, buffer, BUFSIZE);
}
/* Session name s= */
if(anon->sdp_subject && strlen(anon->sdp_subject) > 0) {
g_snprintf(buffer, 512, "s=%s\r\n", anon->sdp_subject);
} else {
g_snprintf(buffer, 512, "s=%s\r\n", "Meetecho Janus");
}
g_strlcat(sdp, buffer, BUFSIZE);
/* Timing t= */
g_snprintf(buffer, 512,
"t=%lu %lu\r\n", anon->sdp_time ? anon->sdp_time->t_start : 0, anon->sdp_time ? anon->sdp_time->t_stop : 0);
g_strlcat(sdp, buffer, BUFSIZE);
/* ICE Full or Lite? */
if(janus_ice_is_ice_lite_enabled()) {
/* Janus is acting in ICE Lite mode, advertize this */
g_strlcat(sdp, "a=ice-lite\r\n", BUFSIZE);
}
/* bundle: add new global attribute */
int audio = (strstr(origsdp, "m=audio") != NULL);
int video = (strstr(origsdp, "m=video") != NULL);
#ifdef HAVE_SCTP
int data = (strstr(origsdp, "DTLS/SCTP") && !strstr(origsdp, " 0 DTLS/SCTP"));
#else
int data = 0;
#endif
g_strlcat(sdp, "a=group:BUNDLE", BUFSIZE);
if(audio) {
g_snprintf(buffer, 512,
" %s", handle->audio_mid ? handle->audio_mid : "audio");
g_strlcat(sdp, buffer, BUFSIZE);
}
if(video) {
g_snprintf(buffer, 512,
" %s", handle->video_mid ? handle->video_mid : "video");
g_strlcat(sdp, buffer, BUFSIZE);
}
if(data) {
g_snprintf(buffer, 512,
" %s", handle->data_mid ? handle->data_mid : "data");
g_strlcat(sdp, buffer, BUFSIZE);
}
g_strlcat(sdp, "\r\n", BUFSIZE);
/* msid-semantic: add new global attribute */
g_strlcat(sdp,
"a=msid-semantic: WMS janus\r\n",
BUFSIZE);
char wms[BUFSIZE];
memset(wms, 0, BUFSIZE);
g_strlcat(wms, "WMS", BUFSIZE);
/* Copy other global attributes, if any */
if(anon->sdp_attributes) {
sdp_attribute_t *a = anon->sdp_attributes;
while(a) {
if(a->a_value == NULL) {
g_snprintf(buffer, 512,
"a=%s\r\n", a->a_name);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
g_snprintf(buffer, 512,
"a=%s:%s\r\n", a->a_name, a->a_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
a = a->a_next;
}
}
gboolean ipv6 = strstr(janus_get_public_ip(), ":") != NULL;
/* Media lines now */
if(anon->sdp_media) {
int audio = 0, video = 0;
#ifdef HAVE_SCTP
int data = 0;
#endif
sdp_media_t *m = anon->sdp_media;
janus_ice_stream *stream = NULL;
while(m) {
if(m->m_type == sdp_media_audio && m->m_port > 0) {
audio++;
if(audio > 1 || !handle->audio_id) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping audio line (we have %d audio lines, and the id is %d)\n", handle->handle_id, audio, handle->audio_id);
g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
/* Audio */
stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(handle->audio_id));
if(stream == NULL) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping audio line (invalid stream %d)\n", handle->handle_id, handle->audio_id);
g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
g_strlcat(sdp, "m=audio 1 RTP/SAVPF", BUFSIZE);
} else if(m->m_type == sdp_media_video && m->m_port > 0) {
video++;
gint id = handle->video_id;
if(id == 0 && janus_flags_is_set(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_BUNDLE))
id = handle->audio_id > 0 ? handle->audio_id : handle->video_id;
if(video > 1 || !id) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping video line (we have %d video lines, and the id is %d)\n", handle->handle_id, video,
janus_flags_is_set(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_BUNDLE) ? handle->audio_id : handle->video_id);
g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
/* Video */
stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(id));
if(stream == NULL) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping video line (invalid stream %d)\n", handle->handle_id, id);
g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
g_strlcat(sdp, "m=video 1 RTP/SAVPF", BUFSIZE);
#ifdef HAVE_SCTP
} else if(m->m_type == sdp_media_application) {
/* Is this SCTP for DataChannels? */
if(m->m_port > 0 && m->m_proto_name != NULL && !strcasecmp(m->m_proto_name, "DTLS/SCTP") && m->m_port > 0) {
/* Yep */
data++;
gint id = handle->data_id;
if(id == 0 && janus_flags_is_set(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_BUNDLE))
id = handle->audio_id > 0 ? handle->audio_id : handle->video_id;
if(data > 1 || !id) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping SCTP line (we have %d SCTP lines, and the id is %d)\n", handle->handle_id, data, id);
g_snprintf(buffer, 512,
"m=%s 0 %s 0\r\n",
m->m_type_name, m->m_proto_name);
g_strlcat(sdp, buffer, BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
/* SCTP */
stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(id));
if(stream == NULL) {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping SCTP line (invalid stream %d)\n", handle->handle_id, id);
g_snprintf(buffer, 512,
"m=%s 0 %s 0\r\n",
m->m_type_name, m->m_proto_name);
g_strlcat(sdp, buffer, BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
g_strlcat(sdp, "m=application 1 DTLS/SCTP", BUFSIZE);
} else {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping unsupported application media line...\n", handle->handle_id);
g_snprintf(buffer, 512,
"m=%s 0 %s 0\r\n",
m->m_type_name, m->m_proto_name);
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
#endif
} else {
JANUS_LOG(LOG_WARN, "[%"SCNu64"] Skipping disabled/unsupported media line...\n", handle->handle_id);
g_snprintf(buffer, 512,
"m=%s 0 %s 0\r\n",
m->m_type_name, m->m_proto_name);
g_strlcat(sdp, buffer, BUFSIZE);
/* FIXME Adding a c-line anyway because otherwise Firefox complains? ("c= connection line not specified for every media level, validation failed") */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
/* Add formats now */
if(!m->m_rtpmaps) {
JANUS_LOG(LOG_VERB, "[%"SCNu64"] No RTP maps?? trying formats...\n", handle->handle_id);
if(!m->m_format) {
JANUS_LOG(LOG_ERR, "[%"SCNu64"] No formats either?? this sucks!\n", handle->handle_id);
g_strlcat(sdp, " 0", BUFSIZE); /* FIXME Won't work apparently */
} else {
sdp_list_t *fmt = m->m_format;
while(fmt) {
g_snprintf(buffer, 512, " %s", fmt->l_text);
g_strlcat(sdp, buffer, BUFSIZE);
fmt = fmt->l_next;
}
}
} else {
sdp_rtpmap_t *r = m->m_rtpmaps;
while(r) {
g_snprintf(buffer, 512, " %d", r->rm_pt);
g_strlcat(sdp, buffer, BUFSIZE);
r = r->rm_next;
}
}
g_strlcat(sdp, "\r\n", BUFSIZE);
/* Media connection c= */
g_snprintf(buffer, 512,
"c=IN %s %s\r\n", ipv6 ? "IP6" : "IP4", janus_get_public_ip());
g_strlcat(sdp, buffer, BUFSIZE);
/* Any bandwidth? */
if(m->m_bandwidths) {
g_snprintf(buffer, 512,
"b=%s:%lu\r\n", /* FIXME Are we doing this correctly? */
m->m_bandwidths->b_modifier_name ? m->m_bandwidths->b_modifier_name : "AS",
m->m_bandwidths->b_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
/* a=mid:(audio|video|data) */
switch(m->m_type) {
case sdp_media_audio:
g_snprintf(buffer, 512, "a=mid:%s\r\n", handle->audio_mid ? handle->audio_mid : "audio");
break;
case sdp_media_video:
g_snprintf(buffer, 512, "a=mid:%s\r\n", handle->video_mid ? handle->video_mid : "video");
break;
#ifdef HAVE_SCTP
case sdp_media_application:
/* FIXME sctpmap and webrtc-datachannel should be dynamic */
g_snprintf(buffer, 512, "a=mid:%s\r\na=sctpmap:5000 webrtc-datachannel 16\r\n",
handle->data_mid ? handle->data_mid : "data");
break;
#endif
default:
break;
}
g_strlcat(sdp, buffer, BUFSIZE);
if(m->m_type != sdp_media_application) {
/* What is the direction? */
switch(m->m_mode) {
case sdp_sendonly:
g_strlcat(sdp, "a=sendonly\r\n", BUFSIZE);
break;
case sdp_recvonly:
g_strlcat(sdp, "a=recvonly\r\n", BUFSIZE);
break;
case sdp_inactive:
g_strlcat(sdp, "a=inactive\r\n", BUFSIZE);
break;
case sdp_sendrecv:
default:
g_strlcat(sdp, "a=sendrecv\r\n", BUFSIZE);
break;
}
/* rtcp-mux */
g_snprintf(buffer, 512, "a=rtcp-mux\n");
g_strlcat(sdp, buffer, BUFSIZE);
/* RTP maps */
if(m->m_rtpmaps) {
sdp_rtpmap_t *rm = NULL;
for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) {
g_snprintf(buffer, 512, "a=rtpmap:%u %s/%lu%s%s\r\n",
rm->rm_pt, rm->rm_encoding, rm->rm_rate,
rm->rm_params ? "/" : "",
rm->rm_params ? rm->rm_params : "");
g_strlcat(sdp, buffer, BUFSIZE);
}
for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) {
if(rm->rm_fmtp) {
g_snprintf(buffer, 512, "a=fmtp:%u %s\r\n", rm->rm_pt, rm->rm_fmtp);
g_strlcat(sdp, buffer, BUFSIZE);
}
}
}
}
/* ICE ufrag and pwd, DTLS fingerprint setup and connection a= */
gchar *ufrag = NULL;
gchar *password = NULL;
nice_agent_get_local_credentials(handle->agent, stream->stream_id, &ufrag, &password);
memset(buffer, 0, 100);
g_snprintf(buffer, 512,
"a=ice-ufrag:%s\r\n"
"a=ice-pwd:%s\r\n"
"a=ice-options:trickle\r\n"
"a=fingerprint:sha-256 %s\r\n"
"a=setup:%s\r\n"
"a=connection:new\r\n",
ufrag, password,
janus_dtls_get_local_fingerprint(),
janus_get_dtls_srtp_role(stream->dtls_role));
if(ufrag != NULL)
g_free(ufrag);
ufrag = NULL;
if(password != NULL)
g_free(password);
password = NULL;
g_strlcat(sdp, buffer, BUFSIZE);
/* Copy existing media attributes, if any */
if(m->m_attributes) {
sdp_attribute_t *a = m->m_attributes;
while(a) {
if(!strcmp(a->a_name, "planb")) {
/* Skip the fake planb attribute, it's for internal use only */
a = a->a_next;
continue;
}
if(a->a_value == NULL) {
g_snprintf(buffer, 512,
"a=%s\r\n", a->a_name);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
g_snprintf(buffer, 512,
"a=%s:%s\r\n", a->a_name, a->a_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
a = a->a_next;
}
}
/* Add last attributes, rtcp and ssrc (msid) */
if(!planb) {
/* Single SSRC */
if(m->m_type == sdp_media_audio && m->m_mode != sdp_inactive && m->m_mode != sdp_recvonly) {
g_snprintf(buffer, 512,
"a=ssrc:%"SCNu32" cname:janusaudio\r\n"
"a=ssrc:%"SCNu32" msid:janus janusa0\r\n"
"a=ssrc:%"SCNu32" mslabel:janus\r\n"
"a=ssrc:%"SCNu32" label:janusa0\r\n",
stream->audio_ssrc, stream->audio_ssrc, stream->audio_ssrc, stream->audio_ssrc);
g_strlcat(sdp, buffer, BUFSIZE);
} else if(m->m_type == sdp_media_video && m->m_mode != sdp_inactive && m->m_mode != sdp_recvonly) {
g_snprintf(buffer, 512,
"a=ssrc:%"SCNu32" cname:janusvideo\r\n"
"a=ssrc:%"SCNu32" msid:janus janusv0\r\n"
"a=ssrc:%"SCNu32" mslabel:janus\r\n"
"a=ssrc:%"SCNu32" label:janusv0\r\n",
stream->video_ssrc, stream->video_ssrc, stream->video_ssrc, stream->video_ssrc);
g_strlcat(sdp, buffer, BUFSIZE);
}
} else {
/* Multiple SSRCs */
char mslabel[255];
memset(mslabel, 0, 255);
if(m->m_attributes) {
char id[256];
uint32_t ssrc = 0;
sdp_attribute_t *a = m->m_attributes;
while(a) {
if(a->a_name == NULL || a->a_value == NULL || strcmp(a->a_name, "planb")) {
a = a->a_next;
continue;
}
if(sscanf(a->a_value, "%255s %"SCNu32"", id, &ssrc) != 2) {
JANUS_LOG(LOG_ERR, "Error parsing 'planb' attribute, skipping it...\n");
a = a->a_next;
continue;
}
JANUS_LOG(LOG_VERB, "Parsing 'planb' attribute: %s\n", a->a_value);
/* Add proper SSRC attributes */
if(m->m_type == sdp_media_audio) {
g_snprintf(buffer, 512,
"a=ssrc:%"SCNu32" cname:%saudio\r\n"
"a=ssrc:%"SCNu32" msid:%s %sa0\r\n"
"a=ssrc:%"SCNu32" mslabel:%s\r\n"
"a=ssrc:%"SCNu32" label:%sa0\r\n",
ssrc, id, ssrc, id, id, ssrc, id, ssrc, id);
} else if(m->m_type == sdp_media_video) {
g_snprintf(buffer, 512,
"a=ssrc:%"SCNu32" cname:%svideo\r\n"
"a=ssrc:%"SCNu32" msid:%s %sv0\r\n"
"a=ssrc:%"SCNu32" mslabel:%s\r\n"
"a=ssrc:%"SCNu32" label:%sv0\r\n",
ssrc, id, ssrc, id, id, ssrc, id, ssrc, id);
}
g_strlcat(sdp, buffer, BUFSIZE);
/* Add to msid-semantic, if needed */
if(!strstr(wms, id)) {
g_snprintf(mslabel, 255, " %s", id);
g_strlcat(wms, mslabel, BUFSIZE);
}
/* Go on */
a = a->a_next;
}
}
}
/* And now the candidates */
janus_ice_candidates_to_sdp(handle, sdp, stream->stream_id, 1);
if(!janus_flags_is_set(&handle->webrtc_flags, JANUS_ICE_HANDLE_WEBRTC_RTCPMUX) &&
m->m_type != sdp_media_application)
janus_ice_candidates_to_sdp(handle, sdp, stream->stream_id, 2);
/* Next */
m = m->m_next;
}
}
/* Do we need to update the msid-semantic attribute? */
if(planb) {
sdp = janus_string_replace(sdp, "WMS janus", wms);
}
sdp_parser_free(parser);
JANUS_LOG(LOG_VERB, " -------------------------------------------\n");
JANUS_LOG(LOG_VERB, " >> Merged (%zu --> %zu bytes)\n", strlen(origsdp), strlen(sdp));
JANUS_LOG(LOG_VERB, " -------------------------------------------\n");
JANUS_LOG(LOG_VERB, "%s\n", sdp);
return sdp;
}
bool LibNiceInterfaceImpl::NiceAgentGetLocalCredentials(NiceAgent* agent, unsigned int stream_id,
char** ufrag, char** pass) {
return nice_agent_get_local_credentials(agent, stream_id, ufrag, pass);
}
char *janus_sdp_merge(janus_ice_handle *handle, const char *origsdp) {
if(handle == NULL || origsdp == NULL)
return NULL;
//~ su_home_t home[1] = { SU_HOME_INIT(home) };
sdp_session_t *anon = NULL;
sdp_parser_t *parser = sdp_parse(home, origsdp, strlen(origsdp), 0);
if(!(anon = sdp_session(parser))) {
JANUS_DEBUG("[%"SCNu64"] Error parsing/merging SDP: %s\n", handle->handle_id, sdp_parsing_error(parser));
return NULL;
}
/* Prepare SDP to merge */
gchar buffer[200];
memset(buffer, 0, 200);
char *sdp = (char*)calloc(BUFSIZE, sizeof(char));
if(sdp == NULL) {
JANUS_DEBUG("Memory error!\n");
return NULL;
}
sdp[0] = '\0';
/* Version v= */
g_strlcat(sdp,
"v=0\r\n", BUFSIZE);
/* Origin o= */
if(anon->sdp_origin) {
g_sprintf(buffer,
"o=%s %"SCNu64" %"SCNu64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */
anon->sdp_origin->o_username ? anon->sdp_origin->o_username : "******",
anon->sdp_origin->o_id, anon->sdp_origin->o_version);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
gint64 sessid = g_get_monotonic_time();
gint64 version = sessid; /* FIXME This needs to be increased when it changes, so time should be ok */
g_sprintf(buffer,
"o=%s %"SCNi64" %"SCNi64" IN IP4 127.0.0.1\r\n", /* FIXME Should we fix the address? */
"-", sessid, version);
g_strlcat(sdp, buffer, BUFSIZE);
}
/* Session name s= */
g_sprintf(buffer,
"s=%s\r\n", anon->sdp_subject ? anon->sdp_subject : "Meetecho Janus");
g_strlcat(sdp, buffer, BUFSIZE);
/* Timing t= */
g_sprintf(buffer,
"t=%lu %lu\r\n", anon->sdp_time ? anon->sdp_time->t_start : 0, anon->sdp_time ? anon->sdp_time->t_stop : 0);
g_strlcat(sdp, buffer, BUFSIZE);
/* Any global bandwidth? */
//~ if(anon->sdp_bandwidths) {
//~ g_sprintf(buffer,
//~ "b=%s:%"SCNu64"\r\n",
//~ anon->sdp_bandwidths->b_modifier_name ? anon->sdp_bandwidths->b_modifier_name : "AS",
//~ anon->sdp_bandwidths->b_value);
//~ g_strlcat(sdp, buffer, BUFSIZE);
//~ }
/* msid-semantic: add new global attribute */
g_strlcat(sdp,
"a=msid-semantic: WMS janus\r\n",
BUFSIZE);
//~ /* Connection c= (global) */
//~ if(anon->sdp_connection) {
//~ g_sprintf(buffer,
//~ "c=IN IP4 %s\r\n", janus_get_local_ip());
//~ g_strlcat(sdp, buffer, BUFSIZE);
//~ }
/* DTLS fingerprint a= (global) */
g_sprintf(buffer,
"a=fingerprint:sha-256 %s\r\n", janus_dtls_get_local_fingerprint());
g_strlcat(sdp, buffer, BUFSIZE);
/* Copy other global attributes, if any */
if(anon->sdp_attributes) {
sdp_attribute_t *a = anon->sdp_attributes;
while(a) {
if(a->a_value == NULL) {
g_sprintf(buffer,
"a=%s\r\n", a->a_name);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
g_sprintf(buffer,
"a=%s:%s\r\n", a->a_name, a->a_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
a = a->a_next;
}
}
/* Media lines now */
if(anon->sdp_media) {
int audio = 0, video = 0;
sdp_media_t *m = anon->sdp_media;
janus_ice_stream *stream = NULL;
while(m) {
if(m->m_type == sdp_media_audio) {
audio++;
if(audio > 1 || !handle->audio_id) {
JANUS_DEBUG("[%"SCNu64"] Skipping audio line (we have %d audio lines, and the id is %d)\n", handle->handle_id, audio, handle->audio_id);
g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE);
m = m->m_next;
continue;
}
/* Audio */
stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(handle->audio_id));
if(stream == NULL) {
JANUS_DEBUG("[%"SCNu64"] Skipping audio line (invalid stream %d)\n", handle->handle_id, handle->audio_id);
g_strlcat(sdp, "m=audio 0 RTP/SAVPF 0\r\n", BUFSIZE);
m = m->m_next;
continue;
}
g_strlcat(sdp, "m=audio ARTPP RTP/SAVPF", BUFSIZE);
} else if(m->m_type == sdp_media_video) {
video++;
if(video > 1 || !handle->video_id) {
JANUS_DEBUG("[%"SCNu64"] Skipping video line (we have %d video lines, and the id is %d)\n", handle->handle_id, video, handle->video_id);
g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE);
m = m->m_next;
continue;
}
/* Video */
stream = g_hash_table_lookup(handle->streams, GUINT_TO_POINTER(handle->video_id));
if(stream == NULL) {
JANUS_DEBUG("[%"SCNu64"] Skipping video line (invalid stream %d)\n", handle->handle_id, handle->audio_id);
g_strlcat(sdp, "m=video 0 RTP/SAVPF 0\r\n", BUFSIZE);
m = m->m_next;
continue;
}
g_strlcat(sdp, "m=video VRTPP RTP/SAVPF", BUFSIZE);
} else {
JANUS_DEBUG("[%"SCNu64"] Skipping unsupported media line...\n", handle->handle_id);
g_sprintf(buffer,
"m=%s 0 %s 0\r\n",
m->m_type_name, m->m_proto_name);
g_strlcat(sdp, buffer, BUFSIZE);
m = m->m_next;
continue;
}
/* Add formats now */
if(!m->m_rtpmaps) {
JANUS_PRINT("[%"SCNu64"] No RTP maps?? trying formats...\n", handle->handle_id);
if(!m->m_format) {
JANUS_DEBUG("[%"SCNu64"] No formats either?? this sucks!\n", handle->handle_id);
g_strlcat(sdp, " 0", BUFSIZE); /* FIXME Won't work apparently */
} else {
sdp_list_t *fmt = m->m_format;
while(fmt) {
g_sprintf(buffer, " %s", fmt->l_text);
g_strlcat(sdp, buffer, BUFSIZE);
fmt = fmt->l_next;
}
}
} else {
sdp_rtpmap_t *r = m->m_rtpmaps;
while(r) {
g_sprintf(buffer, " %d", r->rm_pt);
g_strlcat(sdp, buffer, BUFSIZE);
r = r->rm_next;
}
}
g_strlcat(sdp, "\r\n", BUFSIZE);
/* Any bandwidth? */
if(m->m_bandwidths) {
g_sprintf(buffer,
"b=%s:%lu\r\n", /* FIXME Are we doing this correctly? */
m->m_bandwidths->b_modifier_name ? m->m_bandwidths->b_modifier_name : "AS",
m->m_bandwidths->b_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
/* Media connection c= */
//~ if(m->m_connections) {
g_sprintf(buffer,
"c=IN IP4 %s\r\n", janus_get_local_ip());
g_strlcat(sdp, buffer, BUFSIZE);
//~ }
/* What is the direction? */
switch(m->m_mode) {
case sdp_inactive:
g_strlcat(sdp, "a=inactive\r\n", BUFSIZE);
break;
case sdp_sendonly:
g_strlcat(sdp, "a=sendonly\r\n", BUFSIZE);
break;
case sdp_recvonly:
g_strlcat(sdp, "a=recvonly\r\n", BUFSIZE);
break;
case sdp_sendrecv:
default:
g_strlcat(sdp, "a=sendrecv\r\n", BUFSIZE);
break;
}
/* RTCP */
g_sprintf(buffer, "a=rtcp:%s IN IP4 %s\r\n",
m->m_type == sdp_media_audio ? "ARTCP" : "VRTCP", janus_get_local_ip());
g_strlcat(sdp, buffer, BUFSIZE);
/* RTP maps */
if(m->m_rtpmaps) {
sdp_rtpmap_t *rm = NULL;
for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) {
g_sprintf(buffer, "a=rtpmap:%u %s/%lu%s%s\r\n",
rm->rm_pt, rm->rm_encoding, rm->rm_rate,
rm->rm_params ? "/" : "",
rm->rm_params ? rm->rm_params : "");
g_strlcat(sdp, buffer, BUFSIZE);
}
for(rm = m->m_rtpmaps; rm; rm = rm->rm_next) {
if(rm->rm_fmtp) {
g_sprintf(buffer, "a=fmtp:%u %s\r\n", rm->rm_pt, rm->rm_fmtp);
g_strlcat(sdp, buffer, BUFSIZE);
}
}
}
/* ICE ufrag and pwd, DTLS setup and connection a= */
gchar *ufrag = NULL;
gchar *password = NULL;
nice_agent_get_local_credentials(handle->agent, stream->stream_id, &ufrag, &password);
memset(buffer, 0, 100);
g_sprintf(buffer,
"a=ice-ufrag:%s\r\n"
"a=ice-pwd:%s\r\n"
"a=setup:%s\r\n"
"a=connection:new\r\n",
ufrag, password,
janus_get_dtls_srtp_role(stream->dtls_role));
g_strlcat(sdp, buffer, BUFSIZE);
/* Copy existing media attributes, if any */
if(m->m_attributes) {
sdp_attribute_t *a = m->m_attributes;
while(a) {
if(a->a_value == NULL) {
g_sprintf(buffer,
"a=%s\r\n", a->a_name);
g_strlcat(sdp, buffer, BUFSIZE);
} else {
g_sprintf(buffer,
"a=%s:%s\r\n", a->a_name, a->a_value);
g_strlcat(sdp, buffer, BUFSIZE);
}
a = a->a_next;
}
}
/* Add last attributes, rtcp and ssrc (msid) */
if(m->m_type == sdp_media_audio) {
g_sprintf(buffer,
//~ "a=rtcp:ARTCP IN IP4 %s\r\n"
"a=ssrc:%i cname:janusaudio\r\n"
"a=ssrc:%i msid:janus janusa0\r\n"
"a=ssrc:%i mslabel:janus\r\n"
"a=ssrc:%i label:janusa0\r\n",
//~ janus_get_local_ip(),
stream->ssrc, stream->ssrc, stream->ssrc, stream->ssrc);
g_strlcat(sdp, buffer, BUFSIZE);
} else if(m->m_type == sdp_media_video) {
g_sprintf(buffer,
//~ "a=rtcp:VRTCP IN IP4 %s\r\n"
"a=ssrc:%i cname:janusvideo\r\n"
"a=ssrc:%i msid:janus janusv0\r\n"
"a=ssrc:%i mslabel:janus\r\n"
"a=ssrc:%i label:janusv0\r\n",
//~ janus_get_local_ip(),
stream->ssrc, stream->ssrc, stream->ssrc, stream->ssrc);
g_strlcat(sdp, buffer, BUFSIZE);
}
/* And now the candidates */
janus_ice_setup_candidate(handle, sdp, stream->stream_id, 1);
janus_ice_setup_candidate(handle, sdp, stream->stream_id, 2);
/* Next */
m = m->m_next;
}
}
JANUS_PRINT(" -------------------------------------------\n");
JANUS_PRINT(" >> Merged (%zu --> %zu bytes)\n", strlen(origsdp), strlen(sdp));
JANUS_PRINT(" -------------------------------------------\n");
JANUS_PRINT("%s\n", sdp);
return sdp;
}
static int run_full_test_control_conflict (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, gboolean role)
{
NiceAddress laddr, raddr;
NiceCandidate cdes;
GSList *cands, *i;
guint ls_id, rs_id;
init_candidate (&cdes);
/* 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);
}
/* step: find out the local candidates of each agent */
cands = nice_agent_get_local_candidates(lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
for (i = cands; i; i = i->next) {
NiceCandidate *cand = i->data;
if (cand) {
g_debug ("test-fullmode: local port L %u",
nice_address_get_port (&cand->addr));
laddr = cand->addr;
}
}
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
cands = nice_agent_get_local_candidates(ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
for (i = cands; i; i = i->next) {
NiceCandidate *cand = i->data;
if (cand) {
g_debug ("test-fullmode: local port R %u",
nice_address_get_port (&cand->addr));
raddr = cand->addr;
}
}
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
g_debug ("test-fullmode: Got local candidates...");
/* step: pass the remote candidates to agents */
cands = g_slist_append (NULL, &cdes);
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
cdes.addr = raddr;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.addr = laddr;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
g_slist_free (cands);
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 == 1);
g_assert (global_ragent_cands == 1);
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)
{
NiceAddress laddr, raddr, laddr_rtcp, raddr_rtcp;
NiceCandidate cdes;
GSList *cands;
guint ls_id, rs_id;
init_candidate (&cdes);
/* 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);
}
/* step: find out the local candidates of each agent */
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, &raddr);
g_debug ("test-fullmode: local RTP port R %u",
nice_address_get_port (&raddr));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, &laddr);
g_debug ("test-fullmode: local RTP port L %u",
nice_address_get_port (&laddr));
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, &raddr_rtcp);
g_debug ("test-fullmode: local RTCP port R %u",
nice_address_get_port (&raddr_rtcp));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, &laddr_rtcp);
g_debug ("test-fullmode: local RTCP port L %u",
nice_address_get_port (&laddr_rtcp));
/* step: pass the remote candidates to agent R (answering party) */
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
/* step: set remote candidates for agent R (answering party) */
/*
cands = g_slist_append (NULL, &cdes);
cdes.component_id = NICE_COMPONENT_TYPE_RTP;
cdes.addr = laddr;*/
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
/*cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
cdes.addr = laddr_rtcp;*/
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP);
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
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 the remote candidates to agent L (offering party) */
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
/* step: pass remove candidates to agent L (offering party) */
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
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;
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 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);
g_slist_free (cands);
return 0;
}
static int run_full_test (NiceAgent *lagent, NiceAgent *ragent, NiceAddress *baseaddr, guint ready, guint failed)
{
// NiceAddress laddr, raddr, laddr_rtcp, raddr_rtcp;
NiceCandidate cdes;
GSList *cands, *i;
guint ls_id, rs_id;
init_candidate (&cdes);
/* 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;
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);
#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(lagent, ls_id, 2,
TURN_IP, TURN_PORT, TURN_USER, TURN_PASS, TURN_TYPE);
nice_agent_set_relay_info(ragent, rs_id, 1,
TURN_IP, TURN_PORT, TURN_USER2, TURN_PASS2, TURN_TYPE);
nice_agent_set_relay_info(ragent, rs_id, 2,
TURN_IP, TURN_PORT, TURN_USER2, TURN_PASS2, 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 (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);
}
/* step: find out the local candidates of each agent */
/* priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, &raddr);
g_debug ("test-fullmode: local RTP port R %u",
nice_address_get_port (&raddr));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, &laddr);
g_debug ("test-fullmode: local RTP port L %u",
nice_address_get_port (&laddr));
priv_get_local_addr (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, &raddr_rtcp);
g_debug ("test-fullmode: local RTCP port R %u",
nice_address_get_port (&raddr_rtcp));
priv_get_local_addr (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, &laddr_rtcp);
g_debug ("test-fullmode: local RTCP port L %u",
nice_address_get_port (&laddr_rtcp));*/
/* step: pass the remote candidates to agents */
//cands = g_slist_append (NULL, &cdes);
{
gchar *ufrag = NULL, *password = NULL;
nice_agent_get_local_credentials(lagent, ls_id, &ufrag, &password);
nice_agent_set_remote_credentials (ragent,
rs_id, ufrag, password);
g_free (ufrag);
g_free (password);
nice_agent_get_local_credentials(ragent, rs_id, &ufrag, &password);
nice_agent_set_remote_credentials (lagent,
ls_id, ufrag, password);
g_free (ufrag);
g_free (password);
}
/* cdes.component_id = NICE_COMPONENT_TYPE_RTP;
cdes.addr = raddr;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.addr = laddr;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
cdes.component_id = NICE_COMPONENT_TYPE_RTCP;
cdes.addr = raddr_rtcp;
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
cdes.addr = laddr_rtcp;
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
g_slist_free (cands);*/
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
cands = priv_get_local_candidate (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP);
nice_agent_set_remote_candidates (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTP);
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
cands = priv_get_local_candidate (lagent, ls_id, NICE_COMPONENT_TYPE_RTCP);
nice_agent_set_remote_candidates (ragent, rs_id, NICE_COMPONENT_TYPE_RTCP, cands);
for (i = cands; i; i = i->next)
nice_candidate_free ((NiceCandidate *) i->data);
g_slist_free (cands);
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 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;
g_assert (nice_agent_send (lagent, ls_id, 1, 16, "1234567812345678") == 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;
}
NiceConnection::NiceConnection(MediaType med, const std::string &transport_name,NiceConnectionListener* listener,
unsigned int iceComponents, const IceConfig& iceConfig, std::string username, std::string password)
: mediaType(med), agent_(NULL), listener_(listener), candsDelivered_(0), context_(NULL), iceState_(NICE_INITIAL), iceComponents_(iceComponents) {
localCandidates.reset(new std::vector<CandidateInfo>());
transportName.reset(new std::string(transport_name));
for (unsigned int i = 1; i<=iceComponents_; i++) {
comp_state_list_[i] = NICE_INITIAL;
}
g_type_init();
context_ = g_main_context_new();
g_main_context_set_poll_func(context_,timed_poll);
ELOG_DEBUG("Creating Agent");
nice_debug_enable( FALSE );
// Create a nice agent
agent_ = nice_agent_new(context_, NICE_COMPATIBILITY_RFC5245);
GValue controllingMode = { 0 };
g_value_init(&controllingMode, G_TYPE_BOOLEAN);
g_value_set_boolean(&controllingMode, false);
g_object_set_property(G_OBJECT( agent_ ), "controlling-mode", &controllingMode);
GValue checks = { 0 };
g_value_init(&checks, G_TYPE_UINT);
g_value_set_uint(&checks, 100);
g_object_set_property(G_OBJECT( agent_ ), "max-connectivity-checks", &checks);
if (iceConfig.stunServer.compare("") != 0 && iceConfig.stunPort!=0){
GValue val = { 0 }, val2 = { 0 };
g_value_init(&val, G_TYPE_STRING);
g_value_set_string(&val, iceConfig.stunServer.c_str());
g_object_set_property(G_OBJECT( agent_ ), "stun-server", &val);
g_value_init(&val2, G_TYPE_UINT);
g_value_set_uint(&val2, iceConfig.stunPort);
g_object_set_property(G_OBJECT( agent_ ), "stun-server-port", &val2);
ELOG_DEBUG("Setting STUN server %s:%d", iceConfig.stunServer.c_str(), iceConfig.stunPort);
}
// Connect the signals
g_signal_connect( G_OBJECT( agent_ ), "candidate-gathering-done",
G_CALLBACK( cb_candidate_gathering_done ), this);
g_signal_connect( G_OBJECT( agent_ ), "component-state-changed",
G_CALLBACK( cb_component_state_changed ), this);
g_signal_connect( G_OBJECT( agent_ ), "new-selected-pair",
G_CALLBACK( cb_new_selected_pair ), this);
g_signal_connect( G_OBJECT( agent_ ), "new-candidate",
G_CALLBACK( cb_new_candidate ), this);
// Create a new stream and start gathering candidates
ELOG_DEBUG("Adding Stream... Number of components %d", iceComponents_);
nice_agent_add_stream(agent_, iceComponents_);
gchar *ufrag = NULL, *upass = NULL;
nice_agent_get_local_credentials(agent_, 1, &ufrag, &upass);
ufrag_ = std::string(ufrag); g_free(ufrag);
upass_ = std::string(upass); g_free(upass);
// Set our remote credentials. This must be done *after* we add a stream.
if (username.compare("")!=0 && password.compare("")!=0){
ELOG_DEBUG("Setting remote credentials in constructor");
this->setRemoteCredentials(username, password);
}
// Set Port Range ----> If this doesn't work when linking the file libnice.sym has to be modified to include this call
if (iceConfig.minPort!=0 && iceConfig.maxPort!=0){
ELOG_DEBUG("Setting port range: %d to %d\n", iceConfig.minPort, iceConfig.maxPort);
nice_agent_set_port_range(agent_, (guint)1, (guint)1, (guint)iceConfig.minPort, (guint)iceConfig.maxPort);
}
if (iceConfig.turnServer.compare("") != 0 && iceConfig.turnPort!=0){
ELOG_DEBUG("Setting TURN server %s:%d", iceConfig.turnServer.c_str(), iceConfig.turnPort);
ELOG_DEBUG("Setting TURN credentials %s:%s", iceConfig.turnUsername.c_str(), iceConfig.turnPass.c_str());
for (unsigned int i = 1; i <= iceComponents_ ; i++){
nice_agent_set_relay_info (agent_,
1,
i,
iceConfig.turnServer.c_str(), // TURN Server IP
iceConfig.turnPort, // TURN Server PORT
iceConfig.turnUsername.c_str(), // Username
iceConfig.turnPass.c_str(), // Pass
NICE_RELAY_TYPE_TURN_UDP);
}
}
if(agent_){
for (unsigned int i = 1; i<=iceComponents_; i++){
nice_agent_attach_recv(agent_, 1, i, context_, cb_nice_recv, this);
}
running_ = true;
}
else{
running_=false;
}
m_Thread_ = boost::thread(&NiceConnection::init, this);
}
