kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-10-13 00:04:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add support for T.38 fax to chan_pjsip.

Browse Source 
Review: https://reviewboard.asterisk.org/r/2692/


git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@395731 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Joshua Colp
2013-07-30 14:16:41 +00:00
parent 7c371a1add
commit 7fded33789
8 changed files with 1272 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
res/res_sip.c
View File

@@ -398,6 +398,56 @@
Gulp channel driver will return busy as the device state instead of in use.
</para></description>
</configOption>
<configOption name="t38udptl" default="no">
<synopsis>Whether T.38 UDPTL support is enabled or not</synopsis>
<description><para>
If set to yes T.38 UDPTL support will be enabled, and T.38 negotiation requests will be accepted
and relayed.
</para></description>
</configOption>
<configOption name="t38udptl_ec" default="none">
<synopsis>T.38 UDPTL error correction method</synopsis>
<description>
<enumlist>
<enum name="none"><para>
No error correction should be used.
</para></enum>
<enum name="fec"><para>
Forward error correction should be used.
</para></enum>
<enum name="redundancy"><para>
Redundacy error correction should be used.
</para></enum>
</enumlist>
</description>
</configOption>
<configOption name="t38udptl_maxdatagram" default="0">
<synopsis>T.38 UDPTL maximum datagram size</synopsis>
<description><para>
This option can be set to override the maximum datagram of a remote endpoint for broken
endpoints.
</para></description>
</configOption>
<configOption name="faxdetect" default="no">
<synopsis>Whether CNG tone detection is enabled</synopsis>
<description><para>
This option can be set to send the session to the fax extension when a CNG tone is
detected.
</para></description>
</configOption>
<configOption name="t38udptl_nat" default="no">
<synopsis>Whether NAT support is enabled on UDPTL sessions</synopsis>
<description><para>
When enabled the UDPTL stack will send UDPTL packets to the source address of
received packets.
</para></description>
</configOption>
<configOption name="t38udptl_ipv6" default="no">
<synopsis>Whether IPv6 is used for UDPTL Sessions</synopsis>
<description><para>
When enabled the UDPTL stack will use IPv6.
</para></description>
</configOption>
<configOption name="tonezone">
<synopsis>Set which country's indications to use for channels created for this endpoint.</synopsis>
</configOption>

24
res/res_sip/sip_configuration.c
View File

