afe12505d275186c5457909c9eafeebb75221141
[asterisk/asterisk.git] / res / res_pjsip_t38.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
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.
13  *
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.
17  */
18
19 /*! \file
20  *
21  * \author Joshua Colp <jcolp@digium.com>
22  *
23  * \brief SIP T.38 handling
24  */
25
26 /*** MODULEINFO
27         <depend>pjproject</depend>
28         <depend>res_pjsip</depend>
29         <depend>res_pjsip_session</depend>
30         <support_level>core</support_level>
31  ***/
32
33 #include "asterisk.h"
34
35 #include <pjsip.h>
36 #include <pjsip_ua.h>
37 #include <pjmedia.h>
38 #include <pjlib.h>
39
40 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
41
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"
47
48 #include "asterisk/res_pjsip.h"
49 #include "asterisk/res_pjsip_session.h"
50
51 /*! \brief The number of seconds after receiving a T.38 re-invite before automatically rejecting it */
52 #define T38_AUTOMATIC_REJECTION_SECONDS 5
53
54 /*! \brief Address for IPv4 UDPTL */
55 static struct ast_sockaddr address_ipv4;
56
57 /*! \brief Address for IPv6 UDPTL */
58 static struct ast_sockaddr address_ipv6;
59
60 /*! \brief T.38 state information */
61 struct t38_state {
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 */
69         pj_timer_entry timer;
70 };
71
72 /*! \brief Destructor for T.38 state information */
73 static void t38_state_destroy(void *obj)
74 {
75         ast_free(obj);
76 }
77
78 /*! \brief Datastore for attaching T.38 state information */
79 static const struct ast_datastore_info t38_datastore = {
80         .type = "t38",
81         .destroy = t38_state_destroy,
82 };
83
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;
90 };
91
92 /*! \brief Destructor for T.38 data */
93 static void t38_parameters_task_data_destroy(void *obj)
94 {
95         struct t38_parameters_task_data *data = obj;
96
97         ao2_cleanup(data->session);
98
99         if (data->frame) {
100                 ast_frfree(data->frame);
101         }
102 }
103
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)
107 {
108         struct t38_parameters_task_data *data = ao2_alloc(sizeof(*data), t38_parameters_task_data_destroy);
109
110         if (!data) {
111                 return NULL;
112         }
113
114         data->session = session;
115         ao2_ref(session, +1);
116         data->frame = frame;
117
118         return data;
119 }
120
121 /*! \brief Helper function for changing the T.38 state */
122 static void t38_change_state(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
123         struct t38_state *state, enum ast_sip_session_t38state new_state)
124 {
125         enum ast_sip_session_t38state old_state = session->t38state;
126         struct ast_control_t38_parameters parameters = { .request_response = 0, };
127         pj_time_val delay = { .sec = T38_AUTOMATIC_REJECTION_SECONDS };
128
129         if (old_state == new_state) {
130                 return;
131         }
132
133         session->t38state = new_state;
134         ast_debug(2, "T.38 state changed to '%d' from '%d' on channel '%s'\n", new_state, old_state, ast_channel_name(session->channel));
135
136         if (pj_timer_heap_cancel(pjsip_endpt_get_timer_heap(ast_sip_get_pjsip_endpoint()), &state->timer)) {
137                 ast_debug(2, "Automatic T.38 rejection on channel '%s' terminated\n", ast_channel_name(session->channel));
138                 ao2_ref(session, -1);
139         }
140
141         if (!session->channel) {
142                 return;
143         }
144
145         switch (new_state) {
146         case T38_PEER_REINVITE:
147                 ao2_ref(session, +1);
148                 if (pjsip_endpt_schedule_timer(ast_sip_get_pjsip_endpoint(), &state->timer, &delay) != PJ_SUCCESS) {
149                         ast_log(LOG_WARNING, "Scheduling of automatic T.38 rejection for channel '%s' failed\n",
150                                 ast_channel_name(session->channel));
151                         ao2_ref(session, -1);
152                 }
153                 parameters = state->their_parms;
154                 parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
155                 parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
156                 ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
157                 break;
158         case T38_ENABLED:
159                 parameters = state->their_parms;
160                 parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
161                 parameters.request_response = AST_T38_NEGOTIATED;
162                 ast_udptl_set_tag(session_media->udptl, "%s", ast_channel_name(session->channel));
163                 break;
164         case T38_REJECTED:
165         case T38_DISABLED:
166                 if (old_state == T38_ENABLED) {
167                         parameters.request_response = AST_T38_TERMINATED;
168                 } else if (old_state == T38_LOCAL_REINVITE) {
169                         parameters.request_response = AST_T38_REFUSED;
170                 }
171                 break;
172         case T38_LOCAL_REINVITE:
173                 /* wait until we get a peer response before responding to local reinvite */
174                 break;
175         case T38_MAX_ENUM:
176                 /* Well, that shouldn't happen */
177                 ast_assert(0);
178                 break;
179         }
180
181         if (parameters.request_response) {
182                 ast_queue_control_data(session->channel, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
183         }
184 }
185
186 /*! \brief Task function which rejects a T.38 re-invite and resumes handling it */
187 static int t38_automatic_reject(void *obj)
188 {
189         RAII_VAR(struct ast_sip_session *, session, obj, ao2_cleanup);
190         RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
191         RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(session->media, "image", OBJ_KEY), ao2_cleanup);
192
193         if (!datastore) {
194                 return 0;
195         }
196
197         ast_debug(2, "Automatically rejecting T.38 request on channel '%s'\n", ast_channel_name(session->channel));
198
199         t38_change_state(session, session_media, datastore->data, T38_REJECTED);
200         ast_sip_session_resume_reinvite(session);
201
202         return 0;
203 }
204
205 /*! \brief Timer entry callback which queues a task to reject a T.38 re-invite and resume handling it */
206 static void t38_automatic_reject_timer_cb(pj_timer_heap_t *timer_heap, struct pj_timer_entry *entry)
207 {
208         struct ast_sip_session *session = entry->user_data;
209
210         if (ast_sip_push_task(session->serializer, t38_automatic_reject, session)) {
211                 ao2_ref(session, -1);
212         }
213 }
214
215 /*! \brief Helper function which retrieves or allocates a T.38 state information datastore */
216 static struct t38_state *t38_state_get_or_alloc(struct ast_sip_session *session)
217 {
218         RAII_VAR(struct ast_datastore *, datastore, ast_sip_session_get_datastore(session, "t38"), ao2_cleanup);
219         struct t38_state *state;
220
221         /* While the datastore refcount is decremented this is operating in the serializer so it will remain valid regardless */
222         if (datastore) {
223                 return datastore->data;
224         }
225
226         if (!(datastore = ast_sip_session_alloc_datastore(&t38_datastore, "t38")) ||
227                 !(datastore->data = ast_calloc(1, sizeof(struct t38_state))) ||
228                 ast_sip_session_add_datastore(session, datastore)) {
229                 return NULL;
230         }
231
232         state = datastore->data;
233
234         /* This will get bumped up before scheduling */
235         state->timer.user_data = session;
236         state->timer.cb = t38_automatic_reject_timer_cb;
237
238         datastore->data = state;
239
240         return state;
241 }
242
243 /*! \brief Initializes UDPTL support on a session, only done when actually needed */
244 static int t38_initialize_session(struct ast_sip_session *session, struct ast_sip_session_media *session_media)
245 {
246         if (session_media->udptl) {
247                 return 0;
248         }
249
250         if (!(session_media->udptl = ast_udptl_new_with_bindaddr(NULL, NULL, 0,
251                 session->endpoint->media.t38.ipv6 ? &address_ipv6 : &address_ipv4))) {
252                 return -1;
253         }
254
255         ast_channel_set_fd(session->channel, 5, ast_udptl_fd(session_media->udptl));
256         ast_udptl_set_error_correction_scheme(session_media->udptl, session->endpoint->media.t38.error_correction);
257         ast_udptl_setnat(session_media->udptl, session->endpoint->media.t38.nat);
258
259         return 0;
260 }
261
262 /*! \brief Callback for when T.38 reinvite SDP is created */
263 static int t38_reinvite_sdp_cb(struct ast_sip_session *session, pjmedia_sdp_session *sdp)
264 {
265         int stream;
266
267         /* Move the image media stream to the front and have it as the only stream, pjmedia will fill in
268          * dummy streams for the rest
269          */
270         for (stream = 0; stream < sdp->media_count++; ++stream) {
271                 if (!pj_strcmp2(&sdp->media[stream]->desc.media, "image")) {
272                         sdp->media[0] = sdp->media[stream];
273                         sdp->media_count = 1;
274                         break;
275                 }
276         }
277
278         return 0;
279 }
280
281 /*! \brief Callback for when a response is received for a T.38 re-invite */
282 static int t38_reinvite_response_cb(struct ast_sip_session *session, pjsip_rx_data *rdata)
283 {
284         struct pjsip_status_line status = rdata->msg_info.msg->line.status;
285         struct t38_state *state;
286         RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
287
288         if (status.code == 100) {
289                 return 0;
290         }
291
292         if (!(state = t38_state_get_or_alloc(session)) ||
293                 !(session_media = ao2_find(session->media, "image", OBJ_KEY))) {
294                 ast_log(LOG_WARNING, "Received response to T.38 re-invite on '%s' but state unavailable\n",
295                         ast_channel_name(session->channel));
296                 return 0;
297         }
298
299         t38_change_state(session, session_media, state, (status.code == 200) ? T38_ENABLED : T38_REJECTED);
300
301         return 0;
302 }
303
304 /*! \brief Task for reacting to T.38 control frame */
305 static int t38_interpret_parameters(void *obj)
306 {
307         RAII_VAR(struct t38_parameters_task_data *, data, obj, ao2_cleanup);
308         const struct ast_control_t38_parameters *parameters = data->frame->data.ptr;
309         struct t38_state *state = t38_state_get_or_alloc(data->session);
310         RAII_VAR(struct ast_sip_session_media *, session_media, ao2_find(data->session->media, "image", OBJ_KEY), ao2_cleanup);
311
312         /* Without session media or state we can't interpret parameters */
313         if (!session_media || !state) {
314                 return 0;
315         }
316
317         switch (parameters->request_response) {
318         case AST_T38_NEGOTIATED:
319         case AST_T38_REQUEST_NEGOTIATE:         /* Request T38 */
320                 /* Negotiation can not take place without a valid max_ifp value. */
321                 if (!parameters->max_ifp) {
322                         t38_change_state(data->session, session_media, state, T38_REJECTED);
323                         if (data->session->t38state == T38_PEER_REINVITE) {
324                                 ast_sip_session_resume_reinvite(data->session);
325                         }
326                         break;
327                 } else if (data->session->t38state == T38_PEER_REINVITE) {
328                         state->our_parms = *parameters;
329                         /* modify our parameters to conform to the peer's parameters,
330                          * based on the rules in the ITU T.38 recommendation
331                          */
332                         if (!state->their_parms.fill_bit_removal) {
333                                 state->our_parms.fill_bit_removal = 0;
334                         }
335                         if (!state->their_parms.transcoding_mmr) {
336                                 state->our_parms.transcoding_mmr = 0;
337                         }
338                         if (!state->their_parms.transcoding_jbig) {
339                                 state->our_parms.transcoding_jbig = 0;
340                         }
341                         state->our_parms.version = MIN(state->our_parms.version, state->their_parms.version);
342                         state->our_parms.rate_management = state->their_parms.rate_management;
343                         ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
344                         t38_change_state(data->session, session_media, state, T38_ENABLED);
345                         ast_sip_session_resume_reinvite(data->session);
346                 } else if (data->session->t38state != T38_ENABLED) {
347                         if (t38_initialize_session(data->session, session_media)) {
348                                 break;
349                         }
350                         state->our_parms = *parameters;
351                         ast_udptl_set_local_max_ifp(session_media->udptl, state->our_parms.max_ifp);
352                         t38_change_state(data->session, session_media, state, T38_LOCAL_REINVITE);
353                         ast_sip_session_refresh(data->session, NULL, t38_reinvite_sdp_cb, t38_reinvite_response_cb,
354                                 AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
355                 }
356                 break;
357         case AST_T38_TERMINATED:
358         case AST_T38_REFUSED:
359         case AST_T38_REQUEST_TERMINATE:         /* Shutdown T38 */
360                 if (data->session->t38state == T38_PEER_REINVITE) {
361                         t38_change_state(data->session, session_media, state, T38_REJECTED);
362                         ast_sip_session_resume_reinvite(data->session);
363                 } else if (data->session->t38state == T38_ENABLED) {
364                         t38_change_state(data->session, session_media, state, T38_DISABLED);
365                         ast_sip_session_refresh(data->session, NULL, NULL, NULL, AST_SIP_SESSION_REFRESH_METHOD_INVITE, 1);
366                 }
367                 break;
368         case AST_T38_REQUEST_PARMS: {           /* Application wants remote's parameters re-sent */
369                 struct ast_control_t38_parameters parameters = state->their_parms;
370
371                 if (data->session->t38state == T38_PEER_REINVITE) {
372                         parameters.max_ifp = ast_udptl_get_far_max_ifp(session_media->udptl);
373                         parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
374                         ast_queue_control_data(data->session->channel, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
375                 }
376                 break;
377         }
378         default:
379                 break;
380         }
381
382         return 0;
383 }
384
385 /*! \brief Frame hook callback for writing */
386 static struct ast_frame *t38_framehook_write(struct ast_sip_session *session, struct ast_frame *f)
387 {
388         if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_T38_PARAMETERS &&
389                 session->endpoint->media.t38.enabled) {
390                 struct t38_parameters_task_data *data = t38_parameters_task_data_alloc(session, f);
391
392                 if (!data) {
393                         return f;
394                 }
395
396                 if (ast_sip_push_task(session->serializer, t38_interpret_parameters, data)) {
397                         ao2_ref(data, -1);
398                 }
399
400                 f = &ast_null_frame;
401         } else if (f->frametype == AST_FRAME_MODEM) {
402                 RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
403
404                 if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
405                         session_media->udptl) {
406                         ast_udptl_write(session_media->udptl, f);
407                 }
408         }
409
410         return f;
411 }
412
413 /*! \brief Frame hook callback for reading */
414 static struct ast_frame *t38_framehook_read(struct ast_sip_session *session, struct ast_frame *f)
415 {
416         if (ast_channel_fdno(session->channel) == 5) {
417                 RAII_VAR(struct ast_sip_session_media *, session_media, NULL, ao2_cleanup);
418
419                 if ((session_media = ao2_find(session->media, "image", OBJ_KEY)) &&
420                         session_media->udptl) {
421                         f = ast_udptl_read(session_media->udptl);
422                 }
423         }
424
425         return f;
426 }
427
428 /*! \brief Frame hook callback for T.38 related stuff */
429 static struct ast_frame *t38_framehook(struct ast_channel *chan, struct ast_frame *f,
430         enum ast_framehook_event event, void *data)
431 {
432         struct ast_sip_channel_pvt *channel = ast_channel_tech_pvt(chan);
433
434         if (event == AST_FRAMEHOOK_EVENT_READ) {
435                 f = t38_framehook_read(channel->session, f);
436         } else if (event == AST_FRAMEHOOK_EVENT_WRITE) {
437                 f = t38_framehook_write(channel->session, f);
438         }
439
440         return f;
441 }
442
443 /*! \brief Function called to attach T.38 framehook to channel when appropriate */
444 static void t38_attach_framehook(struct ast_sip_session *session)
445 {
446         static struct ast_framehook_interface hook = {
447                 .version = AST_FRAMEHOOK_INTERFACE_VERSION,
448                 .event_cb = t38_framehook,
449         };
450
451         /* Only attach the framehook on the first outgoing INVITE or the first incoming INVITE */
452         if ((session->inv_session->state != PJSIP_INV_STATE_NULL &&
453                 session->inv_session->state != PJSIP_INV_STATE_INCOMING) ||
454                 !session->endpoint->media.t38.enabled) {
455                 return;
456         }
457
458         if (ast_framehook_attach(session->channel, &hook) < 0) {
459                 ast_log(LOG_WARNING, "Could not attach T.38 Frame hook to channel, T.38 will be unavailable on '%s'\n",
460                         ast_channel_name(session->channel));
461         }
462 }
463
464 /*! \brief Function called when an INVITE goes out */
465 static int t38_incoming_invite_request(struct ast_sip_session *session, struct pjsip_rx_data *rdata)
466 {
467         t38_attach_framehook(session);
468         return 0;
469 }
470
471 /*! \brief Function called when an INVITE comes in */
472 static void t38_outgoing_invite_request(struct ast_sip_session *session, struct pjsip_tx_data *tdata)
473 {
474         t38_attach_framehook(session);
475 }
476
477 /*! \brief Get Max T.38 Transmission rate from T38 capabilities */
478 static unsigned int t38_get_rate(enum ast_control_t38_rate rate)
479 {
480         switch (rate) {
481         case AST_T38_RATE_2400:
482                 return 2400;
483         case AST_T38_RATE_4800:
484                 return 4800;
485         case AST_T38_RATE_7200:
486                 return 7200;
487         case AST_T38_RATE_9600:
488                 return 9600;
489         case AST_T38_RATE_12000:
490                 return 12000;
491         case AST_T38_RATE_14400:
492                 return 14400;
493         default:
494                 return 0;
495         }
496 }
497
498 /*! \brief Supplement for adding framehook to session channel */
499 static struct ast_sip_session_supplement t38_supplement = {
500         .method = "INVITE",
501         .priority = AST_SIP_SESSION_SUPPLEMENT_PRIORITY_CHANNEL + 1,
502         .incoming_request = t38_incoming_invite_request,
503         .outgoing_request = t38_outgoing_invite_request,
504 };
505
506 /*! \brief Parse a T.38 image stream and store the attribute information */
507 static void t38_interpret_sdp(struct t38_state *state, struct ast_sip_session *session, struct ast_sip_session_media *session_media,
508         const struct pjmedia_sdp_media *stream)
509 {
510         unsigned int attr_i;
511
512         for (attr_i = 0; attr_i < stream->attr_count; attr_i++) {
513                 pjmedia_sdp_attr *attr = stream->attr[attr_i];
514
515                 if (!pj_stricmp2(&attr->name, "t38faxmaxbuffer")) {
516                         /* This is purposely left empty, it is unused */
517                 } else if (!pj_stricmp2(&attr->name, "t38maxbitrate") || !pj_stricmp2(&attr->name, "t38faxmaxrate")) {
518                         switch (pj_strtoul(&attr->value)) {
519                         case 14400:
520                                 state->their_parms.rate = AST_T38_RATE_14400;
521                                 break;
522                         case 12000:
523                                 state->their_parms.rate = AST_T38_RATE_12000;
524                                 break;
525                         case 9600:
526                                 state->their_parms.rate = AST_T38_RATE_9600;
527                                 break;
528                         case 7200:
529                                 state->their_parms.rate = AST_T38_RATE_7200;
530                                 break;
531                         case 4800:
532                                 state->their_parms.rate = AST_T38_RATE_4800;
533                                 break;
534                         case 2400:
535                                 state->their_parms.rate = AST_T38_RATE_2400;
536                                 break;
537                         }
538                 } else if (!pj_stricmp2(&attr->name, "t38faxversion")) {
539                         state->their_parms.version = pj_strtoul(&attr->value);
540                 } else if (!pj_stricmp2(&attr->name, "t38faxmaxdatagram") || !pj_stricmp2(&attr->name, "t38maxdatagram")) {
541                         if (session->endpoint->media.t38.maxdatagram) {
542                                 ast_udptl_set_far_max_datagram(session_media->udptl, session->endpoint->media.t38.maxdatagram);
543                         } else {
544                                 ast_udptl_set_far_max_datagram(session_media->udptl, pj_strtoul(&attr->value));
545                         }
546                 } else if (!pj_stricmp2(&attr->name, "t38faxfillbitremoval")) {
547                         state->their_parms.fill_bit_removal = 1;
548                 } else if (!pj_stricmp2(&attr->name, "t38faxtranscodingmmr")) {
549                         state->their_parms.transcoding_mmr = 1;
550                 } else if (!pj_stricmp2(&attr->name, "t38faxtranscodingjbig")) {
551                         state->their_parms.transcoding_jbig = 1;
552                 } else if (!pj_stricmp2(&attr->name, "t38faxratemanagement")) {
553                         if (!pj_stricmp2(&attr->value, "localTCF")) {
554                                 state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_LOCAL_TCF;
555                         } else if (!pj_stricmp2(&attr->value, "transferredTCF")) {
556                                 state->their_parms.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF;
557                         }
558                 } else if (!pj_stricmp2(&attr->name, "t38faxudpec")) {
559                         if (!pj_stricmp2(&attr->value, "t38UDPRedundancy")) {
560                                 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_REDUNDANCY);
561                         } else if (!pj_stricmp2(&attr->value, "t38UDPFEC")) {
562                                 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_FEC);
563                         } else {
564                                 ast_udptl_set_error_correction_scheme(session_media->udptl, UDPTL_ERROR_CORRECTION_NONE);
565                         }
566                 }
567
568         }
569 }
570
571 /*! \brief Function which defers an incoming media stream */
572 static int defer_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
573                                          const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
574 {
575         struct t38_state *state;
576
577         if (!session->endpoint->media.t38.enabled) {
578                 return 0;
579         }
580
581         if (t38_initialize_session(session, session_media)) {
582                 return 0;
583         }
584
585         if (!(state = t38_state_get_or_alloc(session))) {
586                 return 0;
587         }
588
589         t38_interpret_sdp(state, session, session_media, stream);
590
591         /* If they are initiating the re-invite we need to defer responding until later */
592         if (session->t38state == T38_DISABLED) {
593                 t38_change_state(session, session_media, state, T38_PEER_REINVITE);
594                 return 1;
595         }
596
597         return 0;
598 }
599
600 /*! \brief Function which negotiates an incoming media stream */
601 static int negotiate_incoming_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
602                                          const struct pjmedia_sdp_session *sdp, const struct pjmedia_sdp_media *stream)
603 {
604         struct t38_state *state;
605         char host[NI_MAXHOST];
606         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
607
608         if (!session->endpoint->media.t38.enabled) {
609                 return -1;
610         }
611
612         if (!(state = t38_state_get_or_alloc(session))) {
613                 return -1;
614         }
615
616         if ((session->t38state == T38_REJECTED) || (session->t38state == T38_DISABLED)) {
617                 t38_change_state(session, session_media, state, T38_DISABLED);
618                 return -1;
619         }
620
621         ast_copy_pj_str(host, stream->conn ? &stream->conn->addr : &sdp->conn->addr, sizeof(host));
622
623         /* Ensure that the address provided is valid */
624         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_INET) <= 0) {
625                 /* The provided host was actually invalid so we error out this negotiation */
626                 return -1;
627         }
628
629         /* Check the address family to make sure it matches configured */
630         if ((ast_sockaddr_is_ipv6(addrs) && !session->endpoint->media.t38.ipv6) ||
631                 (ast_sockaddr_is_ipv4(addrs) && session->endpoint->media.t38.ipv6)) {
632                 /* The address does not match configured */
633                 return -1;
634         }
635
636         return 1;
637 }
638
639 /*! \brief Function which creates an outgoing stream */
640 static int create_outgoing_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
641                                       struct pjmedia_sdp_session *sdp)
642 {
643         pj_pool_t *pool = session->inv_session->pool_prov;
644         static const pj_str_t STR_IN = { "IN", 2 };
645         static const pj_str_t STR_IP4 = { "IP4", 3};
646         static const pj_str_t STR_IP6 = { "IP6", 3};
647         static const pj_str_t STR_UDPTL = { "udptl", 5 };
648         static const pj_str_t STR_T38 = { "t38", 3 };
649         static const pj_str_t STR_TRANSFERREDTCF = { "transferredTCF", 14 };
650         static const pj_str_t STR_LOCALTCF = { "localTCF", 8 };
651         static const pj_str_t STR_T38UDPFEC = { "t38UDPFEC", 9 };
652         static const pj_str_t STR_T38UDPREDUNDANCY = { "t38UDPRedundancy", 16 };
653         struct t38_state *state;
654         pjmedia_sdp_media *media;
655         char hostip[PJ_INET6_ADDRSTRLEN+2];
656         struct ast_sockaddr addr;
657         char tmp[512];
658         pj_str_t stmp;
659
660         if (!session->endpoint->media.t38.enabled) {
661                 return 1;
662         } else if ((session->t38state != T38_LOCAL_REINVITE) && (session->t38state != T38_PEER_REINVITE) &&
663                 (session->t38state != T38_ENABLED)) {
664                 return 1;
665         } else if (!(state = t38_state_get_or_alloc(session))) {
666                 return -1;
667         } else if (t38_initialize_session(session, session_media)) {
668                 return -1;
669         }
670
671         if (!(media = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_media))) ||
672                 !(media->conn = pj_pool_zalloc(pool, sizeof(struct pjmedia_sdp_conn)))) {
673                 return -1;
674         }
675
676         media->desc.media = pj_str(session_media->stream_type);
677         media->desc.transport = STR_UDPTL;
678
679         if (ast_strlen_zero(session->endpoint->media.address)) {
680                 pj_sockaddr localaddr;
681
682                 if (pj_gethostip(session->endpoint->media.t38.ipv6 ? pj_AF_INET6() : pj_AF_INET(), &localaddr)) {
683                         return -1;
684                 }
685                 pj_sockaddr_print(&localaddr, hostip, sizeof(hostip), 2);
686         } else {
687                 ast_copy_string(hostip, session->endpoint->media.address, sizeof(hostip));
688         }
689
690         media->conn->net_type = STR_IN;
691         media->conn->addr_type = session->endpoint->media.t38.ipv6 ? STR_IP6 : STR_IP4;
692         pj_strdup2(pool, &media->conn->addr, hostip);
693         ast_udptl_get_us(session_media->udptl, &addr);
694         media->desc.port = (pj_uint16_t) ast_sockaddr_port(&addr);
695         media->desc.port_count = 1;
696         media->desc.fmt[media->desc.fmt_count++] = STR_T38;
697
698         snprintf(tmp, sizeof(tmp), "%d", state->our_parms.version);
699         media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxVersion", pj_cstr(&stmp, tmp));
700
701         snprintf(tmp, sizeof(tmp), "%d", t38_get_rate(state->our_parms.rate));
702         media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38MaxBitRate", pj_cstr(&stmp, tmp));
703
704         if (state->our_parms.fill_bit_removal) {
705                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxFillBitRemoval", NULL);
706         }
707
708         if (state->our_parms.transcoding_mmr) {
709                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingMMR", NULL);
710         }
711
712         if (state->our_parms.transcoding_jbig) {
713                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxTranscodingJBIG", NULL);
714         }
715
716         switch (state->our_parms.rate_management) {
717         case AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF:
718                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_TRANSFERREDTCF);
719                 break;
720         case AST_T38_RATE_MANAGEMENT_LOCAL_TCF:
721                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxRateManagement", &STR_LOCALTCF);
722                 break;
723         }
724
725         snprintf(tmp, sizeof(tmp), "%d", ast_udptl_get_local_max_datagram(session_media->udptl));
726         media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxMaxDatagram", pj_cstr(&stmp, tmp));
727
728         switch (ast_udptl_get_error_correction_scheme(session_media->udptl)) {
729         case UDPTL_ERROR_CORRECTION_NONE:
730                 break;
731         case UDPTL_ERROR_CORRECTION_FEC:
732                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPFEC);
733                 break;
734         case UDPTL_ERROR_CORRECTION_REDUNDANCY:
735                 media->attr[media->attr_count++] = pjmedia_sdp_attr_create(pool, "T38FaxUdpEC", &STR_T38UDPREDUNDANCY);
736                 break;
737         }
738
739         sdp->media[sdp->media_count++] = media;
740
741         return 1;
742 }
743
744 /*! \brief Function which applies a negotiated stream */
745 static int apply_negotiated_sdp_stream(struct ast_sip_session *session, struct ast_sip_session_media *session_media,
746                                        const struct pjmedia_sdp_session *local, const struct pjmedia_sdp_media *local_stream,
747                                        const struct pjmedia_sdp_session *remote, const struct pjmedia_sdp_media *remote_stream)
748 {
749         RAII_VAR(struct ast_sockaddr *, addrs, NULL, ast_free_ptr);
750         char host[NI_MAXHOST];
751         struct t38_state *state;
752
753         if (!session_media->udptl) {
754                 return 0;
755         }
756
757         if (!(state = t38_state_get_or_alloc(session))) {
758                 return -1;
759         }
760
761         ast_copy_pj_str(host, remote_stream->conn ? &remote_stream->conn->addr : &remote->conn->addr, sizeof(host));
762
763         /* Ensure that the address provided is valid */
764         if (ast_sockaddr_resolve(&addrs, host, PARSE_PORT_FORBID, AST_AF_UNSPEC) <= 0) {
765                 /* The provided host was actually invalid so we error out this negotiation */
766                 return -1;
767         }
768
769         ast_sockaddr_set_port(addrs, remote_stream->desc.port);
770         ast_udptl_set_peer(session_media->udptl, addrs);
771
772         t38_interpret_sdp(state, session, session_media, remote_stream);
773
774         return 0;
775 }
776
777 /*! \brief Function which updates the media stream with external media address, if applicable */
778 static void change_outgoing_sdp_stream_media_address(pjsip_tx_data *tdata, struct pjmedia_sdp_media *stream, struct ast_sip_transport *transport)
779 {
780         char host[NI_MAXHOST];
781         struct ast_sockaddr addr = { { 0, } };
782
783         /* If the stream has been rejected there will be no connection line */
784         if (!stream->conn) {
785                 return;
786         }
787
788         ast_copy_pj_str(host, &stream->conn->addr, sizeof(host));
789         ast_sockaddr_parse(&addr, host, PARSE_PORT_FORBID);
790
791         /* Is the address within the SDP inside the same network? */
792         if (ast_apply_ha(transport->localnet, &addr) == AST_SENSE_ALLOW) {
793                 return;
794         }
795
796         pj_strdup2(tdata->pool, &stream->conn->addr, transport->external_media_address);
797 }
798
799 /*! \brief Function which destroys the UDPTL instance when session ends */
800 static void stream_destroy(struct ast_sip_session_media *session_media)
801 {
802         if (session_media->udptl) {
803                 ast_udptl_destroy(session_media->udptl);
804         }
805 }
806
807 /*! \brief SDP handler for 'image' media stream */
808 static struct ast_sip_session_sdp_handler image_sdp_handler = {
809         .id = "image",
810         .defer_incoming_sdp_stream = defer_incoming_sdp_stream,
811         .negotiate_incoming_sdp_stream = negotiate_incoming_sdp_stream,
812         .create_outgoing_sdp_stream = create_outgoing_sdp_stream,
813         .apply_negotiated_sdp_stream = apply_negotiated_sdp_stream,
814         .change_outgoing_sdp_stream_media_address = change_outgoing_sdp_stream_media_address,
815         .stream_destroy = stream_destroy,
816 };
817
818 /*! \brief Unloads the SIP T.38 module from Asterisk */
819 static int unload_module(void)
820 {
821         ast_sip_session_unregister_sdp_handler(&image_sdp_handler, "image");
822         ast_sip_session_unregister_supplement(&t38_supplement);
823
824         return 0;
825 }
826
827 /*!
828  * \brief Load the module
829  *
830  * Module loading including tests for configuration or dependencies.
831  * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
832  * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
833  * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
834  * configuration file or other non-critical problem return
835  * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
836  */
837 static int load_module(void)
838 {
839         ast_sockaddr_parse(&address_ipv4, "0.0.0.0", 0);
840         ast_sockaddr_parse(&address_ipv6, "::", 0);
841
842         if (ast_sip_session_register_supplement(&t38_supplement)) {
843                 ast_log(LOG_ERROR, "Unable to register T.38 session supplement\n");
844                 goto end;
845         }
846
847         if (ast_sip_session_register_sdp_handler(&image_sdp_handler, "image")) {
848                 ast_log(LOG_ERROR, "Unable to register SDP handler for image stream type\n");
849                 goto end;
850         }
851
852         return AST_MODULE_LOAD_SUCCESS;
853 end:
854         unload_module();
855
856         return AST_MODULE_LOAD_FAILURE;
857 }
858
859 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP T.38 UDPTL Support",
860                 .load = load_module,
861                 .unload = unload_module,
862                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
863         );