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