From 7fded3378948b9076cc092145bb4823a50b8501c Mon Sep 17 00:00:00 2001 From: Joshua Colp Date: Tue, 30 Jul 2013 14:16:41 +0000 Subject: Add support for T.38 fax to chan_pjsip. Review: https://reviewboard.asterisk.org/r/2692/ git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@395731 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- channels/chan_gulp.c | 117 ++++- include/asterisk/res_sip.h | 14 + include/asterisk/res_sip_session.h | 49 ++- res/res_sip.c | 50 +++ res/res_sip/sip_configuration.c | 24 ++ res/res_sip_session.c | 180 +++++++- res/res_sip_session.exports.in | 1 + res/res_sip_t38.c | 853 +++++++++++++++++++++++++++++++++++++ 8 files changed, 1272 insertions(+), 16 deletions(-) create mode 100644 res/res_sip_t38.c diff --git a/channels/chan_gulp.c b/channels/chan_gulp.c index 3e53b51cf..95cf072c7 100644 --- a/channels/chan_gulp.c +++ b/channels/chan_gulp.c @@ -142,6 +142,7 @@ static int gulp_indicate(struct ast_channel *ast, int condition, const void *dat static int gulp_transfer(struct ast_channel *ast, const char *target); static int gulp_fixup(struct ast_channel *oldchan, struct ast_channel *newchan); static int gulp_devicestate(const char *data); +static int gulp_queryoption(struct ast_channel *ast, int option, void *data, int *datalen); /*! \brief PBX interface structure for channel registration */ static struct ast_channel_tech gulp_tech = { @@ -162,6 +163,7 @@ static struct ast_channel_tech gulp_tech = { .transfer = gulp_transfer, .fixup = gulp_fixup, .devicestate = gulp_devicestate, + .queryoption = gulp_queryoption, .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER }; @@ -431,7 +433,7 @@ static int send_direct_media_request(void *data) { RAII_VAR(struct ast_sip_session *, session, data, ao2_cleanup); - return ast_sip_session_refresh(session, NULL, NULL, session->endpoint->direct_media_method, 1); + return ast_sip_session_refresh(session, NULL, NULL, NULL, session->endpoint->direct_media_method, 1); } static struct ast_datastore_info direct_media_mitigation_info = { }; @@ -668,6 +670,55 @@ static int gulp_answer(struct ast_channel *ast) return 0; } +/*! \brief Internal helper function called when CNG tone is detected */ +static struct ast_frame *gulp_cng_tone_detected(struct ast_sip_session *session, struct ast_frame *f) +{ + const char *target_context; + int exists; + + /* If we only needed this DSP for fax detection purposes we can just drop it now */ + if (session->endpoint->dtmf == AST_SIP_DTMF_INBAND) { + ast_dsp_set_features(session->dsp, DSP_FEATURE_DIGIT_DETECT); + } else { + ast_dsp_free(session->dsp); + session->dsp = NULL; + } + + /* If already executing in the fax extension don't do anything */ + if (!strcmp(ast_channel_exten(session->channel), "fax")) { + return f; + } + + target_context = S_OR(ast_channel_macrocontext(session->channel), ast_channel_context(session->channel)); + + /* We need to unlock the channel here because ast_exists_extension has the + * potential to start and stop an autoservice on the channel. Such action + * is prone to deadlock if the channel is locked. + */ + ast_channel_unlock(session->channel); + exists = ast_exists_extension(session->channel, target_context, "fax", 1, + S_COR(ast_channel_caller(session->channel)->id.number.valid, + ast_channel_caller(session->channel)->id.number.str, NULL)); + ast_channel_lock(session->channel); + + if (exists) { + ast_verb(2, "Redirecting '%s' to fax extension due to CNG detection\n", + ast_channel_name(session->channel)); + pbx_builtin_setvar_helper(session->channel, "FAXEXTEN", ast_channel_exten(session->channel)); + if (ast_async_goto(session->channel, target_context, "fax", 1)) { + ast_log(LOG_ERROR, "Failed to async goto '%s' into fax extension in '%s'\n", + ast_channel_name(session->channel), target_context); + } + ast_frfree(f); + f = &ast_null_frame; + } else { + ast_log(LOG_NOTICE, "FAX CNG detected on '%s' but no fax extension in '%s'\n", + ast_channel_name(session->channel), target_context); + } + + return f; +} + /*! \brief Function called by core to read any waiting frames */ static struct ast_frame *gulp_read(struct ast_channel *ast) { @@ -718,8 +769,13 @@ static struct ast_frame *gulp_read(struct ast_channel *ast) f = ast_dsp_process(ast, channel->session->dsp, f); if (f && (f->frametype == AST_FRAME_DTMF)) { - ast_debug(3, "* Detected inband DTMF '%c' on '%s'\n", f->subclass.integer, - ast_channel_name(ast)); + if (f->subclass.integer == 'f') { + ast_debug(3, "Fax CNG detected on %s\n", ast_channel_name(ast)); + f = gulp_cng_tone_detected(channel->session, f); + } else { + ast_debug(3, "* Detected inband DTMF '%c' on '%s'\n", f->subclass.integer, + ast_channel_name(ast)); + } } } @@ -761,6 +817,8 @@ static int gulp_write(struct ast_channel *ast, struct ast_frame *frame) res = ast_rtp_instance_write(media->rtp, frame); } break; + case AST_FRAME_MODEM: + break; default: ast_log(LOG_WARNING, "Can't send %d type frames with Gulp\n", frame->frametype); break; @@ -874,6 +932,45 @@ static int gulp_devicestate(const char *data) return state; } +/*! \brief Function called to query options on a channel */ +static int gulp_queryoption(struct ast_channel *ast, int option, void *data, int *datalen) +{ + struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(ast); + struct ast_sip_session *session = channel->session; + int res = -1; + enum ast_sip_session_t38state state = T38_STATE_UNAVAILABLE; + + switch (option) { + case AST_OPTION_T38_STATE: + if (session->endpoint->t38udptl) { + switch (session->t38state) { + case T38_LOCAL_REINVITE: + case T38_PEER_REINVITE: + state = T38_STATE_NEGOTIATING; + break; + case T38_ENABLED: + state = T38_STATE_NEGOTIATED; + break; + case T38_REJECTED: + state = T38_STATE_REJECTED; + break; + default: + state = T38_STATE_UNKNOWN; + break; + } + } + + *((enum ast_t38_state *) data) = state; + res = 0; + + break; + default: + break; + } + + return res; +} + struct indicate_data { struct ast_sip_session *session; int condition; @@ -994,7 +1091,7 @@ static int update_connected_line_information(void *data) method = AST_SIP_SESSION_REFRESH_METHOD_UPDATE; } - ast_sip_session_refresh(session, NULL, NULL, method, 0); + ast_sip_session_refresh(session, NULL, NULL, NULL, method, 0); } return 0; @@ -1097,6 +1194,18 @@ static int gulp_indicate(struct ast_channel *ast, int condition, const void *dat } else { res = -1; } + break; + case AST_CONTROL_T38_PARAMETERS: + res = 0; + + if (channel->session->t38state == T38_PEER_REINVITE) { + const struct ast_control_t38_parameters *parameters = data; + + if (parameters->request_response == AST_T38_REQUEST_PARMS) { + res = AST_T38_REQUEST_PARMS; + } + } + break; case -1: res = -1; diff --git a/include/asterisk/res_sip.h b/include/asterisk/res_sip.h index 01d50bfb9..ed24f1e1b 100644 --- a/include/asterisk/res_sip.h +++ b/include/asterisk/res_sip.h @@ -32,6 +32,8 @@ #include "asterisk/dnsmgr.h" /* Needed for ast_endpoint */ #include "asterisk/endpoints.h" +/* Needed for ast_t38_ec_modes */ +#include "asterisk/udptl.h" /* Needed for pj_sockaddr */ #include /* Needed for ast_rtp_dtls_cfg struct */ @@ -434,6 +436,18 @@ struct ast_sip_endpoint { struct ast_endpoint *persistent; /*! The number of channels at which busy device state is returned */ unsigned int devicestate_busy_at; + /*! Whether T.38 UDPTL support is enabled or not */ + unsigned int t38udptl; + /*! Error correction setting for T.38 UDPTL */ + enum ast_t38_ec_modes t38udptl_ec; + /*! Explicit T.38 max datagram value, may be 0 to indicate the remote side can be trusted */ + unsigned int t38udptl_maxdatagram; + /*! Whether fax detection is enabled or not (CNG tone detection) */ + unsigned int faxdetect; + /*! Whether NAT Support is enabled for T.38 UDPTL sessions or not */ + unsigned int t38udptl_nat; + /*! Whether to use IPv6 for UDPTL or not */ + unsigned int t38udptl_ipv6; /*! Determines if transfers (using REFER) are allowed by this endpoint */ unsigned int allowtransfer; /*! DSCP TOS bits for audio streams */ diff --git a/include/asterisk/res_sip_session.h b/include/asterisk/res_sip_session.h index fb482db9b..4c5ac5534 100644 --- a/include/asterisk/res_sip_session.h +++ b/include/asterisk/res_sip_session.h @@ -43,6 +43,16 @@ struct ast_party_id; struct pjmedia_sdp_media; struct pjmedia_sdp_session; struct ast_dsp; +struct ast_udptl; + +/*! \brief T.38 states for a session */ +enum ast_sip_session_t38state { + T38_DISABLED = 0, /*!< Not enabled */ + T38_LOCAL_REINVITE, /*!< Offered from local - REINVITE */ + T38_PEER_REINVITE, /*!< Offered from peer - REINVITE */ + T38_ENABLED, /*!< Negotiated (enabled) */ + T38_REJECTED, /*!< Refused */ +}; struct ast_sip_session_sdp_handler; @@ -50,8 +60,12 @@ struct ast_sip_session_sdp_handler; * \brief A structure containing SIP session media information */ struct ast_sip_session_media { - /*! \brief RTP instance itself */ - struct ast_rtp_instance *rtp; + union { + /*! \brief RTP instance itself */ + struct ast_rtp_instance *rtp; + /*! \brief UDPTL instance itself */ + struct ast_udptl *udptl; + }; /*! \brief Direct media address */ struct ast_sockaddr direct_media_addr; /*! \brief SDP handler that setup the RTP */ @@ -113,10 +127,15 @@ struct ast_sip_session { struct ast_dsp *dsp; /* Whether the termination of the session should be deferred */ unsigned int defer_terminate:1; + /* Deferred incoming re-invite */ + pjsip_rx_data *deferred_reinvite; + /* Current T.38 state */ + enum ast_sip_session_t38state t38state; }; typedef int (*ast_sip_session_request_creation_cb)(struct ast_sip_session *session, pjsip_tx_data *tdata); typedef int (*ast_sip_session_response_cb)(struct ast_sip_session *session, pjsip_rx_data *rdata); +typedef int (*ast_sip_session_sdp_creation_cb)(struct ast_sip_session *session, pjmedia_sdp_session *sdp); enum ast_sip_session_supplement_priority { /*! Top priority. Supplements with this priority are those that need to run before any others */ @@ -209,6 +228,19 @@ struct ast_sip_session_supplement { struct ast_sip_session_sdp_handler { /*! An identifier for this handler */ const char *id; + /*! + * \brief Determine whether a stream requires that the re-invite be deferred. + * If a stream can not be immediately negotiated the re-invite can be deferred and + * resumed at a later time. It is up to the handler which caused deferral to occur + * to resume it. + * \param session The session for which the media is being re-invited + * \param session_media The media being reinvited + * \param sdp The entire SDP. + * \retval 0 The stream was unhandled or does not need the re-invite to be deferred. + * \retval 1 Re-invite should be deferred and will be resumed later. No further operations will take place. + * \note This is optional, if not implemented the stream is assumed to not be deferred. + */ + 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); /*! * \brief Set session details based on a stream in an incoming SDP offer or answer * \param session The session for which the media is being negotiated @@ -443,6 +475,7 @@ void ast_sip_session_remove_datastore(struct ast_sip_session *session, const cha * * \param session The session on which the reinvite will be sent * \param on_request_creation Callback called when request is created + * \param on_sdp_creation Callback called when SDP is created * \param on_response Callback called when response for request is received * \param method The method that should be used when constructing the session refresh * \param generate_new_sdp Boolean to indicate if a new SDP should be created @@ -451,6 +484,7 @@ void ast_sip_session_remove_datastore(struct ast_sip_session *session, const cha */ int ast_sip_session_refresh(struct ast_sip_session *session, 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); @@ -513,4 +547,15 @@ void ast_sip_session_send_request_with_cb(struct ast_sip_session *session, pjsip */ struct ast_sip_session *ast_sip_dialog_get_session(pjsip_dialog *dlg); +/*! + * \brief Resumes processing of a deferred incoming re-invite + * + * \param session The session which has a pending incoming re-invite + * + * \note When resuming a re-invite it is given to the pjsip stack as if it + * had just been received from a transport, this means that the deferral + * callback will be called again. + */ +void ast_sip_session_resume_reinvite(struct ast_sip_session *session); + #endif /* _RES_SIP_SESSION_H */ diff --git a/res/res_sip.c b/res/res_sip.c index 7bab9131e..57c1bed17 100644 --- a/res/res_sip.c +++ b/res/res_sip.c @@ -398,6 +398,56 @@ Gulp channel driver will return busy as the device state instead of in use. + + Whether T.38 UDPTL support is enabled or not + + If set to yes T.38 UDPTL support will be enabled, and T.38 negotiation requests will be accepted + and relayed. + + + + T.38 UDPTL error correction method + + + + No error correction should be used. + + + Forward error correction should be used. + + + Redundacy error correction should be used. + + + + + + T.38 UDPTL maximum datagram size + + This option can be set to override the maximum datagram of a remote endpoint for broken + endpoints. + + + + Whether CNG tone detection is enabled + + This option can be set to send the session to the fax extension when a CNG tone is + detected. + + + + Whether NAT support is enabled on UDPTL sessions + + When enabled the UDPTL stack will send UDPTL packets to the source address of + received packets. + + + + Whether IPv6 is used for UDPTL Sessions + + When enabled the UDPTL stack will use IPv6. + + Set which country's indications to use for channels created for this endpoint. diff --git a/res/res_sip/sip_configuration.c b/res/res_sip/sip_configuration.c index 37a225f39..cb8dc9fd8 100644 --- a/res/res_sip/sip_configuration.c +++ b/res/res_sip/sip_configuration.c @@ -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)); diff --git a/res/res_sip_session.c b/res/res_sip_session.c index 402b791f2..22967c6ff 100644 --- a/res/res_sip_session.c +++ b/res/res_sip_session.c @@ -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; diff --git a/res/res_sip_session.exports.in b/res/res_sip_session.exports.in index a7afb1c30..55274f9cb 100644 --- a/res/res_sip_session.exports.in +++ b/res/res_sip_session.exports.in @@ -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: *; diff --git a/res/res_sip_t38.c b/res/res_sip_t38.c new file mode 100644 index 000000000..d9c57dec1 --- /dev/null +++ b/res/res_sip_t38.c @@ -0,0 +1,853 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2013, Digium, Inc. + * + * Joshua Colp + * + * 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 + * + * \brief SIP T.38 handling + */ + +/*** MODULEINFO + pjproject + res_sip + res_sip_session + core + ***/ + +#include "asterisk.h" + +#include +#include +#include +#include + +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, ¶meters, 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, ¶meters, 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, + ); -- cgit v1.2.3