@@ -527,6 +527,24 @@ static int dtls_handler(const struct aco_option *opt,
return ast_rtp_dtls_cfg_parse(&endpoint->dtls_cfg, var->name, var->value);
}
static int t38udptl_ec_handler(const struct aco_option *opt,
struct ast_variable *var, void *obj)
{
struct ast_sip_endpoint *endpoint = obj;
if (!strcmp(var->value, "none")) {
endpoint->t38udptl_ec = UDPTL_ERROR_CORRECTION_NONE;
} else if (!strcmp(var->value, "fec")) {
endpoint->t38udptl_ec = UDPTL_ERROR_CORRECTION_FEC;
} else if (!strcmp(var->value, "redundancy")) {
endpoint->t38udptl_ec = UDPTL_ERROR_CORRECTION_REDUNDANCY;
} else {
return -1;
}
return 0;
}
static void *sip_nat_hook_alloc(const char *name)
{
return ast_sorcery_generic_alloc(sizeof(struct ast_sip_nat_hook), NULL);
@@ -667,6 +685,12 @@ int ast_res_sip_initialize_configuration(void)
ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "namedcallgroup", "", named_groups_handler, NULL, 0, 0);
ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "namedpickupgroup", "", named_groups_handler, NULL, 0, 0);
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "devicestate_busy_at", "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_endpoint, devicestate_busy_at));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "t38udptl", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, t38udptl));
ast_sorcery_object_field_register_custom(sip_sorcery, "endpoint", "t38udptl_ec", "none", t38udptl_ec_handler, NULL, 0, 0);
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "t38udptl_maxdatagram", "0", OPT_UINT_T, 0, FLDSET(struct ast_sip_endpoint, t38udptl_maxdatagram));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "faxdetect", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, faxdetect));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "t38udptl_nat", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, t38udptl_nat));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "t38udptl_ipv6", "no", OPT_BOOL_T, 1, FLDSET(struct ast_sip_endpoint, t38udptl_ipv6));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "rtpengine", "asterisk", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, rtp_engine));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "tonezone", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, zone));
ast_sorcery_object_field_register(sip_sorcery, "endpoint", "language", "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_sip_endpoint, language));

180
res/res_sip_session.c
View File

@@ -412,6 +412,10 @@ static int handle_negotiated_sdp_session_media(void *obj, void *arg, int flags)
struct ast_sip_session_sdp_handler *handler;
RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
if (!remote->media[i]) {
continue;
}
/* We need a null-terminated version of the media string */
ast_copy_pj_str(media, &local->media[i]->desc.media, sizeof(media));
@@ -602,6 +606,8 @@ struct ast_sip_session_delayed_request {
char method[15];
/*! Callback to call when the delayed request is created. */
ast_sip_session_request_creation_cb on_request_creation;
/*! Callback to call when the delayed request SDP is created */
ast_sip_session_sdp_creation_cb on_sdp_creation;
/*! Callback to call when the delayed request receives a response */
ast_sip_session_response_cb on_response;
/*! Request to send */
@@ -611,6 +617,7 @@ struct ast_sip_session_delayed_request {
static struct ast_sip_session_delayed_request *delayed_request_alloc(const char *method,
ast_sip_session_request_creation_cb on_request_creation,
ast_sip_session_sdp_creation_cb on_sdp_creation,
ast_sip_session_response_cb on_response,
pjsip_tx_data *tdata)
{
@@ -620,6 +627,7 @@ static struct ast_sip_session_delayed_request *delayed_request_alloc(const char
}
ast_copy_string(delay->method, method, sizeof(delay->method));
delay->on_request_creation = on_request_creation;
delay->on_sdp_creation = on_sdp_creation;
delay->on_response = on_response;
delay->tdata = tdata;
return delay;
@@ -636,10 +644,10 @@ static int send_delayed_request(struct ast_sip_session *session, struct ast_sip_
if (!strcmp(delay->method, "INVITE")) {
ast_sip_session_refresh(session, delay->on_request_creation,
delay->on_response, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
delay->on_sdp_creation, delay->on_response, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
} else if (!strcmp(delay->method, "UPDATE")) {
ast_sip_session_refresh(session, delay->on_request_creation,
delay->on_response, AST_SIP_SESSION_REFRESH_METHOD_UPDATE, 1);
delay->on_sdp_creation, delay->on_response, AST_SIP_SESSION_REFRESH_METHOD_UPDATE, 1);
} else {
ast_log(LOG_WARNING, "Unexpected delayed %s request with no existing request structure\n", delay->method);
return -1;
@@ -675,10 +683,11 @@ static void queue_delayed_request(struct ast_sip_session *session)
}
static int delay_request(struct ast_sip_session *session, ast_sip_session_request_creation_cb on_request,
ast_sip_session_response_cb on_response, const char *method, pjsip_tx_data *tdata)
ast_sip_session_sdp_creation_cb on_sdp_creation, ast_sip_session_response_cb on_response,
const char *method, pjsip_tx_data *tdata)
{
struct ast_sip_session_delayed_request *delay = delayed_request_alloc(method,
on_request, on_response, tdata);
on_request, on_sdp_creation, on_response, tdata);
if (!delay) {
return -1;
@@ -702,7 +711,9 @@ static pjmedia_sdp_session *generate_session_refresh_sdp(struct ast_sip_session
}
int ast_sip_session_refresh(struct ast_sip_session *session,
ast_sip_session_request_creation_cb on_request_creation, ast_sip_session_response_cb on_response,
ast_sip_session_request_creation_cb on_request_creation,
ast_sip_session_sdp_creation_cb on_sdp_creation,
ast_sip_session_response_cb on_response,
enum ast_sip_session_refresh_method method, int generate_new_sdp)
{
pjsip_inv_session *inv_session = session->inv_session;
@@ -721,7 +732,7 @@ int ast_sip_session_refresh(struct ast_sip_session *session,
/* We can't send a reinvite yet, so delay it */
ast_debug(3, "Delaying sending reinvite to %s because of outstanding transaction...\n",
ast_sorcery_object_get_id(session->endpoint));
return delay_request(session, on_request_creation, on_response, "INVITE", NULL);
return delay_request(session, on_request_creation, on_sdp_creation, on_response, "INVITE", NULL);
} else if (inv_session->state != PJSIP_INV_STATE_CONFIRMED) {
/* Initial INVITE transaction failed to progress us to a confirmed state
* which means re-invites are not possible
@@ -738,6 +749,11 @@ int ast_sip_session_refresh(struct ast_sip_session *session,
ast_log(LOG_ERROR, "Failed to generate session refresh SDP. Not sending session refresh\n");
return -1;
}
if (on_sdp_creation) {
if (on_sdp_creation(session, new_sdp)) {
return -1;
}
}
}
if (method == AST_SIP_SESSION_REFRESH_METHOD_INVITE) {
@@ -773,6 +789,132 @@ static pjsip_module session_module = {
.on_rx_request = session_on_rx_request,
};
/*! \brief Determine whether the SDP provided requires deferral of negotiating or not
*
* \retval 1 re-invite should be deferred and resumed later
* \retval 0 re-invite should not be deferred
*/
static int sdp_requires_deferral(struct ast_sip_session *session, const pjmedia_sdp_session *sdp)
{
int i;
if (validate_incoming_sdp(sdp)) {
return 0;
}
for (i = 0; i < sdp->media_count; ++i) {
/* See if there are registered handlers for this media stream type */
char media[20];
struct ast_sip_session_sdp_handler *handler;
RAII_VAR(struct sdp_handler_list *, handler_list, NULL, ao2_cleanup);
RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
/* We need a null-terminated version of the media string */
ast_copy_pj_str(media, &sdp->media[i]->desc.media, sizeof(media));
session_media = ao2_find(session->media, media, OBJ_KEY);
if (!session_media) {
/* if the session_media doesn't exist, there weren't
* any handlers at the time of its creation */
continue;
}
if (session_media->handler && session_media->handler->defer_incoming_sdp_stream) {
int res;
handler = session_media->handler;
res = handler->defer_incoming_sdp_stream(
session, session_media, sdp, sdp->media[i]);
if (res) {
return 1;
}
}
handler_list = ao2_find(sdp_handlers, media, OBJ_KEY);
if (!handler_list) {
ast_debug(1, "No registered SDP handlers for media type '%s'\n", media);
continue;
}
AST_LIST_TRAVERSE(&handler_list->list, handler, next) {
int res;
if (session_media->handler) {
/* There is only one slot for this stream type and it has already been claimed
* so it will go unhandled */
break;
}
if (!handler->defer_incoming_sdp_stream) {
continue;
}
res = handler->defer_incoming_sdp_stream(session, session_media, sdp, sdp->media[i]);
if (res) {
return 1;
}
}
}
return 0;
}
static pj_bool_t session_reinvite_on_rx_request(pjsip_rx_data *rdata)
{
pjsip_dialog *dlg;
RAII_VAR(struct ast_sip_session *, session, NULL, ao2_cleanup);
pjsip_rdata_sdp_info *sdp_info;
if (rdata->msg_info.msg->line.req.method.id != PJSIP_INVITE_METHOD ||
!(dlg = pjsip_ua_find_dialog(&rdata->msg_info.cid->id, &rdata->msg_info.to->tag, &rdata->msg_info.from->tag, PJ_FALSE)) ||
!(session = ast_sip_dialog_get_session(dlg))) {
return PJ_FALSE;
}
if (session->deferred_reinvite) {
pj_str_t key, deferred_key;
pjsip_tx_data *tdata;
/* We use memory from the new request on purpose so the deferred reinvite pool does not grow uncontrollably */
pjsip_tsx_create_key(rdata->tp_info.pool, &key, PJSIP_ROLE_UAS, &rdata->msg_info.cseq->method, rdata);
pjsip_tsx_create_key(rdata->tp_info.pool, &deferred_key, PJSIP_ROLE_UAS, &session->deferred_reinvite->msg_info.cseq->method,
session->deferred_reinvite);
/* If this is a retransmission ignore it */
if (!pj_strcmp(&key, &deferred_key)) {
return PJ_TRUE;
}
/* Otherwise this is a new re-invite, so reject it */
if (pjsip_dlg_create_response(dlg, rdata, 491, NULL, &tdata) == PJ_SUCCESS) {
pjsip_endpt_send_response2(ast_sip_get_pjsip_endpoint(), rdata, tdata, NULL, NULL);
}
return PJ_TRUE;
}
if (!(sdp_info = pjsip_rdata_get_sdp_info(rdata)) ||
(sdp_info->sdp_err != PJ_SUCCESS) ||
!sdp_info->sdp ||
!sdp_requires_deferral(session, sdp_info->sdp)) {
return PJ_FALSE;
}
pjsip_rx_data_clone(rdata, 0, &session->deferred_reinvite);
return PJ_TRUE;
}
void ast_sip_session_resume_reinvite(struct ast_sip_session *session)
{
if (!session->deferred_reinvite) {
return;
}
pjsip_endpt_process_rx_data(ast_sip_get_pjsip_endpoint(), session->deferred_reinvite, NULL, NULL);
pjsip_rx_data_free_cloned(session->deferred_reinvite);
session->deferred_reinvite = NULL;
}
static pjsip_module session_reinvite_module = {
.name = { "Session Re-Invite Module", 24 },
.priority = PJSIP_MOD_PRIORITY_UA_PROXY_LAYER - 1,
.on_rx_request = session_reinvite_on_rx_request,
};
void ast_sip_session_send_request_with_cb(struct ast_sip_session *session, pjsip_tx_data *tdata,
ast_sip_session_response_cb on_response)
{
@@ -940,6 +1082,7 @@ struct ast_sip_session *ast_sip_session_alloc(struct ast_sip_endpoint *endpoint,
{
RAII_VAR(struct ast_sip_session *, session, ao2_alloc(sizeof(*session), session_destructor), ao2_cleanup);
struct ast_sip_session_supplement *iter;
int dsp_features = 0;
if (!session) {
return NULL;
}
@@ -971,12 +1114,20 @@ struct ast_sip_session *ast_sip_session_alloc(struct ast_sip_endpoint *endpoint,
session->req_caps = ast_format_cap_alloc_nolock();
if (endpoint->dtmf == AST_SIP_DTMF_INBAND) {
dsp_features |= DSP_FEATURE_DIGIT_DETECT;
}
if (endpoint->faxdetect) {
dsp_features |= DSP_FEATURE_FAX_DETECT;
}
if (dsp_features) {
if (!(session->dsp = ast_dsp_new())) {
ao2_ref(session, -1);
return NULL;
}
ast_dsp_set_features(session->dsp, DSP_FEATURE_DIGIT_DETECT);
ast_dsp_set_features(session->dsp, dsp_features);
}
if (add_supplements(session)) {
@@ -1044,6 +1195,9 @@ struct ast_sip_session *ast_sip_session_create_outgoing(struct ast_sip_endpoint
pjsip_dlg_terminate(dlg);
return NULL;
}
#ifdef PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE
inv_session->sdp_neg_flags = PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE;
#endif
pjsip_timer_setting_default(&timer);
timer.min_se = endpoint->min_se;
@@ -1189,6 +1343,9 @@ static pjsip_inv_session *pre_session_setup(pjsip_rx_data *rdata, const struct a
pjsip_dlg_terminate(dlg);
return NULL;
}
#ifdef PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE
inv_session->sdp_neg_flags = PJMEDIA_SDP_NEG_ALLOW_MEDIA_CHANGE;
#endif
if (pjsip_dlg_add_usage(dlg, &session_module, NULL) != PJ_SUCCESS) {
if (pjsip_inv_initial_answer(inv_session, rdata, 500, NULL, NULL, &tdata) != PJ_SUCCESS) {
pjsip_inv_terminate(inv_session, 500, PJ_FALSE);
@@ -1473,7 +1630,7 @@ static void resend_reinvite(pj_timer_heap_t *timer, pj_timer_entry *entry)
static void reschedule_reinvite(struct ast_sip_session *session, ast_sip_session_response_cb on_response, pjsip_tx_data *tdata)
{
struct ast_sip_session_delayed_request *delay = delayed_request_alloc("INVITE",
NULL, on_response, tdata);
NULL, NULL, on_response, tdata);
pjsip_inv_session *inv = session->inv_session;
struct reschedule_reinvite_data *rrd = reschedule_reinvite_data_alloc(session, delay);
pj_time_val tv;
@@ -1710,8 +1867,9 @@ static void session_inv_on_tsx_state_changed(pjsip_inv_session *inv, pjsip_trans
if (tsx->status_code == PJSIP_SC_REQUEST_PENDING) {
reschedule_reinvite(session, tsx->mod_data[session_module.id], tsx->last_tx);
return;
} else if (inv->state == PJSIP_INV_STATE_CONFIRMED) {
/* Other reinvite failures result in destroying the session. */
} else if (inv->state == PJSIP_INV_STATE_CONFIRMED &&
tsx->status_code != 488) {
/* Other reinvite failures (except 488) result in destroying the session. */
pjsip_tx_data *tdata;
if (pjsip_inv_end_session(inv, 500, NULL, &tdata) == PJ_SUCCESS) {
ast_sip_session_send_request(session, tdata);
@@ -1952,12 +2110,14 @@ static int load_module(void)
if (ast_sip_register_service(&session_module)) {
return AST_MODULE_LOAD_DECLINE;
}
ast_sip_register_service(&session_reinvite_module);
return AST_MODULE_LOAD_SUCCESS;
}
static int unload_module(void)
{
ast_sip_unregister_service(&session_module);
ast_sip_unregister_service(&session_reinvite_module);
if (nat_hook) {
ast_sorcery_delete(ast_sip_get_sorcery(), nat_hook);
nat_hook = NULL;

1
res/res_sip_session.exports.in
View File

@@ -16,6 +16,7 @@
LINKER_SYMBOL_PREFIXast_sip_session_create_invite;
LINKER_SYMBOL_PREFIXast_sip_session_create_outgoing;
LINKER_SYMBOL_PREFIXast_sip_dialog_get_session;
LINKER_SYMBOL_PREFIXast_sip_session_resume_reinvite;
LINKER_SYMBOL_PREFIXast_sip_channel_pvt_alloc;
local:
*;

853
res/res_sip_t38.c Normal file
View File

@@ -0,0 +1,853 @@
/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2013, Digium, Inc.
*
* Joshua Colp <jcolp@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 T.38 handling
*/
/*** MODULEINFO
<depend>pjproject</depend>
<depend>res_sip</depend>
<depend>res_sip_session</depend>
<support_level>core</support_level>
***/
#include "asterisk.h"
#include <pjsip.h>
#include <pjsip_ua.h>
#include <pjmedia.h>
#include <pjlib.h>
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
#include "asterisk/module.h"
#include "asterisk/udptl.h"
#include "asterisk/netsock2.h"
#include "asterisk/channel.h"
#include "asterisk/acl.h"
#include "asterisk/res_sip.h"
#include "asterisk/res_sip_session.h"
/*! \brief The number of seconds after receiving a T.38 re-invite before automatically rejecting it */
#define T38_AUTOMATIC_REJECTION_SECONDS 5
/*! \brief Address for IPv4 UDPTL */
static struct ast_sockaddr address_ipv4;
/*! \brief Address for IPv6 UDPTL */
static struct ast_sockaddr address_ipv6;
/*! \brief T.38 state information */
struct t38_state {
/*! \brief Current state */
enum ast_sip_session_t38state state;
/*! \brief Our T.38 parameters */
struct ast_control_t38_parameters our_parms;
/*! \brief Their T.38 parameters */
struct ast_control_t38_parameters their_parms;
/*! \brief Timer entry for automatically rejecting an inbound re-invite */
pj_timer_entry timer;
};
/*! \brief Destructor for T.38 state information */
static void t38_state_destroy(void *obj)
{
ast_free(obj);
}
/*! \brief Datastore for attaching T.38 state information */
static const struct ast_datastore_info t38_datastore = {
.type = "t38",
.destroy = t38_state_destroy,
};
/*! \brief Structure for T.38 parameters task data */
struct t38_parameters_task_data {
/*! \brief Session itself */
struct ast_sip_session *session;
/*! \brief T.38 control frame */
struct ast_frame *frame;
};
/*! \brief Destructor for T.38 data */
static void t38_parameters_task_data_destroy(void *obj)
{
struct t38_parameters_task_data *data = obj;
ao2_cleanup(data->session);
if (data->frame) {
ast_frfree(data->frame);
}
}
/*! \brief Allocator for T.38 data */
static struct t38_parameters_task_data *t38_parameters_task_data_alloc(struct ast_sip_session *session,
struct ast_frame *frame)
{
struct t38_parameters_task_data *data = ao2_alloc(sizeof(*data), t38_parameters_task_data_destroy);
if (!data) {
return NULL;
}
data->session = session;
ao2_ref(session, +1);
if (!(data->frame = ast_frdup(frame))) {
ao2_cleanup(data);
return NULL;
}
return data;
}
/*! \brief Helper function for changing the T.38 state */
static void t38_change_state(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
struct t38_state *state, enum ast_sip_session_t38state new_state)
{
enum ast_sip_session_t38state old_state = session->t38state;
struct ast_control_t38_parameters parameters = { .request_response = 0, };
pj_time_val delay = { .sec = T38_AUTOMATIC_REJECTION_SECONDS };
if (old_state == new_state) {
return;
}
session->t38state = new_state;
ast_debug(2, "T.38 state changed to '%d' from '%d' on channel '%s'\n", new_state, old_state, ast_channel_name(session->channel));
if (pj_timer_heap_cancel(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()), &state->timer)) {
ast_debug(2, "Automatic T.38 rejection on channel '%s' terminated\n", ast_channel_name(session->channel));
ao2_ref(session, -1);
}
if (!session->channel) {
return;
}
switch (new_state) {
case T38_PEER_REINVITE:
ao2_ref(session, +1);
if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &state->timer, &delay) != PJ_SUCCESS) {
ast_log(LOG_WARNING, "Scheduling of automatic T.38 rejection for channel '%s' failed\n",
ast_channel_name(session->channel));
ao2_ref(session, -1);
}
parameters = state->their_parms;
parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
break;
case T38_ENABLED:
parameters = state->their_parms;
parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
parameters.request_response = AST_T38_NEGOTIATED;
ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
break;
case T38_REJECTED:
case T38_DISABLED:
if (old_state == T38_ENABLED) {
parameters.request_response = AST_T38_TERMINATED;
} else if (old_state == T38_LOCAL_REINVITE) {
parameters.request_response = AST_T38_REFUSED;
}
break;
case T38_LOCAL_REINVITE:
/* wait until we get a peer response before responding to local reinvite */
break;
}
if (parameters.request_response) {
ast_queue_control_data(session->channel, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
}
}
/*! \brief Task function which rejects a T.38 re-invite and resumes handling it */
static int t38_automatic_reject(void *obj)
{
RAII_VAR(struct ast_sip_session *, session, obj, ao2_cleanup);
RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(session->media, "image", OBJ_KEY), ao2_cleanup);
if (!datastore) {
return 0;
}
ast_debug(2, "Automatically rejecting T.38 request on channel '%s'\n", ast_channel_name(session->channel));
t38_change_state(session, session_media, datastore->data, T38_REJECTED);
ast_sip_session_resume_reinvite(session);
return 0;
}
/*! \brief Timer entry callback which queues a task to reject a T.38 re-invite and resume handling it */
static void t38_automatic_reject_timer_cb(pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
{
struct ast_sip_session *session = entry->user_data;
if (ast_sip_push_task(session->serializer, t38_automatic_reject, session)) {
ao2_ref(session, -1);
}
}
/*! \brief Helper function which retrieves or allocates a T.38 state information datastore */
static struct t38_state *t38_state_get_or_alloc(struct ast_sip_session *session)
{
RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
struct t38_state *state;
/* While the datastore refcount is decremented this is operating in the serializer so it will remain valid regardless */
if (datastore) {
return datastore->data;
}
if (!(datastore = ast_sip_session_alloc_datastore(&t38_datastore, "t38")) ||
!(datastore->data = ast_calloc(1, sizeof(struct t38_state))) ||
ast_sip_session_add_datastore(session, datastore)) {
return NULL;
}
state = datastore->data;
/* This will get bumped up before scheduling */
state->timer.user_data = session;
state->timer.cb = t38_automatic_reject_timer_cb;
datastore->data = state;
return state;
}
/*! \brief Initializes UDPTL support on a session, only done when actually needed */
static int t38_initialize_session(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
{
if (session_media->udptl) {
return 0;
}
if (!(session_media->udptl = ast_udptl_new_with_bindaddr(NULL, NULL, 0,
session->endpoint->t38udptl_ipv6 ? &address_ipv6 : &address_ipv4))) {
return -1;
}
ast_channel_set_fd(session->channel, 5, ast_udptl_fd(session_media->udptl));
ast_udptl_set_error_correction_scheme(session_media->udptl, session->endpoint->t38udptl_ec);
ast_udptl_setnat(session_media->udptl, session->endpoint->t38udptl_nat);
return 0;
}
/*! \brief Callback for when T.38 reinvite SDP is created */
static int t38_reinvite_sdp_cb(struct ast_sip_session *session, pjmedia_sdp_session *sdp)
{
int stream;
/* Move the image media stream to the front and have it as the only stream, pjmedia will fill in
* dummy streams for the rest
*/
for (stream = 0; stream < sdp->media_count++; ++stream) {
if (!pj_strcmp2(&sdp->media[stream]->desc.media, "image")) {
sdp->media[0] = sdp->media[stream];
sdp->media_count = 1;
break;
}
}
return 0;
}
/*! \brief Callback for when a response is received for a T.38 re-invite */
static int t38_reinvite_response_cb(struct ast_sip_session *session, pjsip_rx_data *rdata)
{
struct pjsip_status_line status = rdata->msg_info.msg->line.status;
struct t38_state *state;
RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
if (status.code == 100) {
return 0;
}
if (!(state = t38_state_get_or_alloc(session)) ||
!(session_media = ao2_find(session->media, "image", OBJ_KEY))) {
ast_log(LOG_WARNING, "Received response to T.38 re-invite on '%s' but state unavailable\n",
ast_channel_name(session->channel));
return 0;
}
t38_change_state(session, session_media, state, (status.code == 200) ? T38_ENABLED : T38_REJECTED);
return 0;
}
/*! \brief Task for reacting to T.38 control frame */
static int t38_interpret_parameters(void *obj)
{
RAII_VAR(struct t38_parameters_task_data *, data, obj, ao2_cleanup);
const struct ast_control_t38_parameters *parameters = data->frame->data.ptr;
struct t38_state *state = t38_state_get_or_alloc(data->session);
RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(data->session->media, "image", OBJ_KEY), ao2_cleanup);
/* Without session media or state we can't interpret parameters */
if (!session_media || !state) {
return 0;
}
switch (parameters->request_response) {
case AST_T38_NEGOTIATED:
case AST_T38_REQUEST_NEGOTIATE: /* Request T38 */
/* Negotiation can not take place without a valid max_ifp value. */
if (!parameters->max_ifp) {
t38_change_state(data->session, session_media, state, T38_REJECTED);
if (data->session->t38state == T38_PEER_REINVITE) {
ast_sip_session_resume_reinvite(data->session);
}
break;
} else if (data->session->t38state == T38_PEER_REINVITE) {
state->our_parms = *parameters;
/* modify our parameters to conform to the peer's parameters,
* based on the rules in the ITU T.38 recommendation
*/
if (!state->their_parms.fill_bit_removal) {
state->our_parms.fill_bit_removal = 0;
}
if (!state->their_parms.transcoding_mmr) {
state->our_parms.transcoding_mmr = 0;
}
if (!state->their_parms.transcoding_jbig) {
state->our_parms.transcoding_jbig = 0;
}
state->our_parms.version = MIN(state->our_parms.version, state->their_parms.version);
state->our_parms.rate_management = state->their_parms.rate_management;
ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
t38_change_state(data->session, session_media, state, T38_ENABLED);
ast_sip_session_resume_reinvite(data->session);
} else if (data->session->t38state != T38_ENABLED) {
if (t38_initialize_session(data->session, session_media)) {
break;
}
state->our_parms = *parameters;
ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
t38_change_state(data->session, session_media, state, T38_LOCAL_REINVITE);
ast_sip_session_refresh(data->session, NULL, t38_reinvite_sdp_cb, t38_reinvite_response_cb,
AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
}
break;
case AST_T38_TERMINATED:
case AST_T38_REFUSED:
case AST_T38_REQUEST_TERMINATE: /* Shutdown T38 */
if (data->session->t38state == T38_PEER_REINVITE) {
t38_change_state(data->session, session_media, state, T38_REJECTED);
ast_sip_session_resume_reinvite(data->session);
} else if (data->session->t38state == T38_ENABLED) {
t38_change_state(data->session, session_media, state, T38_DISABLED);
ast_sip_session_refresh(data->session, NULL, NULL, NULL, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
}
break;
case AST_T38_REQUEST_PARMS: { /* Application wants remote's parameters re-sent */
struct ast_control_t38_parameters parameters = state->their_parms;
if (data->session->t38state == T38_PEER_REINVITE) {
parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
ast_queue_control_data(data->session->channel, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
}
break;
}
default:
break;
}
return 0;
}
/*! \brief Frame hook callback for writing */
static struct ast_frame *t38_framehook_write(struct ast_sip_session *session, struct ast_frame *f)
{
if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_T38_PARAMETERS &&
session->endpoint->t38udptl) {
struct t38_parameters_task_data *data = t38_parameters_task_data_alloc(session, f);
if (!data) {
return f;
}
if (ast_sip_push_task(session->serializer, t38_interpret_parameters, data)) {
ao2_ref(data, -1);
}
} else if (f->frametype == AST_FRAME_MODEM) {
RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
session_media->udptl) {
ast_udptl_write(session_media->udptl, f);
}
}
return f;
}
/*! \brief Frame hook callback for reading */
static struct ast_frame *t38_framehook_read(struct ast_sip_session *session, struct ast_frame *f)
{
if (ast_channel_fdno(session->channel) == 5) {
RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
session_media->udptl) {
f = ast_udptl_read(session_media->udptl);
}
}
return f;
}
/*! \brief Frame hook callback for T.38 related stuff */
static struct ast_frame *t38_framehook(struct ast_channel *chan, struct ast_frame *f,
enum ast_framehook_event event, void *data)
{
struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
if (event == AST_FRAMEHOOK_EVENT_READ) {
f = t38_framehook_read(channel->session, f);
} else if (event == AST_FRAMEHOOK_EVENT_WRITE) {
f = t38_framehook_write(channel->session, f);
}
return f;
}
/*! \brief Function called to attach T.38 framehook to channel when appropriate */
static void t38_attach_framehook(struct ast_sip_session *session)
{
static struct ast_framehook_interface hook = {
.version = AST_FRAMEHOOK_INTERFACE_VERSION,
.event_cb = t38_framehook,
};
if ((ast_channel_state(session->channel) == AST_STATE_UP) || !session->endpoint->t38udptl) {
return;
}
if (ast_framehook_attach(session->channel, &hook) < 0) {
ast_log(LOG_WARNING, "Could not attach T.38 Frame hook to channel, T.38 will be unavailable on '%s'\n",
ast_channel_name(session->channel));
}
}
/*! \brief Function called when an INVITE goes out */
static int t38_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
{
t38_attach_framehook(session);
return 0;
}
/*! \brief Function called when an INVITE comes in */
static void t38_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
{
t38_attach_framehook(session);
}
/*! \brief Get Max T.38 Transmission rate from T38 capabilities */
static unsigned int t38_get_rate(enum ast_control_t38_rate rate)
{
switch (rate) {
case AST_T38_RATE_2400:
return 2400;
case AST_T38_RATE_4800:
return 4800;
case AST_T38_RATE_7200:
return 7200;
case AST_T38_RATE_9600:
return 9600;
case AST_T38_RATE_12000:
return 12000;
case AST_T38_RATE_14400:
return 14400;
default:
return 0;
}
}
/*! \brief Supplement for adding framehook to session channel */
static struct ast_sip_session_supplement t38_supplement = {
.method = "INVITE",
.priority = AST_SIP_SESSION_SUPPLEMENT_PRIORITY_CHANNEL + 1,
.incoming_request = t38_incoming_invite_request,
.outgoing_request = t38_outgoing_invite_request,
};
/*! \brief Parse a T.38 image stream and store the attribute information */
static void t38_interpret_sdp(struct t38_state *state, struct ast_sip_session *session, struct ast_sip_session_media *session_media,
const struct pjmedia_sdp_media *stream)
{
unsigned int attr_i;
for (attr_i = 0; attr_i < stream->attr_count; attr_i++) {
pjmedia_sdp_attr *attr = stream->attr[attr_i];
if (!pj_stricmp2(&attr->name, "t38faxmaxbuffer")) {
/* This is purposely left empty, it is unused */
} else if (!pj_stricmp2(&attr->name, "t38maxbitrate") || !pj_stricmp2(&attr->name, "t38faxmaxrate")) {
switch (pj_strtoul(&attr->value)) {
case 14400:
state->their_parms.rate = AST_T38_RATE_14400;
break;
case 12000:
state->their_parms.rate = AST_T38_RATE_12000;
break;
case 9600:
state->their_parms.rate = AST_T38_RATE_9600;
break;
case 7200:
state->their_parms.rate = AST_T38_RATE_7200;
break;
case 4800:
state->their_parms.rate = AST_T38_RATE_4800;
break;
case 2400:
state->their_parms.rate = AST_T38_RATE_2400;
break;
}
} else if (!pj_stricmp2(&attr->name, "t38faxversion")) {
state->their_parms.version = pj_strtoul(&attr->value);
} else if (!pj_stricmp2(&attr->name, "t38faxmaxdatagram") || !pj_stricmp2(&attr->name, "t38maxdatagram")) {
if (session->endpoint->t38udptl_maxdatagram) {
ast_udptl_set_far_max_datagram(session_media->udptl, session->endpoint->t38udptl_maxdatagram);
} else {
ast_udptl_set_far_max_datagram(session_media->udptl, pj_strtoul(&attr->value));
}
} else if (!pj_stricmp2(&attr->name, "t38faxfillbitremoval")) {
state->their_parms.fill_bit_removal = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxtranscodingmmr")) {
state->their_parms.transcoding_mmr = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxtranscodingjbig")) {
state->their_parms.transcoding_jbig = 1;
} else if (!pj_stricmp2(&attr->name, "t38faxratemanagement")) {
if (!pj_stricmp2(&attr->value, "localTCF")) {
state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_LOCAL_TCF;
} else if (!pj_stricmp2(&attr->value, "transferredTCF")) {
state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF;
}
} else if (!pj_stricmp2(&attr->name, "t38faxudpec")) {
if (!pj_stricmp2(&attr->value, "t38UDPRedundancy")) {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
} else if (!pj_stricmp2(&attr->value, "t38UDPFEC")) {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_FEC);
} else {
ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_NONE);
}
}
}
}
/*! \brief Function which defers an incoming media stream */
static int defer_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)
{
struct t38_state *state;
if (!session->endpoint->t38udptl) {
return 0;
}
if (t38_initialize_session(session, session_media)) {
return 0;
}
if (!(state = t38_state_get_or_alloc(session))) {
return 0;
}
t38_interpret_sdp(state, session, session_media, stream);
/* If they are initiating the re-invite we need to defer responding until later */
if (session->t38state == T38_DISABLED) {
t38_change_state(session, session_media, state, T38_PEER_REINVITE);
return 1;
}
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)
{
struct t38_state *state;
char host[NI_MAXHOST];
RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
if (!session->endpoint->t38udptl) {
return -1;
}
if (!(state = t38_state_get_or_alloc(session))) {
return -1;
}
if ((session->t38state == T38_REJECTED) || (session->t38state == T38_DISABLED)) {
t38_change_state(session, session_media, state, T38_DISABLED);
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_INET) <= 0) {
/* The provided host was actually invalid so we error out this negotiation */
return -1;
}
/* Check the address family to make sure it matches configured */
if ((ast_sockaddr_is_ipv6(addrs) && !session->endpoint->t38udptl_ipv6) ||
(ast_sockaddr_is_ipv4(addrs) && session->endpoint->t38udptl_ipv6)) {
/* The address does not match configured */
return -1;
}
return 1;
}
/*! \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_UDPTL = { "udptl", 5 };
static const pj_str_t STR_T38 = { "t38", 3 };
static const pj_str_t STR_TRANSFERREDTCF = { "transferredTCF", 14 };
static const pj_str_t STR_LOCALTCF = { "localTCF", 8 };
static const pj_str_t STR_T38UDPFEC = { "t38UDPFEC", 9 };
static const pj_str_t STR_T38UDPREDUNDANCY = { "t38UDPRedundancy", 16 };
struct t38_state *state;
pjmedia_sdp_media *media;
char hostip[PJ_INET6_ADDRSTRLEN+2];
struct ast_sockaddr addr;
char tmp[512];
pj_str_t stmp;
if (!session->endpoint->t38udptl) {
return 1;
} else if ((session->t38state != T38_LOCAL_REINVITE) && (session->t38state != T38_PEER_REINVITE) &&
(session->t38state != T38_ENABLED)) {
return 1;
} else if (!(state = t38_state_get_or_alloc(session))) {
return -1;
} else if (t38_initialize_session(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;
}
media->desc.media = pj_str(session_media->stream_type);
media->desc.transport = STR_UDPTL;
if (ast_strlen_zero(session->endpoint->external_media_address)) {
pj_sockaddr localaddr;
if (pj_gethostip(session->endpoint->t38udptl_ipv6 ? pj_AF_INET6() : pj_AF_INET(), &localaddr)) {
return -1;
}
pj_sockaddr_print(&localaddr, hostip, sizeof(hostip), 2);
} else {
ast_copy_string(hostip, session->endpoint->external_media_address, sizeof(hostip));
}
media->conn->net_type = STR_IN;
media->conn->addr_type = session->endpoint->t38udptl_ipv6 ? STR_IP6 : STR_IP4;
pj_strdup2(pool, &media->conn->addr, hostip);
ast_udptl_get_us(session_media->udptl, &addr);
media->desc.port = (pj_uint16_t) ast_sockaddr_port(&addr);
media->desc.port_count = 1;
media->desc.fmt[media->desc.fmt_count++] = STR_T38;
snprintf(tmp, sizeof(tmp), "%d", state->our_parms.version);
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxVersion", pj_cstr(&stmp, tmp));
snprintf(tmp, sizeof(tmp), "%d", t38_get_rate(state->our_parms.rate));
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38MaxBitRate", pj_cstr(&stmp, tmp));
if (state->our_parms.fill_bit_removal) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxFillBitRemoval", NULL);
}
if (state->our_parms.transcoding_mmr) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingMMR", NULL);
}
if (state->our_parms.transcoding_jbig) {
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingJBIG", NULL);
}
switch (state->our_parms.rate_management) {
case AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_TRANSFERREDTCF);
break;
case AST_T38_RATE_MANAGEMENT_LOCAL_TCF:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_LOCALTCF);
break;
}
snprintf(tmp, sizeof(tmp), "%d", ast_udptl_get_local_max_datagram(session_media->udptl));
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxMaxDatagram", pj_cstr(&stmp, tmp));
switch (ast_udptl_get_error_correction_scheme(session_media->udptl)) {
case UDPTL_ERROR_CORRECTION_NONE:
break;
case UDPTL_ERROR_CORRECTION_FEC:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPFEC);
break;
case UDPTL_ERROR_CORRECTION_REDUNDANCY:
media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPREDUNDANCY);
break;
}
sdp->media[sdp->media_count++] = media;
return 1;
}
/*! \brief Function which applies a negotiated stream */
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_ptr);
char host[NI_MAXHOST];
struct t38_state *state;
if (!session_media->udptl) {
return 0;
}
if (!(state = t38_state_get_or_alloc(session))) {
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;
}
ast_sockaddr_set_port(addrs, remote_stream->desc.port);
ast_udptl_set_peer(session_media->udptl, addrs);
t38_interpret_sdp(state, session, session_media, remote_stream);
return 0;
}
/*! \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)
{
char host[NI_MAXHOST];
struct ast_sockaddr addr = { { 0, } };
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->localnet, &addr) == AST_SENSE_ALLOW) {
return;
}
pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
}
/*! \brief Function which destroys the UDPTL instance when session ends */
static void stream_destroy(struct ast_sip_session_media *session_media)
{
if (session_media->udptl) {
ast_udptl_destroy(session_media->udptl);
}
}
/*! \brief SDP handler for 'image' media stream */
static struct ast_sip_session_sdp_handler image_sdp_handler = {
.id = "image",
.defer_incoming_sdp_stream = defer_incoming_sdp_stream,
.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_destroy = stream_destroy,
};
/*! \brief Unloads the SIP T.38 module from Asterisk */
static int unload_module(void)
{
ast_sip_session_unregister_sdp_handler(&image_sdp_handler, "image");
ast_sip_session_unregister_supplement(&t38_supplement);
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)
{
ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
ast_sockaddr_parse(&address_ipv6, "::", 0);
if (ast_sip_session_register_supplement(&t38_supplement)) {
ast_log(LOG_ERROR, "Unable to register T.38 session supplement\n");
goto end;
}
if (ast_sip_session_register_sdp_handler(&image_sdp_handler, "image")) {
ast_log(LOG_ERROR, "Unable to register SDP handler for image stream type\n");
goto end;
}
return AST_MODULE_LOAD_SUCCESS;
end:
unload_module();
return AST_MODULE_LOAD_FAILURE;
}
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "SIP T.38 UDPTL Support",
.load = load_module,
.unload = unload_module,
.load_pri = AST_MODPRI_CHANNEL_DRIVER,
);