The latest Release candidate fails to create RTP streams when IPv6 is not available. Due to the changes made in September the ast_sockaddr structure passed around to create these streams is always of AF_INET6 type, causing failure when used for IPv4. This patch adds a utility function to check for availability of IPv6 and applies such check at startup to determine how to create the ast_sockaddr structures. ASTERISK-26617 #close Change-Id: I627a4e91795e821111e1cda523f083a40d0e0c3e
1559 lines
51 KiB
C
1559 lines
51 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
*
|
|
* Joshua Colp <jcolp@digium.com>
|
|
* Kevin Harwell <kharwell@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*! \file
|
|
*
|
|
* \author Joshua Colp <jcolp@digium.com>
|
|
*
|
|
* \brief SIP SDP media stream handling
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<depend>pjproject</depend>
|
|
<depend>res_pjsip</depend>
|
|
<depend>res_pjsip_session</depend>
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
#include "asterisk.h"
|
|
|
|
#include <pjsip.h>
|
|
#include <pjsip_ua.h>
|
|
#include <pjmedia.h>
|
|
#include <pjlib.h>
|
|
|
|
#include "asterisk/utils.h"
|
|
#include "asterisk/module.h"
|
|
#include "asterisk/format.h"
|
|
#include "asterisk/format_cap.h"
|
|
#include "asterisk/rtp_engine.h"
|
|
#include "asterisk/netsock2.h"
|
|
#include "asterisk/channel.h"
|
|
#include "asterisk/causes.h"
|
|
#include "asterisk/sched.h"
|
|
#include "asterisk/acl.h"
|
|
#include "asterisk/sdp_srtp.h"
|
|
#include "asterisk/dsp.h"
|
|
#include "asterisk/linkedlists.h" /* for AST_LIST_NEXT */
|
|
|
|
#include "asterisk/res_pjsip.h"
|
|
#include "asterisk/res_pjsip_session.h"
|
|
|
|
/*! \brief Scheduler for RTCP purposes */
|
|
static struct ast_sched_context *sched;
|
|
|
|
/*! \brief Address for RTP */
|
|
static struct ast_sockaddr address_rtp;
|
|
|
|
static const char STR_AUDIO[] = "audio";
|
|
static const int FD_AUDIO = 0;
|
|
|
|
static const char STR_VIDEO[] = "video";
|
|
static const int FD_VIDEO = 2;
|
|
|
|
/*! \brief Retrieves an ast_format_type based on the given stream_type */
|
|
static enum ast_media_type stream_to_media_type(const char *stream_type)
|
|
{
|
|
if (!strcasecmp(stream_type, STR_AUDIO)) {
|
|
return AST_MEDIA_TYPE_AUDIO;
|
|
} else if (!strcasecmp(stream_type, STR_VIDEO)) {
|
|
return AST_MEDIA_TYPE_VIDEO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Get the starting descriptor for a media type */
|
|
static int media_type_to_fdno(enum ast_media_type media_type)
|
|
{
|
|
switch (media_type) {
|
|
case AST_MEDIA_TYPE_AUDIO: return FD_AUDIO;
|
|
case AST_MEDIA_TYPE_VIDEO: return FD_VIDEO;
|
|
case AST_MEDIA_TYPE_TEXT:
|
|
case AST_MEDIA_TYPE_UNKNOWN:
|
|
case AST_MEDIA_TYPE_IMAGE: break;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*! \brief Remove all other cap types but the one given */
|
|
static void format_cap_only_type(struct ast_format_cap *caps, enum ast_media_type media_type)
|
|
{
|
|
int i = 0;
|
|
while (i <= AST_MEDIA_TYPE_TEXT) {
|
|
if (i != media_type && i != AST_MEDIA_TYPE_UNKNOWN) {
|
|
ast_format_cap_remove_by_type(caps, i);
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
static int send_keepalive(const void *data)
|
|
{
|
|
struct ast_sip_session_media *session_media = (struct ast_sip_session_media *) data;
|
|
struct ast_rtp_instance *rtp = session_media->rtp;
|
|
int keepalive;
|
|
time_t interval;
|
|
int send_keepalive;
|
|
|
|
if (!rtp) {
|
|
return 0;
|
|
}
|
|
|
|
keepalive = ast_rtp_instance_get_keepalive(rtp);
|
|
|
|
if (!ast_sockaddr_isnull(&session_media->direct_media_addr)) {
|
|
ast_debug(3, "Not sending RTP keepalive on RTP instance %p since direct media is in use\n", rtp);
|
|
return keepalive * 1000;
|
|
}
|
|
|
|
interval = time(NULL) - ast_rtp_instance_get_last_tx(rtp);
|
|
send_keepalive = interval >= keepalive;
|
|
|
|
ast_debug(3, "It has been %d seconds since RTP was last sent on instance %p. %sending keepalive\n",
|
|
(int) interval, rtp, send_keepalive ? "S" : "Not s");
|
|
|
|
if (send_keepalive) {
|
|
ast_rtp_instance_sendcng(rtp, 0);
|
|
return keepalive * 1000;
|
|
}
|
|
|
|
return (keepalive - interval) * 1000;
|
|
}
|
|
|
|
/*! \brief Check whether RTP is being received or not */
|
|
static int rtp_check_timeout(const void *data)
|
|
{
|
|
struct ast_sip_session_media *session_media = (struct ast_sip_session_media *)data;
|
|
struct ast_rtp_instance *rtp = session_media->rtp;
|
|
int elapsed;
|
|
struct ast_channel *chan;
|
|
|
|
if (!rtp) {
|
|
return 0;
|
|
}
|
|
|
|
elapsed = time(NULL) - ast_rtp_instance_get_last_rx(rtp);
|
|
if (elapsed < ast_rtp_instance_get_timeout(rtp)) {
|
|
return (ast_rtp_instance_get_timeout(rtp) - elapsed) * 1000;
|
|
}
|
|
|
|
chan = ast_channel_get_by_name(ast_rtp_instance_get_channel_id(rtp));
|
|
if (!chan) {
|
|
return 0;
|
|
}
|
|
|
|
ast_log(LOG_NOTICE, "Disconnecting channel '%s' for lack of RTP activity in %d seconds\n",
|
|
ast_channel_name(chan), elapsed);
|
|
|
|
ast_softhangup(chan, AST_SOFTHANGUP_DEV);
|
|
ast_channel_unref(chan);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Internal function which creates an RTP instance */
|
|
static int create_rtp(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
|
|
{
|
|
struct ast_rtp_engine_ice *ice;
|
|
struct ast_sockaddr temp_media_address;
|
|
struct ast_sockaddr *media_address = &address_rtp;
|
|
|
|
if (session->endpoint->media.bind_rtp_to_media_address && !ast_strlen_zero(session->endpoint->media.address)) {
|
|
ast_sockaddr_parse(&temp_media_address, session->endpoint->media.address, 0);
|
|
media_address = &temp_media_address;
|
|
}
|
|
|
|
if (!(session_media->rtp = ast_rtp_instance_new(session->endpoint->media.rtp.engine, sched, media_address, NULL))) {
|
|
ast_log(LOG_ERROR, "Unable to create RTP instance using RTP engine '%s'\n", session->endpoint->media.rtp.engine);
|
|
return -1;
|
|
}
|
|
|
|
ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_RTCP, 1);
|
|
ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_NAT, session->endpoint->media.rtp.symmetric);
|
|
|
|
if (!session->endpoint->media.rtp.ice_support && (ice = ast_rtp_instance_get_ice(session_media->rtp))) {
|
|
ice->stop(session_media->rtp);
|
|
}
|
|
|
|
if (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) {
|
|
ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_RFC2833);
|
|
ast_rtp_instance_set_prop(session_media->rtp, AST_RTP_PROPERTY_DTMF, 1);
|
|
} else if (session->endpoint->dtmf == AST_SIP_DTMF_INBAND) {
|
|
ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
|
|
}
|
|
|
|
if (!strcmp(session_media->stream_type, STR_AUDIO) &&
|
|
(session->endpoint->media.tos_audio || session->endpoint->media.cos_video)) {
|
|
ast_rtp_instance_set_qos(session_media->rtp, session->endpoint->media.tos_audio,
|
|
session->endpoint->media.cos_audio, "SIP RTP Audio");
|
|
} else if (!strcmp(session_media->stream_type, STR_VIDEO) &&
|
|
(session->endpoint->media.tos_video || session->endpoint->media.cos_video)) {
|
|
ast_rtp_instance_set_qos(session_media->rtp, session->endpoint->media.tos_video,
|
|
session->endpoint->media.cos_video, "SIP RTP Video");
|
|
}
|
|
|
|
ast_rtp_instance_set_last_rx(session_media->rtp, time(NULL));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void get_codecs(struct ast_sip_session *session, const struct pjmedia_sdp_media *stream, struct ast_rtp_codecs *codecs,
|
|
struct ast_sip_session_media *session_media)
|
|
{
|
|
pjmedia_sdp_attr *attr;
|
|
pjmedia_sdp_rtpmap *rtpmap;
|
|
pjmedia_sdp_fmtp fmtp;
|
|
struct ast_format *format;
|
|
int i, num = 0, tel_event = 0;
|
|
char name[256];
|
|
char media[20];
|
|
char fmt_param[256];
|
|
enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
|
|
AST_RTP_OPT_G726_NONSTANDARD : 0;
|
|
|
|
ast_rtp_codecs_payloads_initialize(codecs);
|
|
|
|
/* Iterate through provided formats */
|
|
for (i = 0; i < stream->desc.fmt_count; ++i) {
|
|
/* The payload is kept as a string for things like t38 but for video it is always numerical */
|
|
ast_rtp_codecs_payloads_set_m_type(codecs, NULL, pj_strtoul(&stream->desc.fmt[i]));
|
|
/* Look for the optional rtpmap attribute */
|
|
if (!(attr = pjmedia_sdp_media_find_attr2(stream, "rtpmap", &stream->desc.fmt[i]))) {
|
|
continue;
|
|
}
|
|
|
|
/* Interpret the attribute as an rtpmap */
|
|
if ((pjmedia_sdp_attr_to_rtpmap(session->inv_session->pool_prov, attr, &rtpmap)) != PJ_SUCCESS) {
|
|
continue;
|
|
}
|
|
|
|
ast_copy_pj_str(name, &rtpmap->enc_name, sizeof(name));
|
|
if (strcmp(name, "telephone-event") == 0) {
|
|
tel_event++;
|
|
}
|
|
|
|
ast_copy_pj_str(media, (pj_str_t*)&stream->desc.media, sizeof(media));
|
|
ast_rtp_codecs_payloads_set_rtpmap_type_rate(codecs, NULL,
|
|
pj_strtoul(&stream->desc.fmt[i]), media, name, options, rtpmap->clock_rate);
|
|
/* Look for an optional associated fmtp attribute */
|
|
if (!(attr = pjmedia_sdp_media_find_attr2(stream, "fmtp", &rtpmap->pt))) {
|
|
continue;
|
|
}
|
|
|
|
if ((pjmedia_sdp_attr_get_fmtp(attr, &fmtp)) == PJ_SUCCESS) {
|
|
ast_copy_pj_str(fmt_param, &fmtp.fmt, sizeof(fmt_param));
|
|
if (sscanf(fmt_param, "%30d", &num) != 1) {
|
|
continue;
|
|
}
|
|
|
|
if ((format = ast_rtp_codecs_get_payload_format(codecs, num))) {
|
|
struct ast_format *format_parsed;
|
|
|
|
ast_copy_pj_str(fmt_param, &fmtp.fmt_param, sizeof(fmt_param));
|
|
|
|
format_parsed = ast_format_parse_sdp_fmtp(format, fmt_param);
|
|
if (format_parsed) {
|
|
ast_rtp_codecs_payload_replace_format(codecs, num, format_parsed);
|
|
ao2_ref(format_parsed, -1);
|
|
}
|
|
|
|
ao2_ref(format, -1);
|
|
}
|
|
}
|
|
}
|
|
if (!tel_event && (session->endpoint->dtmf == AST_SIP_DTMF_AUTO)) {
|
|
ast_rtp_instance_dtmf_mode_set(session_media->rtp, AST_RTP_DTMF_MODE_INBAND);
|
|
}
|
|
/* Get the packetization, if it exists */
|
|
if ((attr = pjmedia_sdp_media_find_attr2(stream, "ptime", NULL))) {
|
|
unsigned long framing = pj_strtoul(pj_strltrim(&attr->value));
|
|
if (framing && session->endpoint->media.rtp.use_ptime) {
|
|
ast_rtp_codecs_set_framing(codecs, framing);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int set_caps(struct ast_sip_session *session,
|
|
struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_media *stream,
|
|
int is_offer)
|
|
{
|
|
RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_format_cap *, peer, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_format_cap *, joint, NULL, ao2_cleanup);
|
|
enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
|
|
struct ast_rtp_codecs codecs = AST_RTP_CODECS_NULL_INIT;
|
|
int fmts = 0;
|
|
int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
|
|
ast_format_cap_count(session->direct_media_cap);
|
|
int dsp_features = 0;
|
|
|
|
if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
|
|
!(peer = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT)) ||
|
|
!(joint = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
|
ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
|
|
return -1;
|
|
}
|
|
|
|
/* get the endpoint capabilities */
|
|
if (direct_media_enabled) {
|
|
ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
|
|
format_cap_only_type(caps, media_type);
|
|
} else {
|
|
ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
|
|
}
|
|
|
|
/* get the capabilities on the peer */
|
|
get_codecs(session, stream, &codecs, session_media);
|
|
ast_rtp_codecs_payload_formats(&codecs, peer, &fmts);
|
|
|
|
/* get the joint capabilities between peer and endpoint */
|
|
ast_format_cap_get_compatible(caps, peer, joint);
|
|
if (!ast_format_cap_count(joint)) {
|
|
struct ast_str *usbuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
|
|
struct ast_str *thembuf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
|
|
|
|
ast_rtp_codecs_payloads_destroy(&codecs);
|
|
ast_log(LOG_NOTICE, "No joint capabilities for '%s' media stream between our configuration(%s) and incoming SDP(%s)\n",
|
|
session_media->stream_type,
|
|
ast_format_cap_get_names(caps, &usbuf),
|
|
ast_format_cap_get_names(peer, &thembuf));
|
|
return -1;
|
|
}
|
|
|
|
if (is_offer) {
|
|
/*
|
|
* Setup rx payload type mapping to prefer the mapping
|
|
* from the peer that the RFC says we SHOULD use.
|
|
*/
|
|
ast_rtp_codecs_payloads_xover(&codecs, &codecs, NULL);
|
|
}
|
|
ast_rtp_codecs_payloads_copy(&codecs, ast_rtp_instance_get_codecs(session_media->rtp),
|
|
session_media->rtp);
|
|
|
|
ast_format_cap_append_from_cap(session->req_caps, joint, AST_MEDIA_TYPE_UNKNOWN);
|
|
|
|
if (session->channel) {
|
|
ast_channel_lock(session->channel);
|
|
ast_format_cap_remove_by_type(caps, AST_MEDIA_TYPE_UNKNOWN);
|
|
ast_format_cap_append_from_cap(caps, ast_channel_nativeformats(session->channel),
|
|
AST_MEDIA_TYPE_UNKNOWN);
|
|
ast_format_cap_remove_by_type(caps, media_type);
|
|
if (session->endpoint->preferred_codec_only){
|
|
struct ast_format *preferred_fmt = ast_format_cap_get_format(joint, 0);
|
|
ast_format_cap_append(caps, preferred_fmt, 0);
|
|
ao2_ref(preferred_fmt, -1);
|
|
} else {
|
|
ast_format_cap_append_from_cap(caps, joint, media_type);
|
|
}
|
|
/*
|
|
* Apply the new formats to the channel, potentially changing
|
|
* raw read/write formats and translation path while doing so.
|
|
*/
|
|
ast_channel_nativeformats_set(session->channel, caps);
|
|
if (media_type == AST_MEDIA_TYPE_AUDIO) {
|
|
ast_set_read_format(session->channel, ast_channel_readformat(session->channel));
|
|
ast_set_write_format(session->channel, ast_channel_writeformat(session->channel));
|
|
}
|
|
if ((session->endpoint->dtmf == AST_SIP_DTMF_AUTO)
|
|
&& (ast_rtp_instance_dtmf_mode_get(session_media->rtp) == AST_RTP_DTMF_MODE_RFC2833)
|
|
&& (session->dsp)) {
|
|
dsp_features = ast_dsp_get_features(session->dsp);
|
|
dsp_features &= ~DSP_FEATURE_DIGIT_DETECT;
|
|
if (dsp_features) {
|
|
ast_dsp_set_features(session->dsp, dsp_features);
|
|
} else {
|
|
ast_dsp_free(session->dsp);
|
|
session->dsp = NULL;
|
|
}
|
|
}
|
|
|
|
if (ast_channel_is_bridged(session->channel)) {
|
|
ast_channel_set_unbridged_nolock(session->channel, 1);
|
|
}
|
|
|
|
ast_channel_unlock(session->channel);
|
|
}
|
|
|
|
ast_rtp_codecs_payloads_destroy(&codecs);
|
|
return 0;
|
|
}
|
|
|
|
static pjmedia_sdp_attr* generate_rtpmap_attr(struct ast_sip_session *session, pjmedia_sdp_media *media, pj_pool_t *pool,
|
|
int rtp_code, int asterisk_format, struct ast_format *format, int code)
|
|
{
|
|
pjmedia_sdp_rtpmap rtpmap;
|
|
pjmedia_sdp_attr *attr = NULL;
|
|
char tmp[64];
|
|
enum ast_rtp_options options = session->endpoint->media.g726_non_standard ?
|
|
AST_RTP_OPT_G726_NONSTANDARD : 0;
|
|
|
|
snprintf(tmp, sizeof(tmp), "%d", rtp_code);
|
|
pj_strdup2(pool, &media->desc.fmt[media->desc.fmt_count++], tmp);
|
|
rtpmap.pt = media->desc.fmt[media->desc.fmt_count - 1];
|
|
rtpmap.clock_rate = ast_rtp_lookup_sample_rate2(asterisk_format, format, code);
|
|
pj_strdup2(pool, &rtpmap.enc_name, ast_rtp_lookup_mime_subtype2(asterisk_format, format, code, options));
|
|
if (!pj_stricmp2(&rtpmap.enc_name, "opus")) {
|
|
pj_cstr(&rtpmap.param, "2");
|
|
} else {
|
|
pj_cstr(&rtpmap.param, NULL);
|
|
}
|
|
|
|
pjmedia_sdp_rtpmap_to_attr(pool, &rtpmap, &attr);
|
|
|
|
return attr;
|
|
}
|
|
|
|
static pjmedia_sdp_attr* generate_fmtp_attr(pj_pool_t *pool, struct ast_format *format, int rtp_code)
|
|
{
|
|
struct ast_str *fmtp0 = ast_str_alloca(256);
|
|
pj_str_t fmtp1;
|
|
pjmedia_sdp_attr *attr = NULL;
|
|
char *tmp;
|
|
|
|
ast_format_generate_sdp_fmtp(format, rtp_code, &fmtp0);
|
|
if (ast_str_strlen(fmtp0)) {
|
|
tmp = ast_str_buffer(fmtp0) + ast_str_strlen(fmtp0) - 1;
|
|
/* remove any carriage return line feeds */
|
|
while (*tmp == '\r' || *tmp == '\n') --tmp;
|
|
*++tmp = '\0';
|
|
/* ast...generate gives us everything, just need value */
|
|
tmp = strchr(ast_str_buffer(fmtp0), ':');
|
|
if (tmp && tmp[1] != '\0') {
|
|
fmtp1 = pj_str(tmp + 1);
|
|
} else {
|
|
fmtp1 = pj_str(ast_str_buffer(fmtp0));
|
|
}
|
|
attr = pjmedia_sdp_attr_create(pool, "fmtp", &fmtp1);
|
|
}
|
|
return attr;
|
|
}
|
|
|
|
/*! \brief Function which adds ICE attributes to a media stream */
|
|
static void add_ice_to_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media, pj_pool_t *pool, pjmedia_sdp_media *media)
|
|
{
|
|
struct ast_rtp_engine_ice *ice;
|
|
struct ao2_container *candidates;
|
|
const char *username, *password;
|
|
pj_str_t stmp;
|
|
pjmedia_sdp_attr *attr;
|
|
struct ao2_iterator it_candidates;
|
|
struct ast_rtp_engine_ice_candidate *candidate;
|
|
|
|
if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp)) ||
|
|
!(candidates = ice->get_local_candidates(session_media->rtp))) {
|
|
return;
|
|
}
|
|
|
|
if ((username = ice->get_ufrag(session_media->rtp))) {
|
|
attr = pjmedia_sdp_attr_create(pool, "ice-ufrag", pj_cstr(&stmp, username));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
if ((password = ice->get_password(session_media->rtp))) {
|
|
attr = pjmedia_sdp_attr_create(pool, "ice-pwd", pj_cstr(&stmp, password));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
it_candidates = ao2_iterator_init(candidates, 0);
|
|
for (; (candidate = ao2_iterator_next(&it_candidates)); ao2_ref(candidate, -1)) {
|
|
struct ast_str *attr_candidate = ast_str_create(128);
|
|
|
|
ast_str_set(&attr_candidate, -1, "%s %u %s %d %s ", candidate->foundation, candidate->id, candidate->transport,
|
|
candidate->priority, ast_sockaddr_stringify_addr_remote(&candidate->address));
|
|
ast_str_append(&attr_candidate, -1, "%s typ ", ast_sockaddr_stringify_port(&candidate->address));
|
|
|
|
switch (candidate->type) {
|
|
case AST_RTP_ICE_CANDIDATE_TYPE_HOST:
|
|
ast_str_append(&attr_candidate, -1, "host");
|
|
break;
|
|
case AST_RTP_ICE_CANDIDATE_TYPE_SRFLX:
|
|
ast_str_append(&attr_candidate, -1, "srflx");
|
|
break;
|
|
case AST_RTP_ICE_CANDIDATE_TYPE_RELAYED:
|
|
ast_str_append(&attr_candidate, -1, "relay");
|
|
break;
|
|
}
|
|
|
|
if (!ast_sockaddr_isnull(&candidate->relay_address)) {
|
|
ast_str_append(&attr_candidate, -1, " raddr %s rport", ast_sockaddr_stringify_addr_remote(&candidate->relay_address));
|
|
ast_str_append(&attr_candidate, -1, " %s", ast_sockaddr_stringify_port(&candidate->relay_address));
|
|
}
|
|
|
|
attr = pjmedia_sdp_attr_create(pool, "candidate", pj_cstr(&stmp, ast_str_buffer(attr_candidate)));
|
|
media->attr[media->attr_count++] = attr;
|
|
|
|
ast_free(attr_candidate);
|
|
}
|
|
|
|
ao2_iterator_destroy(&it_candidates);
|
|
ao2_ref(candidates, -1);
|
|
}
|
|
|
|
/*! \brief Function which processes ICE attributes in an audio stream */
|
|
static void process_ice_attributes(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
|
|
{
|
|
struct ast_rtp_engine_ice *ice;
|
|
const pjmedia_sdp_attr *attr;
|
|
char attr_value[256];
|
|
unsigned int attr_i;
|
|
|
|
/* If ICE support is not enabled or available exit early */
|
|
if (!session->endpoint->media.rtp.ice_support || !(ice = ast_rtp_instance_get_ice(session_media->rtp))) {
|
|
return;
|
|
}
|
|
|
|
attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-ufrag", NULL);
|
|
if (!attr) {
|
|
attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-ufrag", NULL);
|
|
}
|
|
if (attr) {
|
|
ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
|
|
ice->set_authentication(session_media->rtp, attr_value, NULL);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
attr = pjmedia_sdp_media_find_attr2(remote_stream, "ice-pwd", NULL);
|
|
if (!attr) {
|
|
attr = pjmedia_sdp_attr_find2(remote->attr_count, remote->attr, "ice-pwd", NULL);
|
|
}
|
|
if (attr) {
|
|
ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
|
|
ice->set_authentication(session_media->rtp, NULL, attr_value);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
if (pjmedia_sdp_media_find_attr2(remote_stream, "ice-lite", NULL)) {
|
|
ice->ice_lite(session_media->rtp);
|
|
}
|
|
|
|
/* Find all of the candidates */
|
|
for (attr_i = 0; attr_i < remote_stream->attr_count; ++attr_i) {
|
|
char foundation[32], transport[32], address[PJ_INET6_ADDRSTRLEN + 1], cand_type[6], relay_address[PJ_INET6_ADDRSTRLEN + 1] = "";
|
|
unsigned int port, relay_port = 0;
|
|
struct ast_rtp_engine_ice_candidate candidate = { 0, };
|
|
|
|
attr = remote_stream->attr[attr_i];
|
|
|
|
/* If this is not a candidate line skip it */
|
|
if (pj_strcmp2(&attr->name, "candidate")) {
|
|
continue;
|
|
}
|
|
|
|
ast_copy_pj_str(attr_value, (pj_str_t*)&attr->value, sizeof(attr_value));
|
|
|
|
if (sscanf(attr_value, "%31s %30u %31s %30u %46s %30u typ %5s %*s %23s %*s %30u", foundation, &candidate.id, transport,
|
|
(unsigned *)&candidate.priority, address, &port, cand_type, relay_address, &relay_port) < 7) {
|
|
/* Candidate did not parse properly */
|
|
continue;
|
|
}
|
|
|
|
candidate.foundation = foundation;
|
|
candidate.transport = transport;
|
|
|
|
ast_sockaddr_parse(&candidate.address, address, PARSE_PORT_FORBID);
|
|
ast_sockaddr_set_port(&candidate.address, port);
|
|
|
|
if (!strcasecmp(cand_type, "host")) {
|
|
candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_HOST;
|
|
} else if (!strcasecmp(cand_type, "srflx")) {
|
|
candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_SRFLX;
|
|
} else if (!strcasecmp(cand_type, "relay")) {
|
|
candidate.type = AST_RTP_ICE_CANDIDATE_TYPE_RELAYED;
|
|
} else {
|
|
continue;
|
|
}
|
|
|
|
if (!ast_strlen_zero(relay_address)) {
|
|
ast_sockaddr_parse(&candidate.relay_address, relay_address, PARSE_PORT_FORBID);
|
|
}
|
|
|
|
if (relay_port) {
|
|
ast_sockaddr_set_port(&candidate.relay_address, relay_port);
|
|
}
|
|
|
|
ice->add_remote_candidate(session_media->rtp, &candidate);
|
|
}
|
|
|
|
ice->set_role(session_media->rtp, pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_TRUE ?
|
|
AST_RTP_ICE_ROLE_CONTROLLING : AST_RTP_ICE_ROLE_CONTROLLED);
|
|
ice->start(session_media->rtp);
|
|
}
|
|
|
|
/*! \brief figure out if media stream has crypto lines for sdes */
|
|
static int media_stream_has_crypto(const struct pjmedia_sdp_media *stream)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < stream->attr_count; i++) {
|
|
pjmedia_sdp_attr *attr;
|
|
|
|
/* check the stream for the required crypto attribute */
|
|
attr = stream->attr[i];
|
|
if (pj_strcmp2(&attr->name, "crypto")) {
|
|
continue;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief figure out media transport encryption type from the media transport string */
|
|
static enum ast_sip_session_media_encryption get_media_encryption_type(pj_str_t transport,
|
|
const struct pjmedia_sdp_media *stream, unsigned int *optimistic)
|
|
{
|
|
RAII_VAR(char *, transport_str, ast_strndup(transport.ptr, transport.slen), ast_free);
|
|
|
|
*optimistic = 0;
|
|
|
|
if (!transport_str) {
|
|
return AST_SIP_MEDIA_TRANSPORT_INVALID;
|
|
}
|
|
if (strstr(transport_str, "UDP/TLS")) {
|
|
return AST_SIP_MEDIA_ENCRYPT_DTLS;
|
|
} else if (strstr(transport_str, "SAVP")) {
|
|
return AST_SIP_MEDIA_ENCRYPT_SDES;
|
|
} else if (media_stream_has_crypto(stream)) {
|
|
*optimistic = 1;
|
|
return AST_SIP_MEDIA_ENCRYPT_SDES;
|
|
} else {
|
|
return AST_SIP_MEDIA_ENCRYPT_NONE;
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Checks whether the encryption offered in SDP is compatible with the endpoint's configuration
|
|
* \internal
|
|
*
|
|
* \param endpoint_encryption Media encryption configured for the endpoint
|
|
* \param stream pjmedia_sdp_media stream description
|
|
*
|
|
* \retval AST_SIP_MEDIA_TRANSPORT_INVALID on encryption mismatch
|
|
* \retval The encryption requested in the SDP
|
|
*/
|
|
static enum ast_sip_session_media_encryption check_endpoint_media_transport(
|
|
struct ast_sip_endpoint *endpoint,
|
|
const struct pjmedia_sdp_media *stream)
|
|
{
|
|
enum ast_sip_session_media_encryption incoming_encryption;
|
|
char transport_end = stream->desc.transport.ptr[stream->desc.transport.slen - 1];
|
|
unsigned int optimistic;
|
|
|
|
if ((transport_end == 'F' && !endpoint->media.rtp.use_avpf)
|
|
|| (transport_end != 'F' && endpoint->media.rtp.use_avpf)) {
|
|
return AST_SIP_MEDIA_TRANSPORT_INVALID;
|
|
}
|
|
|
|
incoming_encryption = get_media_encryption_type(stream->desc.transport, stream, &optimistic);
|
|
|
|
if (incoming_encryption == endpoint->media.rtp.encryption) {
|
|
return incoming_encryption;
|
|
}
|
|
|
|
if (endpoint->media.rtp.force_avp ||
|
|
endpoint->media.rtp.encryption_optimistic) {
|
|
return incoming_encryption;
|
|
}
|
|
|
|
/* If an optimistic offer has been made but encryption is not enabled consider it as having
|
|
* no offer of crypto at all instead of invalid so the session proceeds.
|
|
*/
|
|
if (optimistic) {
|
|
return AST_SIP_MEDIA_ENCRYPT_NONE;
|
|
}
|
|
|
|
return AST_SIP_MEDIA_TRANSPORT_INVALID;
|
|
}
|
|
|
|
static int setup_srtp(struct ast_sip_session_media *session_media)
|
|
{
|
|
if (!session_media->srtp) {
|
|
session_media->srtp = ast_sdp_srtp_alloc();
|
|
if (!session_media->srtp) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (!session_media->srtp->crypto) {
|
|
session_media->srtp->crypto = ast_sdp_crypto_alloc();
|
|
if (!session_media->srtp->crypto) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int setup_dtls_srtp(struct ast_sip_session *session,
|
|
struct ast_sip_session_media *session_media)
|
|
{
|
|
struct ast_rtp_engine_dtls *dtls;
|
|
|
|
if (!session->endpoint->media.rtp.dtls_cfg.enabled || !session_media->rtp) {
|
|
return -1;
|
|
}
|
|
|
|
dtls = ast_rtp_instance_get_dtls(session_media->rtp);
|
|
if (!dtls) {
|
|
return -1;
|
|
}
|
|
|
|
session->endpoint->media.rtp.dtls_cfg.suite = ((session->endpoint->media.rtp.srtp_tag_32) ? AST_AES_CM_128_HMAC_SHA1_32 : AST_AES_CM_128_HMAC_SHA1_80);
|
|
if (dtls->set_configuration(session_media->rtp, &session->endpoint->media.rtp.dtls_cfg)) {
|
|
ast_log(LOG_ERROR, "Attempted to set an invalid DTLS-SRTP configuration on RTP instance '%p'\n",
|
|
session_media->rtp);
|
|
return -1;
|
|
}
|
|
|
|
if (setup_srtp(session_media)) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void apply_dtls_attrib(struct ast_sip_session_media *session_media,
|
|
pjmedia_sdp_attr *attr)
|
|
{
|
|
struct ast_rtp_engine_dtls *dtls = ast_rtp_instance_get_dtls(session_media->rtp);
|
|
pj_str_t *value;
|
|
|
|
if (!attr->value.ptr) {
|
|
return;
|
|
}
|
|
|
|
value = pj_strtrim(&attr->value);
|
|
|
|
if (!pj_strcmp2(&attr->name, "setup")) {
|
|
if (!pj_stricmp2(value, "active")) {
|
|
dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTIVE);
|
|
} else if (!pj_stricmp2(value, "passive")) {
|
|
dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_PASSIVE);
|
|
} else if (!pj_stricmp2(value, "actpass")) {
|
|
dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_ACTPASS);
|
|
} else if (!pj_stricmp2(value, "holdconn")) {
|
|
dtls->set_setup(session_media->rtp, AST_RTP_DTLS_SETUP_HOLDCONN);
|
|
} else {
|
|
ast_log(LOG_WARNING, "Unsupported setup attribute value '%*s'\n", (int)value->slen, value->ptr);
|
|
}
|
|
} else if (!pj_strcmp2(&attr->name, "connection")) {
|
|
if (!pj_stricmp2(value, "new")) {
|
|
dtls->reset(session_media->rtp);
|
|
} else if (!pj_stricmp2(value, "existing")) {
|
|
/* Do nothing */
|
|
} else {
|
|
ast_log(LOG_WARNING, "Unsupported connection attribute value '%*s'\n", (int)value->slen, value->ptr);
|
|
}
|
|
} else if (!pj_strcmp2(&attr->name, "fingerprint")) {
|
|
char hash_value[256], hash[32];
|
|
char fingerprint_text[value->slen + 1];
|
|
ast_copy_pj_str(fingerprint_text, value, sizeof(fingerprint_text));
|
|
if (sscanf(fingerprint_text, "%31s %255s", hash, hash_value) == 2) {
|
|
if (!strcasecmp(hash, "sha-1")) {
|
|
dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA1, hash_value);
|
|
} else if (!strcasecmp(hash, "sha-256")) {
|
|
dtls->set_fingerprint(session_media->rtp, AST_RTP_DTLS_HASH_SHA256, hash_value);
|
|
} else {
|
|
ast_log(LOG_WARNING, "Unsupported fingerprint hash type '%s'\n",
|
|
hash);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int parse_dtls_attrib(struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_session *sdp,
|
|
const struct pjmedia_sdp_media *stream)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < sdp->attr_count; i++) {
|
|
apply_dtls_attrib(session_media, sdp->attr[i]);
|
|
}
|
|
|
|
for (i = 0; i < stream->attr_count; i++) {
|
|
apply_dtls_attrib(session_media, stream->attr[i]);
|
|
}
|
|
|
|
ast_set_flag(session_media->srtp, AST_SRTP_CRYPTO_OFFER_OK);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int setup_sdes_srtp(struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_media *stream)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < stream->attr_count; i++) {
|
|
pjmedia_sdp_attr *attr;
|
|
RAII_VAR(char *, crypto_str, NULL, ast_free);
|
|
|
|
/* check the stream for the required crypto attribute */
|
|
attr = stream->attr[i];
|
|
if (pj_strcmp2(&attr->name, "crypto")) {
|
|
continue;
|
|
}
|
|
|
|
crypto_str = ast_strndup(attr->value.ptr, attr->value.slen);
|
|
if (!crypto_str) {
|
|
return -1;
|
|
}
|
|
|
|
if (setup_srtp(session_media)) {
|
|
return -1;
|
|
}
|
|
|
|
if (!ast_sdp_crypto_process(session_media->rtp, session_media->srtp, crypto_str)) {
|
|
/* found a valid crypto attribute */
|
|
return 0;
|
|
}
|
|
|
|
ast_debug(1, "Ignoring crypto offer with unsupported parameters: %s\n", crypto_str);
|
|
}
|
|
|
|
/* no usable crypto attributes found */
|
|
return -1;
|
|
}
|
|
|
|
static int setup_media_encryption(struct ast_sip_session *session,
|
|
struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_session *sdp,
|
|
const struct pjmedia_sdp_media *stream)
|
|
{
|
|
switch (session_media->encryption) {
|
|
case AST_SIP_MEDIA_ENCRYPT_SDES:
|
|
if (setup_sdes_srtp(session_media, stream)) {
|
|
return -1;
|
|
}
|
|
break;
|
|
case AST_SIP_MEDIA_ENCRYPT_DTLS:
|
|
if (setup_dtls_srtp(session, session_media)) {
|
|
return -1;
|
|
}
|
|
if (parse_dtls_attrib(session_media, sdp, stream)) {
|
|
return -1;
|
|
}
|
|
break;
|
|
case AST_SIP_MEDIA_TRANSPORT_INVALID:
|
|
case AST_SIP_MEDIA_ENCRYPT_NONE:
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Function which negotiates an incoming media stream */
|
|
static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
|
|
{
|
|
char host[NI_MAXHOST];
|
|
RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
|
|
enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
|
|
enum ast_sip_session_media_encryption encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
|
|
int res;
|
|
|
|
/* If port is 0, ignore this media stream */
|
|
if (!stream->desc.port) {
|
|
ast_debug(3, "Media stream '%s' is already declined\n", session_media->stream_type);
|
|
return 0;
|
|
}
|
|
|
|
/* If no type formats have been configured reject this stream */
|
|
if (!ast_format_cap_has_type(session->endpoint->media.codecs, media_type)) {
|
|
ast_debug(3, "Endpoint has no codecs for media type '%s', declining stream\n", session_media->stream_type);
|
|
return 0;
|
|
}
|
|
|
|
/* Ensure incoming transport is compatible with the endpoint's configuration */
|
|
if (!session->endpoint->media.rtp.use_received_transport) {
|
|
encryption = check_endpoint_media_transport(session->endpoint, stream);
|
|
|
|
if (encryption == AST_SIP_MEDIA_TRANSPORT_INVALID) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
|
|
|
|
/* Ensure that the address provided is valid */
|
|
if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
|
|
/* The provided host was actually invalid so we error out this negotiation */
|
|
return -1;
|
|
}
|
|
|
|
/* Using the connection information create an appropriate RTP instance */
|
|
if (!session_media->rtp && create_rtp(session, session_media)) {
|
|
return -1;
|
|
}
|
|
|
|
res = setup_media_encryption(session, session_media, sdp, stream);
|
|
if (res) {
|
|
if (!session->endpoint->media.rtp.encryption_optimistic ||
|
|
!pj_strncmp2(&stream->desc.transport, "RTP/SAVP", 8)) {
|
|
/* If optimistic encryption is disabled and crypto should have been enabled
|
|
* but was not this session must fail. This must also fail if crypto was
|
|
* required in the offer but could not be set up.
|
|
*/
|
|
return -1;
|
|
}
|
|
/* There is no encryption, sad. */
|
|
session_media->encryption = AST_SIP_MEDIA_ENCRYPT_NONE;
|
|
}
|
|
|
|
/* If we've been explicitly configured to use the received transport OR if
|
|
* encryption is on and crypto is present use the received transport.
|
|
* This is done in case of optimistic because it may come in as RTP/AVP or RTP/SAVP depending
|
|
* on the configuration of the remote endpoint (optimistic themselves or mandatory).
|
|
*/
|
|
if ((session->endpoint->media.rtp.use_received_transport) ||
|
|
((encryption == AST_SIP_MEDIA_ENCRYPT_SDES) && !res)) {
|
|
pj_strdup(session->inv_session->pool, &session_media->transport, &stream->desc.transport);
|
|
}
|
|
|
|
if (set_caps(session, session_media, stream, 1)) {
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int add_crypto_to_stream(struct ast_sip_session *session,
|
|
struct ast_sip_session_media *session_media,
|
|
pj_pool_t *pool, pjmedia_sdp_media *media)
|
|
{
|
|
pj_str_t stmp;
|
|
pjmedia_sdp_attr *attr;
|
|
enum ast_rtp_dtls_hash hash;
|
|
const char *crypto_attribute;
|
|
struct ast_rtp_engine_dtls *dtls;
|
|
struct ast_sdp_srtp *tmp;
|
|
static const pj_str_t STR_NEW = { "new", 3 };
|
|
static const pj_str_t STR_EXISTING = { "existing", 8 };
|
|
static const pj_str_t STR_ACTIVE = { "active", 6 };
|
|
static const pj_str_t STR_PASSIVE = { "passive", 7 };
|
|
static const pj_str_t STR_ACTPASS = { "actpass", 7 };
|
|
static const pj_str_t STR_HOLDCONN = { "holdconn", 8 };
|
|
|
|
switch (session_media->encryption) {
|
|
case AST_SIP_MEDIA_ENCRYPT_NONE:
|
|
case AST_SIP_MEDIA_TRANSPORT_INVALID:
|
|
break;
|
|
case AST_SIP_MEDIA_ENCRYPT_SDES:
|
|
if (!session_media->srtp) {
|
|
session_media->srtp = ast_sdp_srtp_alloc();
|
|
if (!session_media->srtp) {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
tmp = session_media->srtp;
|
|
|
|
do {
|
|
crypto_attribute = ast_sdp_srtp_get_attrib(tmp,
|
|
0 /* DTLS running? No */,
|
|
session->endpoint->media.rtp.srtp_tag_32 /* 32 byte tag length? */);
|
|
if (!crypto_attribute) {
|
|
/* No crypto attribute to add, bad news */
|
|
return -1;
|
|
}
|
|
|
|
attr = pjmedia_sdp_attr_create(pool, "crypto",
|
|
pj_cstr(&stmp, crypto_attribute));
|
|
media->attr[media->attr_count++] = attr;
|
|
} while ((tmp = AST_LIST_NEXT(tmp, sdp_srtp_list)));
|
|
|
|
break;
|
|
case AST_SIP_MEDIA_ENCRYPT_DTLS:
|
|
if (setup_dtls_srtp(session, session_media)) {
|
|
return -1;
|
|
}
|
|
|
|
dtls = ast_rtp_instance_get_dtls(session_media->rtp);
|
|
if (!dtls) {
|
|
return -1;
|
|
}
|
|
|
|
switch (dtls->get_connection(session_media->rtp)) {
|
|
case AST_RTP_DTLS_CONNECTION_NEW:
|
|
attr = pjmedia_sdp_attr_create(pool, "connection", &STR_NEW);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
case AST_RTP_DTLS_CONNECTION_EXISTING:
|
|
attr = pjmedia_sdp_attr_create(pool, "connection", &STR_EXISTING);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (dtls->get_setup(session_media->rtp)) {
|
|
case AST_RTP_DTLS_SETUP_ACTIVE:
|
|
attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTIVE);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
case AST_RTP_DTLS_SETUP_PASSIVE:
|
|
attr = pjmedia_sdp_attr_create(pool, "setup", &STR_PASSIVE);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
case AST_RTP_DTLS_SETUP_ACTPASS:
|
|
attr = pjmedia_sdp_attr_create(pool, "setup", &STR_ACTPASS);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
case AST_RTP_DTLS_SETUP_HOLDCONN:
|
|
attr = pjmedia_sdp_attr_create(pool, "setup", &STR_HOLDCONN);
|
|
media->attr[media->attr_count++] = attr;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
hash = dtls->get_fingerprint_hash(session_media->rtp);
|
|
crypto_attribute = dtls->get_fingerprint(session_media->rtp);
|
|
if (crypto_attribute && (hash == AST_RTP_DTLS_HASH_SHA1 || hash == AST_RTP_DTLS_HASH_SHA256)) {
|
|
RAII_VAR(struct ast_str *, fingerprint, ast_str_create(64), ast_free);
|
|
if (!fingerprint) {
|
|
return -1;
|
|
}
|
|
|
|
if (hash == AST_RTP_DTLS_HASH_SHA1) {
|
|
ast_str_set(&fingerprint, 0, "SHA-1 %s", crypto_attribute);
|
|
} else {
|
|
ast_str_set(&fingerprint, 0, "SHA-256 %s", crypto_attribute);
|
|
}
|
|
|
|
attr = pjmedia_sdp_attr_create(pool, "fingerprint", pj_cstr(&stmp, ast_str_buffer(fingerprint)));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*! \brief Function which creates an outgoing stream */
|
|
static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
|
|
struct pjmedia_sdp_session *sdp)
|
|
{
|
|
pj_pool_t *pool = session->inv_session->pool_prov;
|
|
static const pj_str_t STR_IN = { "IN", 2 };
|
|
static const pj_str_t STR_IP4 = { "IP4", 3};
|
|
static const pj_str_t STR_IP6 = { "IP6", 3};
|
|
static const pj_str_t STR_SENDRECV = { "sendrecv", 8 };
|
|
static const pj_str_t STR_SENDONLY = { "sendonly", 8 };
|
|
pjmedia_sdp_media *media;
|
|
const char *hostip = NULL;
|
|
struct ast_sockaddr addr;
|
|
char tmp[512];
|
|
pj_str_t stmp;
|
|
pjmedia_sdp_attr *attr;
|
|
int index = 0;
|
|
int noncodec = (session->endpoint->dtmf == AST_SIP_DTMF_RFC_4733 || session->endpoint->dtmf == AST_SIP_DTMF_AUTO) ? AST_RTP_DTMF : 0;
|
|
int min_packet_size = 0, max_packet_size = 0;
|
|
int rtp_code;
|
|
RAII_VAR(struct ast_format_cap *, caps, NULL, ao2_cleanup);
|
|
enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
|
|
int use_override_prefs = ast_format_cap_count(session->req_caps);
|
|
|
|
int direct_media_enabled = !ast_sockaddr_isnull(&session_media->direct_media_addr) &&
|
|
ast_format_cap_count(session->direct_media_cap);
|
|
|
|
if ((use_override_prefs && !ast_format_cap_has_type(session->req_caps, media_type)) ||
|
|
(!use_override_prefs && !ast_format_cap_has_type(session->endpoint->media.codecs, media_type))) {
|
|
/* If no type formats are configured don't add a stream */
|
|
return 0;
|
|
} else if (!session_media->rtp && create_rtp(session, session_media)) {
|
|
return -1;
|
|
}
|
|
|
|
if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
|
|
!(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
|
|
return -1;
|
|
}
|
|
|
|
if (add_crypto_to_stream(session, session_media, pool, media)) {
|
|
return -1;
|
|
}
|
|
|
|
media->desc.media = pj_str(session_media->stream_type);
|
|
if (pj_strlen(&session_media->transport)) {
|
|
/* If a transport has already been specified use it */
|
|
media->desc.transport = session_media->transport;
|
|
} else {
|
|
media->desc.transport = pj_str(ast_sdp_get_rtp_profile(
|
|
/* Optimistic encryption places crypto in the normal RTP/AVP profile */
|
|
!session->endpoint->media.rtp.encryption_optimistic &&
|
|
(session_media->encryption == AST_SIP_MEDIA_ENCRYPT_SDES),
|
|
session_media->rtp, session->endpoint->media.rtp.use_avpf,
|
|
session->endpoint->media.rtp.force_avp));
|
|
}
|
|
|
|
/* Add connection level details */
|
|
if (direct_media_enabled) {
|
|
hostip = ast_sockaddr_stringify_fmt(&session_media->direct_media_addr, AST_SOCKADDR_STR_ADDR);
|
|
} else if (ast_strlen_zero(session->endpoint->media.address)) {
|
|
hostip = ast_sip_get_host_ip_string(session->endpoint->media.rtp.ipv6 ? pj_AF_INET6() : pj_AF_INET());
|
|
} else {
|
|
hostip = session->endpoint->media.address;
|
|
}
|
|
|
|
if (ast_strlen_zero(hostip)) {
|
|
ast_log(LOG_ERROR, "No local host IP available for stream %s\n", session_media->stream_type);
|
|
return -1;
|
|
}
|
|
|
|
media->conn->net_type = STR_IN;
|
|
/* Assume that the connection will use IPv4 until proven otherwise */
|
|
media->conn->addr_type = STR_IP4;
|
|
pj_strdup2(pool, &media->conn->addr, hostip);
|
|
|
|
if (!ast_strlen_zero(session->endpoint->media.address)) {
|
|
pj_sockaddr ip;
|
|
|
|
if ((pj_sockaddr_parse(pj_AF_UNSPEC(), 0, &media->conn->addr, &ip) == PJ_SUCCESS) &&
|
|
(ip.addr.sa_family == pj_AF_INET6())) {
|
|
media->conn->addr_type = STR_IP6;
|
|
}
|
|
}
|
|
|
|
ast_rtp_instance_get_local_address(session_media->rtp, &addr);
|
|
media->desc.port = direct_media_enabled ? ast_sockaddr_port(&session_media->direct_media_addr) : (pj_uint16_t) ast_sockaddr_port(&addr);
|
|
media->desc.port_count = 1;
|
|
|
|
/* Add ICE attributes and candidates */
|
|
add_ice_to_stream(session, session_media, pool, media);
|
|
|
|
if (!(caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
|
ast_log(LOG_ERROR, "Failed to allocate %s capabilities\n", session_media->stream_type);
|
|
return -1;
|
|
}
|
|
|
|
if (direct_media_enabled) {
|
|
ast_format_cap_get_compatible(session->endpoint->media.codecs, session->direct_media_cap, caps);
|
|
} else if (!ast_format_cap_count(session->req_caps) ||
|
|
!ast_format_cap_iscompatible(session->req_caps, session->endpoint->media.codecs)) {
|
|
ast_format_cap_append_from_cap(caps, session->endpoint->media.codecs, media_type);
|
|
} else {
|
|
ast_format_cap_append_from_cap(caps, session->req_caps, media_type);
|
|
}
|
|
|
|
for (index = 0; index < ast_format_cap_count(caps); ++index) {
|
|
struct ast_format *format = ast_format_cap_get_format(caps, index);
|
|
|
|
if (ast_format_get_type(format) != media_type) {
|
|
ao2_ref(format, -1);
|
|
continue;
|
|
}
|
|
|
|
if ((rtp_code = ast_rtp_codecs_payload_code(ast_rtp_instance_get_codecs(session_media->rtp), 1, format, 0)) == -1) {
|
|
ast_log(LOG_WARNING,"Unable to get rtp codec payload code for %s\n", ast_format_get_name(format));
|
|
ao2_ref(format, -1);
|
|
continue;
|
|
}
|
|
|
|
if (!(attr = generate_rtpmap_attr(session, media, pool, rtp_code, 1, format, 0))) {
|
|
ao2_ref(format, -1);
|
|
continue;
|
|
}
|
|
media->attr[media->attr_count++] = attr;
|
|
|
|
if ((attr = generate_fmtp_attr(pool, format, rtp_code))) {
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
if (ast_format_get_maximum_ms(format) &&
|
|
((ast_format_get_maximum_ms(format) < max_packet_size) || !max_packet_size)) {
|
|
max_packet_size = ast_format_get_maximum_ms(format);
|
|
}
|
|
ao2_ref(format, -1);
|
|
|
|
if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Add non-codec formats */
|
|
if (media_type != AST_MEDIA_TYPE_VIDEO && media->desc.fmt_count < PJMEDIA_MAX_SDP_FMT) {
|
|
for (index = 1LL; index <= AST_RTP_MAX; index <<= 1) {
|
|
if (!(noncodec & index)) {
|
|
continue;
|
|
}
|
|
rtp_code = ast_rtp_codecs_payload_code(
|
|
ast_rtp_instance_get_codecs(session_media->rtp), 0, NULL, index);
|
|
if (rtp_code == -1) {
|
|
continue;
|
|
}
|
|
|
|
if (!(attr = generate_rtpmap_attr(session, media, pool, rtp_code, 0, NULL, index))) {
|
|
continue;
|
|
}
|
|
|
|
media->attr[media->attr_count++] = attr;
|
|
|
|
if (index == AST_RTP_DTMF) {
|
|
snprintf(tmp, sizeof(tmp), "%d 0-16", rtp_code);
|
|
attr = pjmedia_sdp_attr_create(pool, "fmtp", pj_cstr(&stmp, tmp));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
if (media->desc.fmt_count == PJMEDIA_MAX_SDP_FMT) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* If no formats were actually added to the media stream don't add it to the SDP */
|
|
if (!media->desc.fmt_count) {
|
|
return 1;
|
|
}
|
|
|
|
/* If ptime is set add it as an attribute */
|
|
min_packet_size = ast_rtp_codecs_get_framing(ast_rtp_instance_get_codecs(session_media->rtp));
|
|
if (!min_packet_size) {
|
|
min_packet_size = ast_format_cap_get_framing(caps);
|
|
}
|
|
if (min_packet_size) {
|
|
snprintf(tmp, sizeof(tmp), "%d", min_packet_size);
|
|
attr = pjmedia_sdp_attr_create(pool, "ptime", pj_cstr(&stmp, tmp));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
if (max_packet_size) {
|
|
snprintf(tmp, sizeof(tmp), "%d", max_packet_size);
|
|
attr = pjmedia_sdp_attr_create(pool, "maxptime", pj_cstr(&stmp, tmp));
|
|
media->attr[media->attr_count++] = attr;
|
|
}
|
|
|
|
/* Add the sendrecv attribute - we purposely don't keep track because pjmedia-sdp will automatically change our offer for us */
|
|
attr = PJ_POOL_ZALLOC_T(pool, pjmedia_sdp_attr);
|
|
attr->name = !session_media->locally_held ? STR_SENDRECV : STR_SENDONLY;
|
|
media->attr[media->attr_count++] = attr;
|
|
|
|
/* Add the media stream to the SDP */
|
|
sdp->media[sdp->media_count++] = media;
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
|
|
const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
|
|
const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
|
|
{
|
|
RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free);
|
|
enum ast_media_type media_type = stream_to_media_type(session_media->stream_type);
|
|
char host[NI_MAXHOST];
|
|
int fdno, res;
|
|
|
|
if (!session->channel) {
|
|
return 1;
|
|
}
|
|
|
|
if (!local_stream->desc.port || !remote_stream->desc.port) {
|
|
return 1;
|
|
}
|
|
|
|
/* Ensure incoming transport is compatible with the endpoint's configuration */
|
|
if (!session->endpoint->media.rtp.use_received_transport &&
|
|
check_endpoint_media_transport(session->endpoint, remote_stream) == AST_SIP_MEDIA_TRANSPORT_INVALID) {
|
|
return -1;
|
|
}
|
|
|
|
/* Create an RTP instance if need be */
|
|
if (!session_media->rtp && create_rtp(session, session_media)) {
|
|
return -1;
|
|
}
|
|
|
|
res = setup_media_encryption(session, session_media, remote, remote_stream);
|
|
if (!session->endpoint->media.rtp.encryption_optimistic && res) {
|
|
/* If optimistic encryption is disabled and crypto should have been enabled but was not
|
|
* this session must fail.
|
|
*/
|
|
return -1;
|
|
}
|
|
|
|
if (!remote_stream->conn && !remote->conn) {
|
|
return 1;
|
|
}
|
|
|
|
ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
|
|
|
|
/* Ensure that the address provided is valid */
|
|
if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
|
|
/* The provided host was actually invalid so we error out this negotiation */
|
|
return -1;
|
|
}
|
|
|
|
/* Apply connection information to the RTP instance */
|
|
ast_sockaddr_set_port(addrs, remote_stream->desc.port);
|
|
ast_rtp_instance_set_remote_address(session_media->rtp, addrs);
|
|
if (set_caps(session, session_media, remote_stream, 0)) {
|
|
return 1;
|
|
}
|
|
|
|
if ((fdno = media_type_to_fdno(media_type)) < 0) {
|
|
return -1;
|
|
}
|
|
ast_channel_set_fd(session->channel, fdno, ast_rtp_instance_fd(session_media->rtp, 0));
|
|
ast_channel_set_fd(session->channel, fdno + 1, ast_rtp_instance_fd(session_media->rtp, 1));
|
|
|
|
/* If ICE support is enabled find all the needed attributes */
|
|
process_ice_attributes(session, session_media, remote, remote_stream);
|
|
|
|
/* Ensure the RTP instance is active */
|
|
ast_rtp_instance_activate(session_media->rtp);
|
|
|
|
/* audio stream handles music on hold */
|
|
if (media_type != AST_MEDIA_TYPE_AUDIO) {
|
|
if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
|
|
&& (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
|
|
ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
if (ast_sockaddr_isnull(addrs) ||
|
|
ast_sockaddr_is_any(addrs) ||
|
|
pjmedia_sdp_media_find_attr2(remote_stream, "sendonly", NULL) ||
|
|
pjmedia_sdp_media_find_attr2(remote_stream, "inactive", NULL)) {
|
|
if (!session_media->remotely_held) {
|
|
/* The remote side has put us on hold */
|
|
ast_queue_hold(session->channel, session->endpoint->mohsuggest);
|
|
ast_rtp_instance_stop(session_media->rtp);
|
|
ast_queue_frame(session->channel, &ast_null_frame);
|
|
session_media->remotely_held = 1;
|
|
}
|
|
} else if (session_media->remotely_held) {
|
|
/* The remote side has taken us off hold */
|
|
ast_queue_unhold(session->channel);
|
|
ast_queue_frame(session->channel, &ast_null_frame);
|
|
session_media->remotely_held = 0;
|
|
} else if ((pjmedia_sdp_neg_was_answer_remote(session->inv_session->neg) == PJ_FALSE)
|
|
&& (session->inv_session->state == PJSIP_INV_STATE_CONFIRMED)) {
|
|
ast_queue_control(session->channel, AST_CONTROL_UPDATE_RTP_PEER);
|
|
}
|
|
|
|
/* This purposely resets the encryption to the configured in case it gets added later */
|
|
session_media->encryption = session->endpoint->media.rtp.encryption;
|
|
|
|
if (session->endpoint->media.rtp.keepalive > 0 &&
|
|
stream_to_media_type(session_media->stream_type) == AST_MEDIA_TYPE_AUDIO) {
|
|
ast_rtp_instance_set_keepalive(session_media->rtp, session->endpoint->media.rtp.keepalive);
|
|
/* Schedule the initial keepalive early in case this is being used to punch holes through
|
|
* a NAT. This way there won't be an awkward delay before media starts flowing in some
|
|
* scenarios.
|
|
*/
|
|
AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
|
|
session_media->keepalive_sched_id = ast_sched_add_variable(sched, 500, send_keepalive,
|
|
session_media, 1);
|
|
}
|
|
|
|
/* As the channel lock is not held during this process the scheduled item won't block if
|
|
* it is hanging up the channel at the same point we are applying this negotiated SDP.
|
|
*/
|
|
AST_SCHED_DEL(sched, session_media->timeout_sched_id);
|
|
|
|
/* Due to the fact that we only ever have one scheduled timeout item for when we are both
|
|
* off hold and on hold we don't need to store the two timeouts differently on the RTP
|
|
* instance itself.
|
|
*/
|
|
ast_rtp_instance_set_timeout(session_media->rtp, 0);
|
|
if (session->endpoint->media.rtp.timeout && !session_media->remotely_held) {
|
|
ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout);
|
|
} else if (session->endpoint->media.rtp.timeout_hold && session_media->remotely_held) {
|
|
ast_rtp_instance_set_timeout(session_media->rtp, session->endpoint->media.rtp.timeout_hold);
|
|
}
|
|
|
|
if (ast_rtp_instance_get_timeout(session_media->rtp)) {
|
|
session_media->timeout_sched_id = ast_sched_add_variable(sched,
|
|
ast_rtp_instance_get_timeout(session_media->rtp) * 1000, rtp_check_timeout,
|
|
session_media, 1);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/*! \brief Function which updates the media stream with external media address, if applicable */
|
|
static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
|
|
{
|
|
RAII_VAR(struct ast_sip_transport_state *, transport_state, ast_sip_get_transport_state(ast_sorcery_object_get_id(transport)), ao2_cleanup);
|
|
char host[NI_MAXHOST];
|
|
struct ast_sockaddr addr = { { 0, } };
|
|
|
|
/* If the stream has been rejected there will be no connection line */
|
|
if (!stream->conn || !transport_state) {
|
|
return;
|
|
}
|
|
|
|
ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
|
|
ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
|
|
|
|
/* Is the address within the SDP inside the same network? */
|
|
if (ast_apply_ha(transport_state->localnet, &addr) == AST_SENSE_ALLOW) {
|
|
return;
|
|
}
|
|
|
|
pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
|
|
}
|
|
|
|
/*! \brief Function which stops the RTP instance */
|
|
static void stream_stop(struct ast_sip_session_media *session_media)
|
|
{
|
|
if (!session_media->rtp) {
|
|
return;
|
|
}
|
|
|
|
AST_SCHED_DEL(sched, session_media->keepalive_sched_id);
|
|
AST_SCHED_DEL(sched, session_media->timeout_sched_id);
|
|
ast_rtp_instance_stop(session_media->rtp);
|
|
}
|
|
|
|
/*! \brief Function which destroys the RTP instance when session ends */
|
|
static void stream_destroy(struct ast_sip_session_media *session_media)
|
|
{
|
|
if (session_media->rtp) {
|
|
stream_stop(session_media);
|
|
ast_rtp_instance_destroy(session_media->rtp);
|
|
}
|
|
session_media->rtp = NULL;
|
|
}
|
|
|
|
/*! \brief SDP handler for 'audio' media stream */
|
|
static struct ast_sip_session_sdp_handler audio_sdp_handler = {
|
|
.id = STR_AUDIO,
|
|
.negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
|
|
.create_outgoing_sdp_stream = create_outgoing_sdp_stream,
|
|
.apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
|
|
.change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
|
|
.stream_stop = stream_stop,
|
|
.stream_destroy = stream_destroy,
|
|
};
|
|
|
|
/*! \brief SDP handler for 'video' media stream */
|
|
static struct ast_sip_session_sdp_handler video_sdp_handler = {
|
|
.id = STR_VIDEO,
|
|
.negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
|
|
.create_outgoing_sdp_stream = create_outgoing_sdp_stream,
|
|
.apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
|
|
.change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
|
|
.stream_stop = stream_stop,
|
|
.stream_destroy = stream_destroy,
|
|
};
|
|
|
|
static int video_info_incoming_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
|
|
{
|
|
struct pjsip_transaction *tsx;
|
|
pjsip_tx_data *tdata;
|
|
|
|
if (!session->channel
|
|
|| !ast_sip_is_content_type(&rdata->msg_info.msg->body->content_type,
|
|
"application",
|
|
"media_control+xml")) {
|
|
return 0;
|
|
}
|
|
|
|
tsx = pjsip_rdata_get_tsx(rdata);
|
|
|
|
ast_queue_control(session->channel, AST_CONTROL_VIDUPDATE);
|
|
|
|
if (pjsip_dlg_create_response(session->inv_session->dlg, rdata, 200, NULL, &tdata) == PJ_SUCCESS) {
|
|
pjsip_dlg_send_response(session->inv_session->dlg, tsx, tdata);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct ast_sip_session_supplement video_info_supplement = {
|
|
.method = "INFO",
|
|
.incoming_request = video_info_incoming_request,
|
|
};
|
|
|
|
/*! \brief Unloads the sdp RTP/AVP module from Asterisk */
|
|
static int unload_module(void)
|
|
{
|
|
ast_sip_session_unregister_supplement(&video_info_supplement);
|
|
ast_sip_session_unregister_sdp_handler(&video_sdp_handler, STR_VIDEO);
|
|
ast_sip_session_unregister_sdp_handler(&audio_sdp_handler, STR_AUDIO);
|
|
|
|
if (sched) {
|
|
ast_sched_context_destroy(sched);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*!
|
|
* \brief Load the module
|
|
*
|
|
* Module loading including tests for configuration or dependencies.
|
|
* This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
|
|
* or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
|
|
* tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
|
|
* configuration file or other non-critical problem return
|
|
* AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
|
|
*/
|
|
static int load_module(void)
|
|
{
|
|
CHECK_PJSIP_SESSION_MODULE_LOADED();
|
|
|
|
if (ast_check_ipv6()) {
|
|
ast_sockaddr_parse(&address_rtp, "::", 0);
|
|
} else {
|
|
ast_sockaddr_parse(&address_rtp, "0.0.0.0", 0);
|
|
}
|
|
|
|
if (!(sched = ast_sched_context_create())) {
|
|
ast_log(LOG_ERROR, "Unable to create scheduler context.\n");
|
|
goto end;
|
|
}
|
|
|
|
if (ast_sched_start_thread(sched)) {
|
|
ast_log(LOG_ERROR, "Unable to create scheduler context thread.\n");
|
|
goto end;
|
|
}
|
|
|
|
if (ast_sip_session_register_sdp_handler(&audio_sdp_handler, STR_AUDIO)) {
|
|
ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_AUDIO);
|
|
goto end;
|
|
}
|
|
|
|
if (ast_sip_session_register_sdp_handler(&video_sdp_handler, STR_VIDEO)) {
|
|
ast_log(LOG_ERROR, "Unable to register SDP handler for %s stream type\n", STR_VIDEO);
|
|
goto end;
|
|
}
|
|
|
|
ast_sip_session_register_supplement(&video_info_supplement);
|
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
|
end:
|
|
unload_module();
|
|
|
|
return AST_MODULE_LOAD_FAILURE;
|
|
}
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP SDP RTP/AVP stream handler",
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
|
.load = load_module,
|
|
.unload = unload_module,
|
|
.load_pri = AST_MODPRI_CHANNEL_DRIVER,
|
|
);
|