void get_and_register_SDP_to_cloud(struct ice_trans_s* icetrans, ice_option_t opt, char *usrid)
{
static char buffer[2048];
int len;
if (icetrans->icest == NULL) {
PJ_LOG(1,(THIS_FILE, "Error: No ICE instance, create it first"));
return;
}
PJ_LOG(4, (__FUNCTION__, "General info"));
PJ_LOG(4, (__FUNCTION__,"---------------"));
PJ_LOG(4, (__FUNCTION__,"Component count : %d\n", opt.comp_cnt));
PJ_LOG(4, (__FUNCTION__,"Status : "));
if (pj_ice_strans_sess_is_complete(icetrans->icest))
puts("negotiation complete");
else if (pj_ice_strans_sess_is_running(icetrans->icest))
puts("negotiation is in progress");
else if (pj_ice_strans_has_sess(icetrans->icest))
puts("session ready");
else
puts("session not created");
if (!pj_ice_strans_has_sess(icetrans->icest)) {
puts("Create the session first to see more info");
return;
}
printf("Negotiated comp_cnt: %d\n",
pj_ice_strans_get_running_comp_cnt(icetrans->icest));
printf("Role : %s\n",
pj_ice_strans_get_role(icetrans->icest)==PJ_ICE_SESS_ROLE_CONTROLLED ?
"controlled" : "controlling");
len = extract_sdp_to_xml(icetrans, buffer, 2048, opt, usrid);
if (len < 0)
err_exit("not enough buffer to show ICE status", -len, icetrans);
// Register this local SDP to cloud
char full_url[256];
//printf("[DEBUG] %s, %d \n", __FUNCTION__, __LINE__ );
strcpy(full_url, gUrl); // plus URL
strcpy(&full_url[strlen(full_url)], "/peer/registerPeer"); // plus API
http_post_request(full_url, buffer);
PJ_LOG(4, (__FUNCTION__,"Local SDP (paste this to remote host):\n"
"--------------------------------------\n"
"%s\n", buffer));
}
/*
* Show information contained in the ICE stream transport. This is
* invoked from the menu.
*/
static void icedemo_show_ice(void)
{
static char buffer[1000];
int len;
if (icedemo.icest == NULL) {
PJ_LOG(1,(THIS_FILE, "Error: No ICE instance, create it first"));
return;
}
puts("General info");
puts("---------------");
printf("Component count : %d\n", icedemo.opt.comp_cnt);
printf("Status : ");
if (pj_ice_strans_sess_is_complete(icedemo.icest))
puts("negotiation complete");
else if (pj_ice_strans_sess_is_running(icedemo.icest))
puts("negotiation is in progress");
else if (pj_ice_strans_has_sess(icedemo.icest))
puts("session ready");
else
puts("session not created");
if (!pj_ice_strans_has_sess(icedemo.icest)) {
puts("Create the session first to see more info");
return;
}
printf("Negotiated comp_cnt: %d\n",
pj_ice_strans_get_running_comp_cnt(icedemo.icest));
printf("Role : %s\n",
pj_ice_strans_get_role(icedemo.icest)==PJ_ICE_SESS_ROLE_CONTROLLED ?
"controlled" : "controlling");
len = encode_session(buffer, sizeof(buffer));
if (len < 0)
err_exit("not enough buffer to show ICE status", -len);
puts("");
printf("Local SDP (paste this to remote host):\n"
"--------------------------------------\n"
"%s\n", buffer);
puts("");
puts("Remote info:\n"
"----------------------");
if (icedemo.rem.cand_cnt==0) {
puts("No remote info yet");
} else {
unsigned i;
printf("Remote ufrag : %s\n", icedemo.rem.ufrag);
printf("Remote password : %s\n", icedemo.rem.pwd);
printf("Remote cand. cnt. : %d\n", icedemo.rem.cand_cnt);
for (i=0; i<icedemo.rem.cand_cnt; ++i) {
len = print_cand(buffer, sizeof(buffer), &icedemo.rem.cand[i]);
if (len < 0)
err_exit("not enough buffer to show ICE status", -len);
printf(" %s", buffer);
}
}
}
/* Encode ICE information in SDP */
static pj_status_t encode_session_in_sdp(struct transport_ice *tp_ice,
pj_pool_t *sdp_pool,
pjmedia_sdp_session *sdp_local,
unsigned media_index,
unsigned comp_cnt,
pj_bool_t restart_session)
{
enum {
ATTR_BUF_LEN = 160, /* Max len of a=candidate attr */
RATTR_BUF_LEN= 160 /* Max len of a=remote-candidates attr */
};
pjmedia_sdp_media *m = sdp_local->media[media_index];
pj_str_t local_ufrag, local_pwd;
pjmedia_sdp_attr *attr;
pj_status_t status;
/* Must have a session */
PJ_ASSERT_RETURN(pj_ice_strans_has_sess(tp_ice->ice_st), PJ_EBUG);
/* Get ufrag and pwd from current session */
pj_ice_strans_get_ufrag_pwd(tp_ice->ice_st, &local_ufrag, &local_pwd,
NULL, NULL);
/* The listing of candidates depends on whether ICE has completed
* or not. When ICE has completed:
*
* 9.1.2.2: Existing Media Streams with ICE Completed
* The agent MUST include a candidate attributes for candidates
* matching the default destination for each component of the
* media stream, and MUST NOT include any other candidates.
*
* When ICE has not completed, we shall include all candidates.
*
* Except when we have detected that remote is offering to restart
* the session, in this case we will answer with full ICE SDP and
* new ufrag/pwd pair.
*/
if (!restart_session && pj_ice_strans_sess_is_complete(tp_ice->ice_st)) {
const pj_ice_sess_check *check;
char *attr_buf;
pjmedia_sdp_conn *conn;
pjmedia_sdp_attr *a_rtcp;
pj_str_t rem_cand;
unsigned comp;
/* Encode ice-ufrag attribute */
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_UFRAG.ptr,
&local_ufrag);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
/* Encode ice-pwd attribute */
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_PWD.ptr,
&local_pwd);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
/* Prepare buffer */
attr_buf = (char*) pj_pool_alloc(sdp_pool, ATTR_BUF_LEN);
rem_cand.ptr = (char*) pj_pool_alloc(sdp_pool, RATTR_BUF_LEN);
rem_cand.slen = 0;
/* 9.1.2.2: Existing Media Streams with ICE Completed
* The default destination for media (i.e., the values of
* the IP addresses and ports in the m and c line used for
* that media stream) MUST be the local candidate from the
* highest priority nominated pair in the valid list for each
* component.
*/
check = pj_ice_strans_get_valid_pair(tp_ice->ice_st, 1);
if (check == NULL) {
pj_assert(!"Shouldn't happen");
return PJ_EBUG;
}
/* Override connection line address and media port number */
conn = m->conn;
if (conn == NULL)
conn = sdp_local->conn;
conn->addr.ptr = (char*) pj_pool_alloc(sdp_pool,
PJ_INET6_ADDRSTRLEN);
pj_sockaddr_print(&check->lcand->addr, conn->addr.ptr,
PJ_INET6_ADDRSTRLEN, 0);
conn->addr.slen = pj_ansi_strlen(conn->addr.ptr);
m->desc.port = pj_sockaddr_get_port(&check->lcand->addr);
/* Override address RTCP attribute if it's present */
if (comp_cnt == 2 &&
(check = pj_ice_strans_get_valid_pair(tp_ice->ice_st,
COMP_RTCP)) != NULL &&
(a_rtcp = pjmedia_sdp_attr_find(m->attr_count, m->attr,
&STR_RTCP, 0)) != NULL)
{
pjmedia_sdp_attr_remove(&m->attr_count, m->attr, a_rtcp);
a_rtcp = pjmedia_sdp_attr_create_rtcp(sdp_pool,
&check->lcand->addr);
if (a_rtcp)
pjmedia_sdp_attr_add(&m->attr_count, m->attr, a_rtcp);
}
/* Encode only candidates matching the default destination
* for each component
*/
for (comp=0; comp < comp_cnt; ++comp) {
int len;
pj_str_t value;
/* Get valid pair for this component */
check = pj_ice_strans_get_valid_pair(tp_ice->ice_st, comp+1);
if (check == NULL)
continue;
/* Print and add local candidate in the pair */
value.ptr = attr_buf;
value.slen = print_sdp_cand_attr(attr_buf, ATTR_BUF_LEN,
check->lcand);
if (value.slen < 0) {
pj_assert(!"Not enough attr_buf to print candidate");
return PJ_EBUG;
}
attr = pjmedia_sdp_attr_create(sdp_pool, STR_CANDIDATE.ptr,
&value);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
/* Append to a=remote-candidates attribute */
if (pj_ice_strans_get_role(tp_ice->ice_st) ==
PJ_ICE_SESS_ROLE_CONTROLLING)
{
char rem_addr[PJ_INET6_ADDRSTRLEN];
pj_sockaddr_print(&check->rcand->addr, rem_addr,
sizeof(rem_addr), 0);
len = pj_ansi_snprintf(
rem_cand.ptr + rem_cand.slen,
RATTR_BUF_LEN - rem_cand.slen,
"%s%u %s %u",
(rem_cand.slen==0? "" : " "),
comp+1, rem_addr,
pj_sockaddr_get_port(&check->rcand->addr)
);
if (len < 1 || len >= RATTR_BUF_LEN) {
pj_assert(!"Not enough buffer to print "
"remote-candidates");
return PJ_EBUG;
}
rem_cand.slen += len;
}
}
/* 9.1.2.2: Existing Media Streams with ICE Completed
* In addition, if the agent is controlling, it MUST include
* the a=remote-candidates attribute for each media stream
* whose check list is in the Completed state. The attribute
* contains the remote candidates from the highest priority
* nominated pair in the valid list for each component of that
* media stream.
*/
if (pj_ice_strans_get_role(tp_ice->ice_st) ==
PJ_ICE_SESS_ROLE_CONTROLLING)
{
attr = pjmedia_sdp_attr_create(sdp_pool, STR_REM_CAND.ptr,
&rem_cand);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
} else if (pj_ice_strans_has_sess(tp_ice->ice_st)) {
/* Encode all candidates to SDP media */
char *attr_buf;
unsigned comp;
/* If ICE is not restarted, encode current ICE ufrag/pwd.
* Otherwise generate new one.
*/
if (!restart_session) {
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_UFRAG.ptr,
&local_ufrag);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_PWD.ptr,
&local_pwd);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
} else {
pj_str_t str;
str.slen = PJ_ICE_UFRAG_LEN;
str.ptr = (char*) pj_pool_alloc(sdp_pool, str.slen);
pj_create_random_string(str.ptr, str.slen);
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_UFRAG.ptr, &str);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
str.ptr = (char*) pj_pool_alloc(sdp_pool, str.slen);
pj_create_random_string(str.ptr, str.slen);
attr = pjmedia_sdp_attr_create(sdp_pool, STR_ICE_PWD.ptr, &str);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
/* Create buffer to encode candidates as SDP attribute */
attr_buf = (char*) pj_pool_alloc(sdp_pool, ATTR_BUF_LEN);
for (comp=0; comp < comp_cnt; ++comp) {
unsigned cand_cnt;
pj_ice_sess_cand cand[PJ_ICE_ST_MAX_CAND];
unsigned i;
cand_cnt = PJ_ARRAY_SIZE(cand);
status = pj_ice_strans_enum_cands(tp_ice->ice_st, comp+1,
&cand_cnt, cand);
if (status != PJ_SUCCESS)
return status;
for (i=0; i<cand_cnt; ++i) {
pj_str_t value;
value.slen = print_sdp_cand_attr(attr_buf, ATTR_BUF_LEN,
&cand[i]);
if (value.slen < 0) {
pj_assert(!"Not enough attr_buf to print candidate");
return PJ_EBUG;
}
value.ptr = attr_buf;
attr = pjmedia_sdp_attr_create(sdp_pool,
STR_CANDIDATE.ptr,
&value);
pjmedia_sdp_attr_add(&m->attr_count, m->attr, attr);
}
}
} else {
/* ICE has failed, application should have terminated this call */
}
/* Removing a=rtcp line when there is only one component. */
if (comp_cnt == 1) {
attr = pjmedia_sdp_attr_find(m->attr_count, m->attr, &STR_RTCP, NULL);
if (attr)
pjmedia_sdp_attr_remove(&m->attr_count, m->attr, attr);
}
return PJ_SUCCESS;
}
