void Sdp::addZrtpAttribute(pjmedia_sdp_media* media, std::string hash)
{
/* Format: ":version value" */
std::string val = "1.10 " + hash;
pj_str_t value = { (char*)val.c_str(), val.size() };
pjmedia_sdp_attr *attr = pjmedia_sdp_attr_create(memPool_, "zrtp-hash", &value);
if (pjmedia_sdp_media_add_attr(media, attr) != PJ_SUCCESS)
throw SdpException("Could not add zrtp attribute to media");
}
void Sdp::addSdesAttribute(const std::vector<std::string>& crypto)
{
for (std::vector<std::string>::const_iterator iter = crypto.begin();
iter != crypto.end(); ++iter) {
pj_str_t val = { (char*)(*iter).c_str(), (*iter).size() };
pjmedia_sdp_attr *attr = pjmedia_sdp_attr_create(memPool_, "crypto", &val);
for (unsigned i = 0; i < localSession_->media_count; i++)
if (pjmedia_sdp_media_add_attr(localSession_->media[i], attr) != PJ_SUCCESS)
throw SdpException("Could not add sdes attribute to media");
}
}
/*
* Apply direction attribute in session to all media.
*/
static void apply_media_direction(pjmedia_sdp_session *sdp)
{
pjmedia_sdp_attr *dir_attr = NULL;
unsigned i;
const pj_str_t inactive = { "inactive", 8 };
const pj_str_t sendonly = { "sendonly", 8 };
const pj_str_t recvonly = { "recvonly", 8 };
const pj_str_t sendrecv = { "sendrecv", 8 };
/* Find direction attribute in session, don't need to find default
* direction "sendrecv".
*/
for (i = 0; i < sdp->attr_count && !dir_attr; ++i) {
if (!pj_strcmp(&sdp->attr[i]->name, &sendonly) ||
!pj_strcmp(&sdp->attr[i]->name, &recvonly) ||
!pj_strcmp(&sdp->attr[i]->name, &inactive))
{
dir_attr = sdp->attr[i];
}
}
/* Found the direction attribute */
if (dir_attr) {
/* Remove the direction attribute in session */
pjmedia_sdp_attr_remove(&sdp->attr_count, sdp->attr, dir_attr);
/* Apply the direction attribute to all media, but not overriding it
* if media already has direction attribute.
*/
for (i = 0; i < sdp->media_count; ++i) {
pjmedia_sdp_media *m;
unsigned j;
/* Find direction attribute in this media */
m = sdp->media[i];
for (j = 0; j < m->attr_count; ++j) {
if (!pj_strcmp(&m->attr[j]->name, &sendrecv) ||
!pj_strcmp(&m->attr[j]->name, &sendonly) ||
!pj_strcmp(&m->attr[j]->name, &recvonly) ||
!pj_strcmp(&m->attr[j]->name, &inactive))
{
break;
}
}
/* Not found, apply direction attribute from session */
if (j == m->attr_count)
pjmedia_sdp_media_add_attr(m, dir_attr);
}
}
}
/* Internal function to apply symmetric PT for the local answer. */
static void apply_answer_symmetric_pt(pj_pool_t *pool,
pjmedia_sdp_media *answer,
unsigned pt_cnt,
const pj_str_t pt_offer[],
const pj_str_t pt_answer[])
{
pjmedia_sdp_attr *a_tmp[PJMEDIA_MAX_SDP_ATTR];
unsigned i, a_tmp_cnt = 0;
/* Rewrite the payload types in the answer if different to
* the ones in the offer.
*/
for (i = 0; i < pt_cnt; ++i) {
pjmedia_sdp_attr *a;
/* Skip if the PTs are the same already, e.g: static PT. */
if (pj_strcmp(&pt_answer[i], &pt_offer[i]) == 0)
continue;
/* Rewrite payload type in the answer to match to the offer */
pj_strdup(pool, &answer->desc.fmt[i], &pt_offer[i]);
/* Also update payload type in rtpmap */
a = pjmedia_sdp_media_find_attr2(answer, "rtpmap", &pt_answer[i]);
if (a) {
rewrite_pt(pool, &a->value, &pt_answer[i], &pt_offer[i]);
/* Temporarily remove the attribute in case the new payload
* type is being used by another format in the media.
*/
pjmedia_sdp_media_remove_attr(answer, a);
a_tmp[a_tmp_cnt++] = a;
}
/* Also update payload type in fmtp */
a = pjmedia_sdp_media_find_attr2(answer, "fmtp", &pt_answer[i]);
if (a) {
rewrite_pt(pool, &a->value, &pt_answer[i], &pt_offer[i]);
/* Temporarily remove the attribute in case the new payload
* type is being used by another format in the media.
*/
pjmedia_sdp_media_remove_attr(answer, a);
a_tmp[a_tmp_cnt++] = a;
}
}
/* Return back 'rtpmap' and 'fmtp' attributes */
for (i = 0; i < a_tmp_cnt; ++i)
pjmedia_sdp_media_add_attr(answer, a_tmp[i]);
}
/* Update media direction based on peer's media direction */
static void update_media_direction(pj_pool_t *pool,
const pjmedia_sdp_media *remote,
pjmedia_sdp_media *local)
{
pjmedia_dir old_dir = PJMEDIA_DIR_ENCODING_DECODING,
new_dir;
/* Get the media direction of local SDP */
if (pjmedia_sdp_media_find_attr2(local, "sendonly", NULL))
old_dir = PJMEDIA_DIR_ENCODING;
else if (pjmedia_sdp_media_find_attr2(local, "recvonly", NULL))
old_dir = PJMEDIA_DIR_DECODING;
else if (pjmedia_sdp_media_find_attr2(local, "inactive", NULL))
old_dir = PJMEDIA_DIR_NONE;
new_dir = old_dir;
/* Adjust local media direction based on remote media direction */
if (pjmedia_sdp_media_find_attr2(remote, "inactive", NULL) != NULL) {
/* If remote has "a=inactive", then local is inactive too */
new_dir = PJMEDIA_DIR_NONE;
} else if(pjmedia_sdp_media_find_attr2(remote, "sendonly", NULL) != NULL) {
/* If remote has "a=sendonly", then set local to "recvonly" if
* it is currently "sendrecv". Otherwise if local is NOT "recvonly",
* then set local direction to "inactive".
*/
switch (old_dir) {
case PJMEDIA_DIR_ENCODING_DECODING:
new_dir = PJMEDIA_DIR_DECODING;
break;
case PJMEDIA_DIR_DECODING:
/* No change */
break;
default:
new_dir = PJMEDIA_DIR_NONE;
break;
}
} else if(pjmedia_sdp_media_find_attr2(remote, "recvonly", NULL) != NULL) {
/* If remote has "a=recvonly", then set local to "sendonly" if
* it is currently "sendrecv". Otherwise if local is NOT "sendonly",
* then set local direction to "inactive"
*/
switch (old_dir) {
case PJMEDIA_DIR_ENCODING_DECODING:
new_dir = PJMEDIA_DIR_ENCODING;
break;
case PJMEDIA_DIR_ENCODING:
/* No change */
break;
default:
new_dir = PJMEDIA_DIR_NONE;
break;
}
} else {
/* Remote indicates "sendrecv" capability. No change to local
* direction
*/
}
if (new_dir != old_dir) {
pjmedia_sdp_attr *a = NULL;
remove_all_media_directions(local);
switch (new_dir) {
case PJMEDIA_DIR_NONE:
a = pjmedia_sdp_attr_create(pool, "inactive", NULL);
break;
case PJMEDIA_DIR_ENCODING:
a = pjmedia_sdp_attr_create(pool, "sendonly", NULL);
break;
case PJMEDIA_DIR_DECODING:
a = pjmedia_sdp_attr_create(pool, "recvonly", NULL);
break;
default:
/* sendrecv */
break;
}
if (a) {
pjmedia_sdp_media_add_attr(local, a);
}
}
}
/*
* Parse SDP message.
*/
PJ_DEF(pj_status_t) pjmedia_sdp_parse( pj_pool_t *pool,
char *buf, pj_size_t len,
pjmedia_sdp_session **p_sdp)
{
pj_scanner scanner;
pjmedia_sdp_session *session;
pjmedia_sdp_media *media = NULL;
pjmedia_sdp_attr *attr;
pjmedia_sdp_conn *conn;
pjmedia_sdp_bandw *bandw;
pj_str_t dummy;
int cur_name = 254;
parse_context ctx;
PJ_USE_EXCEPTION;
ctx.last_error = PJ_SUCCESS;
init_sdp_parser();
pj_scan_init(&scanner, buf, len, 0, &on_scanner_error);
session = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_session);
PJ_ASSERT_RETURN(session != NULL, PJ_ENOMEM);
/* Ignore leading newlines */
while (*scanner.curptr=='\r' || *scanner.curptr=='\n')
pj_scan_get_char(&scanner);
PJ_TRY {
while (!pj_scan_is_eof(&scanner)) {
cur_name = *scanner.curptr;
switch (cur_name) {
case 'a':
attr = parse_attr(pool, &scanner, &ctx);
if (attr) {
if (media) {
if (media->attr_count < PJMEDIA_MAX_SDP_ATTR)
pjmedia_sdp_media_add_attr(media, attr);
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding media attribute, "
"attribute is ignored"));
} else {
if (session->attr_count < PJMEDIA_MAX_SDP_ATTR)
pjmedia_sdp_session_add_attr(session, attr);
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding session attribute"
", attribute is ignored"));
}
}
break;
case 'o':
parse_origin(&scanner, session, &ctx);
break;
case 's':
parse_generic_line(&scanner, &session->name, &ctx);
break;
case 'c':
conn = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_conn);
parse_connection_info(&scanner, conn, &ctx);
if (media) {
media->conn = conn;
} else {
session->conn = conn;
}
break;
case 't':
parse_time(&scanner, session, &ctx);
break;
case 'm':
media = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_media);
parse_media(&scanner, media, &ctx);
if (session->media_count < PJMEDIA_MAX_SDP_MEDIA)
session->media[ session->media_count++ ] = media;
else
PJ_PERROR(2,(THIS_FILE, PJ_ETOOMANY,
"Error adding media, media is ignored"));
break;
case 'v':
parse_version(&scanner, &ctx);
break;
case 13:
case 10:
pj_scan_get_char(&scanner);
/* Allow empty newlines at the end of the message */
while (!pj_scan_is_eof(&scanner)) {
if (*scanner.curptr != 13 && *scanner.curptr != 10) {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
pj_scan_get_char(&scanner);
}
break;
case 'b':
bandw = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_bandw);
parse_bandwidth_info(&scanner, bandw, &ctx);
if (media) {
if (media->bandw_count < PJMEDIA_MAX_SDP_BANDW)
media->bandw[media->bandw_count++] = bandw;
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding media bandwidth "
"info, info is ignored"));
} else {
if (session->bandw_count < PJMEDIA_MAX_SDP_BANDW)
session->bandw[session->bandw_count++] = bandw;
else
PJ_PERROR(2, (THIS_FILE, PJ_ETOOMANY,
"Error adding session bandwidth "
"info, info is ignored"));
}
break;
default:
if (cur_name >= 'a' && cur_name <= 'z')
parse_generic_line(&scanner, &dummy, &ctx);
else {
ctx.last_error = PJMEDIA_SDP_EINSDP;
on_scanner_error(&scanner);
}
break;
}
}
ctx.last_error = PJ_SUCCESS;
}
PJ_CATCH_ANY {
char errmsg[PJ_ERR_MSG_SIZE];
pj_strerror(ctx.last_error, errmsg, sizeof(errmsg));
PJ_LOG(4, (THIS_FILE, "Error parsing SDP in line %d col %d: %s",
scanner.line, pj_scan_get_col(&scanner),
errmsg));
session = NULL;
pj_assert(ctx.last_error != PJ_SUCCESS);
}
PJ_END;
pj_scan_fini(&scanner);
if (session)
apply_media_direction(session);
*p_sdp = session;
return ctx.last_error;
}
void Sdp::addAttributeToLocalAudioMedia(const char *attr)
{
if (localSession_)
pjmedia_sdp_media_add_attr(localSession_->media[0], pjmedia_sdp_attr_create(memPool_, attr, NULL));
}
