2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 2013, Digium, Inc.
6 * Joshua Colp <jcolp@digium.com>
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
21 * \author Joshua Colp <jcolp@digium.com>
23 * \brief SIP T.38 handling
27 <depend>pjproject</depend>
28 <depend>res_pjsip</depend>
29 <depend>res_pjsip_session</depend>
30 <support_level>core</support_level>
40 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42 #include "asterisk/module.h"
43 #include "asterisk/udptl.h"
44 #include "asterisk/netsock2.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/acl.h"
48 #include "asterisk/res_pjsip.h"
49 #include "asterisk/res_pjsip_session.h"
51 /*! \brief The number of seconds after receiving a T.38 re-invite before automatically rejecting it */
52 #define T38_AUTOMATIC_REJECTION_SECONDS 5
54 /*! \brief Address for IPv4 UDPTL */
55 static struct ast_sockaddr address_ipv4;
57 /*! \brief Address for IPv6 UDPTL */
58 static struct ast_sockaddr address_ipv6;
60 /*! \brief T.38 state information */
62 /*! \brief Current state */
63 enum ast_sip_session_t38state state;
64 /*! \brief Our T.38 parameters */
65 struct ast_control_t38_parameters our_parms;
66 /*! \brief Their T.38 parameters */
67 struct ast_control_t38_parameters their_parms;
68 /*! \brief Timer entry for automatically rejecting an inbound re-invite */
72 /*! \brief Destructor for T.38 state information */
73 static void t38_state_destroy(void *obj)
78 /*! \brief Datastore for attaching T.38 state information */
79 static const struct ast_datastore_info t38_datastore = {
81 .destroy = t38_state_destroy,
84 /*! \brief Structure for T.38 parameters task data */
85 struct t38_parameters_task_data {
86 /*! \brief Session itself */
87 struct ast_sip_session *session;
88 /*! \brief T.38 control frame */
89 struct ast_frame *frame;
92 /*! \brief Destructor for T.38 data */
93 static void t38_parameters_task_data_destroy(void *obj)
95 struct t38_parameters_task_data *data = obj;
97 ao2_cleanup(data->session);
100 ast_frfree(data->frame);
104 /*! \brief Allocator for T.38 data */
105 static struct t38_parameters_task_data *t38_parameters_task_data_alloc(struct ast_sip_session *session,
106 struct ast_frame *frame)
108 struct t38_parameters_task_data *data = ao2_alloc(sizeof(*data), t38_parameters_task_data_destroy);
114 data->session = session;
115 ao2_ref(session, +1);
116 data->frame = ast_frdup(frame);
125 /*! \brief Helper function for changing the T.38 state */
126 static void t38_change_state(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
127 struct t38_state *state, enum ast_sip_session_t38state new_state)
129 enum ast_sip_session_t38state old_state = session->t38state;
130 struct ast_control_t38_parameters parameters = { .request_response = 0, };
131 pj_time_val delay = { .sec = T38_AUTOMATIC_REJECTION_SECONDS };
133 if (old_state == new_state) {
137 session->t38state = new_state;
138 ast_debug(2, "T.38 state changed to '%u' from '%u' on channel '%s'\n", new_state, old_state, ast_channel_name(session->channel));
140 if (pj_timer_heap_cancel(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()), &state->timer)) {
141 ast_debug(2, "Automatic T.38 rejection on channel '%s' terminated\n", ast_channel_name(session->channel));
142 ao2_ref(session, -1);
145 if (!session->channel) {
150 case T38_PEER_REINVITE:
151 ao2_ref(session, +1);
152 if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &state->timer, &delay) != PJ_SUCCESS) {
153 ast_log(LOG_WARNING, "Scheduling of automatic T.38 rejection for channel '%s' failed\n",
154 ast_channel_name(session->channel));
155 ao2_ref(session, -1);
157 parameters = state->their_parms;
158 parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
159 parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
160 ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
163 parameters = state->their_parms;
164 parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
165 parameters.request_response = AST_T38_NEGOTIATED;
166 ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
170 if (old_state == T38_ENABLED) {
171 parameters.request_response = AST_T38_TERMINATED;
172 } else if (old_state == T38_LOCAL_REINVITE) {
173 parameters.request_response = AST_T38_REFUSED;
176 case T38_LOCAL_REINVITE:
177 /* wait until we get a peer response before responding to local reinvite */
180 /* Well, that shouldn't happen */
185 if (parameters.request_response) {
186 ast_queue_control_data(session->channel, AST_CONTROL_T38_PARAMETERS, ¶meters, sizeof(parameters));
190 /*! \brief Task function which rejects a T.38 re-invite and resumes handling it */
191 static int t38_automatic_reject(void *obj)
193 RAII_VAR(struct ast_sip_session *, session, obj, ao2_cleanup);
194 RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
195 RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(session->media, "image", OBJ_KEY), ao2_cleanup);
201 ast_debug(2, "Automatically rejecting T.38 request on channel '%s'\n", ast_channel_name(session->channel));
203 t38_change_state(session, session_media, datastore->data, T38_REJECTED);
204 ast_sip_session_resume_reinvite(session);
209 /*! \brief Timer entry callback which queues a task to reject a T.38 re-invite and resume handling it */
210 static void t38_automatic_reject_timer_cb(pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
212 struct ast_sip_session *session = entry->user_data;
214 if (ast_sip_push_task(session->serializer, t38_automatic_reject, session)) {
215 ao2_ref(session, -1);
219 /*! \brief Helper function which retrieves or allocates a T.38 state information datastore */
220 static struct t38_state *t38_state_get_or_alloc(struct ast_sip_session *session)
222 RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
223 struct t38_state *state;
225 /* While the datastore refcount is decremented this is operating in the serializer so it will remain valid regardless */
227 return datastore->data;
230 if (!(datastore = ast_sip_session_alloc_datastore(&t38_datastore, "t38")) ||
231 !(datastore->data = ast_calloc(1, sizeof(struct t38_state))) ||
232 ast_sip_session_add_datastore(session, datastore)) {
236 state = datastore->data;
238 /* This will get bumped up before scheduling */
239 state->timer.user_data = session;
240 state->timer.cb = t38_automatic_reject_timer_cb;
242 datastore->data = state;
247 /*! \brief Initializes UDPTL support on a session, only done when actually needed */
248 static int t38_initialize_session(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
250 if (session_media->udptl) {
254 if (!(session_media->udptl = ast_udptl_new_with_bindaddr(NULL, NULL, 0,
255 session->endpoint->media.t38.ipv6 ? &address_ipv6 : &address_ipv4))) {
259 ast_channel_set_fd(session->channel, 5, ast_udptl_fd(session_media->udptl));
260 ast_udptl_set_error_correction_scheme(session_media->udptl, session->endpoint->media.t38.error_correction);
261 ast_udptl_setnat(session_media->udptl, session->endpoint->media.t38.nat);
266 /*! \brief Callback for when T.38 reinvite SDP is created */
267 static int t38_reinvite_sdp_cb(struct ast_sip_session *session, pjmedia_sdp_session *sdp)
271 /* Move the image media stream to the front and have it as the only stream, pjmedia will fill in
272 * dummy streams for the rest
274 for (stream = 0; stream < sdp->media_count++; ++stream) {
275 if (!pj_strcmp2(&sdp->media[stream]->desc.media, "image")) {
276 sdp->media[0] = sdp->media[stream];
277 sdp->media_count = 1;
285 /*! \brief Callback for when a response is received for a T.38 re-invite */
286 static int t38_reinvite_response_cb(struct ast_sip_session *session, pjsip_rx_data *rdata)
288 struct pjsip_status_line status = rdata->msg_info.msg->line.status;
289 struct t38_state *state;
290 RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
292 if (status.code == 100) {
296 if (!(state = t38_state_get_or_alloc(session)) ||
297 !(session_media = ao2_find(session->media, "image", OBJ_KEY))) {
298 ast_log(LOG_WARNING, "Received response to T.38 re-invite on '%s' but state unavailable\n",
299 ast_channel_name(session->channel));
303 t38_change_state(session, session_media, state, (status.code == 200) ? T38_ENABLED : T38_REJECTED);
308 /*! \brief Task for reacting to T.38 control frame */
309 static int t38_interpret_parameters(void *obj)
311 RAII_VAR(struct t38_parameters_task_data *, data, obj, ao2_cleanup);
312 const struct ast_control_t38_parameters *parameters = data->frame->data.ptr;
313 struct t38_state *state = t38_state_get_or_alloc(data->session);
314 RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(data->session->media, "image", OBJ_KEY), ao2_cleanup);
316 /* Without session media or state we can't interpret parameters */
317 if (!session_media || !state) {
321 switch (parameters->request_response) {
322 case AST_T38_NEGOTIATED:
323 case AST_T38_REQUEST_NEGOTIATE: /* Request T38 */
324 /* Negotiation can not take place without a valid max_ifp value. */
325 if (!parameters->max_ifp) {
326 t38_change_state(data->session, session_media, state, T38_REJECTED);
327 if (data->session->t38state == T38_PEER_REINVITE) {
328 ast_sip_session_resume_reinvite(data->session);
331 } else if (data->session->t38state == T38_PEER_REINVITE) {
332 state->our_parms = *parameters;
333 /* modify our parameters to conform to the peer's parameters,
334 * based on the rules in the ITU T.38 recommendation
336 if (!state->their_parms.fill_bit_removal) {
337 state->our_parms.fill_bit_removal = 0;
339 if (!state->their_parms.transcoding_mmr) {
340 state->our_parms.transcoding_mmr = 0;
342 if (!state->their_parms.transcoding_jbig) {
343 state->our_parms.transcoding_jbig = 0;
345 state->our_parms.version = MIN(state->our_parms.version, state->their_parms.version);
346 state->our_parms.rate_management = state->their_parms.rate_management;
347 ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
348 t38_change_state(data->session, session_media, state, T38_ENABLED);
349 ast_sip_session_resume_reinvite(data->session);
350 } else if (data->session->t38state != T38_ENABLED) {
351 if (t38_initialize_session(data->session, session_media)) {
354 state->our_parms = *parameters;
355 ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
356 t38_change_state(data->session, session_media, state, T38_LOCAL_REINVITE);
357 ast_sip_session_refresh(data->session, NULL, t38_reinvite_sdp_cb, t38_reinvite_response_cb,
358 AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
361 case AST_T38_TERMINATED:
362 case AST_T38_REFUSED:
363 case AST_T38_REQUEST_TERMINATE: /* Shutdown T38 */
364 if (data->session->t38state == T38_PEER_REINVITE) {
365 t38_change_state(data->session, session_media, state, T38_REJECTED);
366 ast_sip_session_resume_reinvite(data->session);
367 } else if (data->session->t38state == T38_ENABLED) {
368 t38_change_state(data->session, session_media, state, T38_DISABLED);
369 ast_sip_session_refresh(data->session, NULL, NULL, NULL, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
372 case AST_T38_REQUEST_PARMS: { /* Application wants remote's parameters re-sent */
373 struct ast_control_t38_parameters parameters = state->their_parms;
375 if (data->session->t38state == T38_PEER_REINVITE) {
376 parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
377 parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
378 ast_queue_control_data(data->session->channel, AST_CONTROL_T38_PARAMETERS, ¶meters, sizeof(parameters));
389 /*! \brief Frame hook callback for writing */
390 static struct ast_frame *t38_framehook_write(struct ast_sip_session *session, struct ast_frame *f)
392 if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_T38_PARAMETERS &&
393 session->endpoint->media.t38.enabled) {
394 struct t38_parameters_task_data *data = t38_parameters_task_data_alloc(session, f);
400 if (ast_sip_push_task(session->serializer, t38_interpret_parameters, data)) {
403 } else if (f->frametype == AST_FRAME_MODEM) {
404 RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
406 if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
407 session_media->udptl) {
408 ast_udptl_write(session_media->udptl, f);
415 /*! \brief Frame hook callback for reading */
416 static struct ast_frame *t38_framehook_read(struct ast_sip_session *session, struct ast_frame *f)
418 if (ast_channel_fdno(session->channel) == 5) {
419 RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
421 if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
422 session_media->udptl) {
423 f = ast_udptl_read(session_media->udptl);
430 /*! \brief Frame hook callback for T.38 related stuff */
431 static struct ast_frame *t38_framehook(struct ast_channel *chan, struct ast_frame *f,
432 enum ast_framehook_event event, void *data)
434 struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
436 if (event == AST_FRAMEHOOK_EVENT_READ) {
437 f = t38_framehook_read(channel->session, f);
438 } else if (event == AST_FRAMEHOOK_EVENT_WRITE) {
439 f = t38_framehook_write(channel->session, f);
445 static void t38_masq(void *data, int framehook_id,
446 struct ast_channel *old_chan, struct ast_channel *new_chan)
448 if (ast_channel_tech(old_chan) == ast_channel_tech(new_chan)) {
452 /* This framehook is only applicable to PJSIP channels */
453 ast_framehook_detach(new_chan, framehook_id);
456 /*! \brief Function called to attach T.38 framehook to channel when appropriate */
457 static void t38_attach_framehook(struct ast_sip_session *session)
459 static struct ast_framehook_interface hook = {
460 .version = AST_FRAMEHOOK_INTERFACE_VERSION,
461 .event_cb = t38_framehook,
462 .chan_fixup_cb = t38_masq,
463 .chan_breakdown_cb = t38_masq,
466 /* Only attach the framehook on the first outgoing INVITE or the first incoming INVITE */
467 if ((session->inv_session->state != PJSIP_INV_STATE_NULL &&
468 session->inv_session->state != PJSIP_INV_STATE_INCOMING) ||
469 !session->endpoint->media.t38.enabled) {
473 if (ast_framehook_attach(session->channel, &hook) < 0) {
474 ast_log(LOG_WARNING, "Could not attach T.38 Frame hook to channel, T.38 will be unavailable on '%s'\n",
475 ast_channel_name(session->channel));
479 /*! \brief Function called when an INVITE goes out */
480 static int t38_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
482 t38_attach_framehook(session);
486 /*! \brief Function called when an INVITE comes in */
487 static void t38_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
489 t38_attach_framehook(session);
492 /*! \brief Get Max T.38 Transmission rate from T38 capabilities */
493 static unsigned int t38_get_rate(enum ast_control_t38_rate rate)
496 case AST_T38_RATE_2400:
498 case AST_T38_RATE_4800:
500 case AST_T38_RATE_7200:
502 case AST_T38_RATE_9600:
504 case AST_T38_RATE_12000:
506 case AST_T38_RATE_14400:
513 /*! \brief Supplement for adding framehook to session channel */
514 static struct ast_sip_session_supplement t38_supplement = {
516 .priority = AST_SIP_SUPPLEMENT_PRIORITY_CHANNEL + 1,
517 .incoming_request = t38_incoming_invite_request,
518 .outgoing_request = t38_outgoing_invite_request,
521 /*! \brief Parse a T.38 image stream and store the attribute information */
522 static void t38_interpret_sdp(struct t38_state *state, struct ast_sip_session *session, struct ast_sip_session_media *session_media,
523 const struct pjmedia_sdp_media *stream)
527 for (attr_i = 0; attr_i < stream->attr_count; attr_i++) {
528 pjmedia_sdp_attr *attr = stream->attr[attr_i];
530 if (!pj_stricmp2(&attr->name, "t38faxmaxbuffer")) {
531 /* This is purposely left empty, it is unused */
532 } else if (!pj_stricmp2(&attr->name, "t38maxbitrate") || !pj_stricmp2(&attr->name, "t38faxmaxrate")) {
533 switch (pj_strtoul(&attr->value)) {
535 state->their_parms.rate = AST_T38_RATE_14400;
538 state->their_parms.rate = AST_T38_RATE_12000;
541 state->their_parms.rate = AST_T38_RATE_9600;
544 state->their_parms.rate = AST_T38_RATE_7200;
547 state->their_parms.rate = AST_T38_RATE_4800;
550 state->their_parms.rate = AST_T38_RATE_2400;
553 } else if (!pj_stricmp2(&attr->name, "t38faxversion")) {
554 state->their_parms.version = pj_strtoul(&attr->value);
555 } else if (!pj_stricmp2(&attr->name, "t38faxmaxdatagram") || !pj_stricmp2(&attr->name, "t38maxdatagram")) {
556 if (session->endpoint->media.t38.maxdatagram) {
557 ast_udptl_set_far_max_datagram(session_media->udptl, session->endpoint->media.t38.maxdatagram);
559 ast_udptl_set_far_max_datagram(session_media->udptl, pj_strtoul(&attr->value));
561 } else if (!pj_stricmp2(&attr->name, "t38faxfillbitremoval")) {
562 state->their_parms.fill_bit_removal = 1;
563 } else if (!pj_stricmp2(&attr->name, "t38faxtranscodingmmr")) {
564 state->their_parms.transcoding_mmr = 1;
565 } else if (!pj_stricmp2(&attr->name, "t38faxtranscodingjbig")) {
566 state->their_parms.transcoding_jbig = 1;
567 } else if (!pj_stricmp2(&attr->name, "t38faxratemanagement")) {
568 if (!pj_stricmp2(&attr->value, "localTCF")) {
569 state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_LOCAL_TCF;
570 } else if (!pj_stricmp2(&attr->value, "transferredTCF")) {
571 state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF;
573 } else if (!pj_stricmp2(&attr->name, "t38faxudpec")) {
574 if (!pj_stricmp2(&attr->value, "t38UDPRedundancy")) {
575 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
576 } else if (!pj_stricmp2(&attr->value, "t38UDPFEC")) {
577 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_FEC);
579 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_NONE);
586 /*! \brief Function which defers an incoming media stream */
587 static enum ast_sip_session_sdp_stream_defer defer_incoming_sdp_stream(
588 struct ast_sip_session *session, struct ast_sip_session_media *session_media,
589 const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
591 struct t38_state *state;
593 if (!session->endpoint->media.t38.enabled) {
594 return AST_SIP_SESSION_SDP_DEFER_NOT_HANDLED;
597 if (t38_initialize_session(session, session_media)) {
598 return AST_SIP_SESSION_SDP_DEFER_ERROR;
601 if (!(state = t38_state_get_or_alloc(session))) {
602 return AST_SIP_SESSION_SDP_DEFER_ERROR;
605 t38_interpret_sdp(state, session, session_media, stream);
607 /* If they are initiating the re-invite we need to defer responding until later */
608 if (session->t38state == T38_DISABLED) {
609 t38_change_state(session, session_media, state, T38_PEER_REINVITE);
610 return AST_SIP_SESSION_SDP_DEFER_NEEDED;
613 return AST_SIP_SESSION_SDP_DEFER_NOT_NEEDED;
616 /*! \brief Function which negotiates an incoming media stream */
617 static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
618 const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
620 struct t38_state *state;
621 char host[NI_MAXHOST];
622 RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
624 if (!session->endpoint->media.t38.enabled) {
628 if (!(state = t38_state_get_or_alloc(session))) {
632 if ((session->t38state == T38_REJECTED) || (session->t38state == T38_DISABLED)) {
633 t38_change_state(session, session_media, state, T38_DISABLED);
637 ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
639 /* Ensure that the address provided is valid */
640 if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_INET) <= 0) {
641 /* The provided host was actually invalid so we error out this negotiation */
645 /* Check the address family to make sure it matches configured */
646 if ((ast_sockaddr_is_ipv6(addrs) && !session->endpoint->media.t38.ipv6) ||
647 (ast_sockaddr_is_ipv4(addrs) && session->endpoint->media.t38.ipv6)) {
648 /* The address does not match configured */
655 /*! \brief Function which creates an outgoing stream */
656 static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
657 struct pjmedia_sdp_session *sdp)
659 pj_pool_t *pool = session->inv_session->pool_prov;
660 static const pj_str_t STR_IN = { "IN", 2 };
661 static const pj_str_t STR_IP4 = { "IP4", 3};
662 static const pj_str_t STR_IP6 = { "IP6", 3};
663 static const pj_str_t STR_UDPTL = { "udptl", 5 };
664 static const pj_str_t STR_T38 = { "t38", 3 };
665 static const pj_str_t STR_TRANSFERREDTCF = { "transferredTCF", 14 };
666 static const pj_str_t STR_LOCALTCF = { "localTCF", 8 };
667 static const pj_str_t STR_T38UDPFEC = { "t38UDPFEC", 9 };
668 static const pj_str_t STR_T38UDPREDUNDANCY = { "t38UDPRedundancy", 16 };
669 struct t38_state *state;
670 pjmedia_sdp_media *media;
671 char hostip[PJ_INET6_ADDRSTRLEN+2];
672 struct ast_sockaddr addr;
676 if (!session->endpoint->media.t38.enabled) {
678 } else if ((session->t38state != T38_LOCAL_REINVITE) && (session->t38state != T38_PEER_REINVITE) &&
679 (session->t38state != T38_ENABLED)) {
681 } else if (!(state = t38_state_get_or_alloc(session))) {
683 } else if (t38_initialize_session(session, session_media)) {
687 if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
688 !(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
692 media->desc.media = pj_str(session_media->stream_type);
693 media->desc.transport = STR_UDPTL;
695 if (ast_strlen_zero(session->endpoint->media.address)) {
696 pj_sockaddr localaddr;
698 if (pj_gethostip(session->endpoint->media.t38.ipv6 ? pj_AF_INET6() : pj_AF_INET(), &localaddr)) {
701 pj_sockaddr_print(&localaddr, hostip, sizeof(hostip), 2);
703 ast_copy_string(hostip, session->endpoint->media.address, sizeof(hostip));
706 media->conn->net_type = STR_IN;
707 media->conn->addr_type = session->endpoint->media.t38.ipv6 ? STR_IP6 : STR_IP4;
708 pj_strdup2(pool, &media->conn->addr, hostip);
709 ast_udptl_get_us(session_media->udptl, &addr);
710 media->desc.port = (pj_uint16_t) ast_sockaddr_port(&addr);
711 media->desc.port_count = 1;
712 media->desc.fmt[media->desc.fmt_count++] = STR_T38;
714 snprintf(tmp, sizeof(tmp), "%u", state->our_parms.version);
715 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxVersion", pj_cstr(&stmp, tmp));
717 snprintf(tmp, sizeof(tmp), "%u", t38_get_rate(state->our_parms.rate));
718 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38MaxBitRate", pj_cstr(&stmp, tmp));
720 if (state->our_parms.fill_bit_removal) {
721 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxFillBitRemoval", NULL);
724 if (state->our_parms.transcoding_mmr) {
725 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingMMR", NULL);
728 if (state->our_parms.transcoding_jbig) {
729 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingJBIG", NULL);
732 switch (state->our_parms.rate_management) {
733 case AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF:
734 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_TRANSFERREDTCF);
736 case AST_T38_RATE_MANAGEMENT_LOCAL_TCF:
737 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_LOCALTCF);
741 snprintf(tmp, sizeof(tmp), "%u", ast_udptl_get_local_max_datagram(session_media->udptl));
742 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxMaxDatagram", pj_cstr(&stmp, tmp));
744 switch (ast_udptl_get_error_correction_scheme(session_media->udptl)) {
745 case UDPTL_ERROR_CORRECTION_NONE:
747 case UDPTL_ERROR_CORRECTION_FEC:
748 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPFEC);
750 case UDPTL_ERROR_CORRECTION_REDUNDANCY:
751 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPREDUNDANCY);
755 sdp->media[sdp->media_count++] = media;
760 /*! \brief Function which applies a negotiated stream */
761 static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
762 const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
763 const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
765 RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
766 char host[NI_MAXHOST];
767 struct t38_state *state;
769 if (!session_media->udptl) {
773 if (!(state = t38_state_get_or_alloc(session))) {
777 ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
779 /* Ensure that the address provided is valid */
780 if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
781 /* The provided host was actually invalid so we error out this negotiation */
785 ast_sockaddr_set_port(addrs, remote_stream->desc.port);
786 ast_udptl_set_peer(session_media->udptl, addrs);
788 t38_interpret_sdp(state, session, session_media, remote_stream);
793 /*! \brief Function which updates the media stream with external media address, if applicable */
794 static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
796 char host[NI_MAXHOST];
797 struct ast_sockaddr addr = { { 0, } };
799 /* If the stream has been rejected there will be no connection line */
804 ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
805 ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
807 /* Is the address within the SDP inside the same network? */
808 if (ast_apply_ha(transport->localnet, &addr) == AST_SENSE_ALLOW) {
812 pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
815 /*! \brief Function which destroys the UDPTL instance when session ends */
816 static void stream_destroy(struct ast_sip_session_media *session_media)
818 if (session_media->udptl) {
819 ast_udptl_destroy(session_media->udptl);
823 /*! \brief SDP handler for 'image' media stream */
824 static struct ast_sip_session_sdp_handler image_sdp_handler = {
826 .defer_incoming_sdp_stream = defer_incoming_sdp_stream,
827 .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
828 .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
829 .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
830 .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
831 .stream_destroy = stream_destroy,
834 /*! \brief Unloads the SIP T.38 module from Asterisk */
835 static int unload_module(void)
837 ast_sip_session_unregister_sdp_handler(&image_sdp_handler, "image");
838 ast_sip_session_unregister_supplement(&t38_supplement);
844 * \brief Load the module
846 * Module loading including tests for configuration or dependencies.
847 * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
848 * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
849 * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
850 * configuration file or other non-critical problem return
851 * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
853 static int load_module(void)
855 CHECK_PJSIP_SESSION_MODULE_LOADED();
857 ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
858 ast_sockaddr_parse(&address_ipv6, "::", 0);
860 if (ast_sip_session_register_supplement(&t38_supplement)) {
861 ast_log(LOG_ERROR, "Unable to register T.38 session supplement\n");
865 if (ast_sip_session_register_sdp_handler(&image_sdp_handler, "image")) {
866 ast_log(LOG_ERROR, "Unable to register SDP handler for image stream type\n");
870 return AST_MODULE_LOAD_SUCCESS;
874 return AST_MODULE_LOAD_FAILURE;
877 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP T.38 UDPTL Support",
878 .support_level = AST_MODULE_SUPPORT_CORE,
880 .unload = unload_module,
881 .load_pri = AST_MODPRI_CHANNEL_DRIVER,