res/res_fax.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2008-2009, Digium, Inc.
   5  *
   6  * Dwayne M. Hubbard <dhubbard@digium.com>
   7  * Kevin P. Fleming <kpfleming@digium.com>
   8  * Matthew Nicholson <mnicholson@digium.com>
   9  *
  10  * Initial T.38-gateway code
  11  * 2008, Daniel Ferenci <daniel.ferenci@nethemba.com>
  12  * Created by Nethemba s.r.o. http://www.nethemba.com
  13  * Sponsored by IPEX a.s. http://www.ipex.cz
  14  *
  15  * T.38-gateway integration into asterisk app_fax and rework
  16  * 2008-2011, Gregory Hinton Nietsky <gregory@distrotech.co.za>
  17  * dns Telecom http://www.dnstelecom.co.za
  18  *
  19  * Modified to make T.38-gateway compatible with Asterisk 1.6.2
  20  * 2010, Anton Verevkin <mymail@verevkin.it>
  21  * ViaNetTV http://www.vianettv.com
  22  *
  23  * Modified to make T.38-gateway work
  24  * 2010, Klaus Darilion, IPCom GmbH, www.ipcom.at
  25  *
  26  * See http://www.asterisk.org for more information about
  27  * the Asterisk project. Please do not directly contact
  28  * any of the maintainers of this project for assistance;
  29  * the project provides a web site, mailing lists and IRC
  30  * channels for your use.
  31  *
  32  * This program is free software, distributed under the terms of
  33  * the GNU General Public License Version 2. See the LICENSE file
  34  * at the top of the source tree.
  35  */
  36
  37 /*** MODULEINFO
  38         <conflict>app_fax</conflict>
  39         <support_level>core</support_level>
  40 ***/
  41
  42 /*! \file
  43  *
  44  * \brief Generic FAX Resource for FAX technology resource modules
  45  *
  46  * \author Dwayne M. Hubbard <dhubbard@digium.com>
  47  * \author Kevin P. Fleming <kpfleming@digium.com>
  48  * \author Matthew Nicholson <mnicholson@digium.com>
  49  * \author Gregory H. Nietsky  <gregory@distrotech.co.za>
  50  *
  51  * A generic FAX resource module that provides SendFAX and ReceiveFAX applications.
  52  * This module requires FAX technology modules, like res_fax_spandsp, to register with it
  53  * so it can use the technology modules to perform the actual FAX transmissions.
  54  * \ingroup applications
  55  */
  56
  57 /*! \li \ref res_fax.c uses the configuration file \ref res_fax.conf
  58  * \addtogroup configuration_file Configuration Files
  59  */
  60
  61 /*!
  62  * \page res_fax.conf res_fax.conf
  63  * \verbinclude res_fax.conf.sample
  64  */
  65
  66 #include "asterisk.h"
  67
  68 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  69
  70 #include "asterisk/io.h"
  71 #include "asterisk/file.h"
  72 #include "asterisk/logger.h"
  73 #include "asterisk/module.h"
  74 #include "asterisk/app.h"
  75 #include "asterisk/lock.h"
  76 #include "asterisk/options.h"
  77 #include "asterisk/strings.h"
  78 #include "asterisk/cli.h"
  79 #include "asterisk/utils.h"
  80 #include "asterisk/config.h"
  81 #include "asterisk/astobj2.h"
  82 #include "asterisk/res_fax.h"
  83 #include "asterisk/file.h"
  84 #include "asterisk/channel.h"
  85 #include "asterisk/pbx.h"
  86 #include "asterisk/dsp.h"
  87 #include "asterisk/indications.h"
  88 #include "asterisk/ast_version.h"
  89 #include "asterisk/translate.h"
  90 #include "asterisk/stasis.h"
  91 #include "asterisk/stasis_channels.h"
  92 #include "asterisk/smoother.h"
  93 #include "asterisk/format_cache.h"
  94
  95 /*** DOCUMENTATION
  96         <application name="ReceiveFAX" language="en_US" module="res_fax">
  97                 <synopsis>
  98                         Receive a FAX and save as a TIFF/F file.
  99                 </synopsis>
 100                 <syntax>
 101                         <parameter name="filename" required="true" />
 102                         <parameter name="options">
 103                                 <optionlist>
 104                                         <option name="d">
 105                                                 <para>Enable FAX debugging.</para>
 106                                         </option>
 107                                         <option name="f">
 108                                                 <para>Allow audio fallback FAX transfer on T.38 capable channels.</para>
 109                                         </option>
 110                                         <option name="F">
 111                                                 <para>Force usage of audio mode on T.38 capable channels.</para>
 112                                         </option>
 113                                         <option name="s">
 114                                                 <para>Send progress Manager events (overrides statusevents setting in res_fax.conf).</para>
 115                                         </option>
 116                                 </optionlist>
 117                         </parameter>
 118                 </syntax>
 119                 <description>
 120                         <para>This application is provided by res_fax, which is a FAX technology agnostic module
 121                         that utilizes FAX technology resource modules to complete a FAX transmission.</para>
 122                         <para>Session arguments can be set by the FAXOPT function and to check results of the ReceiveFax() application.</para>
 123                 </description>
 124                 <see-also>
 125                         <ref type="function">FAXOPT</ref>
 126                 </see-also>
 127         </application>
 128         <application name="SendFAX" language="en_US" module="res_fax">
 129                 <synopsis>
 130                         Sends a specified TIFF/F file as a FAX.
 131                 </synopsis>
 132                 <syntax>
 133                         <parameter name="filename" required="true" argsep="&amp;">
 134                                 <argument name="filename2" multiple="true">
 135                                         <para>TIFF file to send as a FAX.</para>
 136                                 </argument>
 137                         </parameter>
 138                         <parameter name="options">
 139                                 <optionlist>
 140                                         <option name="d">
 141                                                 <para>Enable FAX debugging.</para>
 142                                         </option>
 143                                         <option name="f">
 144                                                 <para>Allow audio fallback FAX transfer on T.38 capable channels.</para>
 145                                         </option>
 146                                         <option name="F">
 147                                                 <para>Force usage of audio mode on T.38 capable channels.</para>
 148                                         </option>
 149                                         <option name="s">
 150                                                 <para>Send progress Manager events (overrides statusevents setting in res_fax.conf).</para>
 151                                         </option>
 152                                         <option name="z">
 153                                                 <para>Initiate a T.38 reinvite on the channel if the remote end does not.</para>
 154                                         </option>
 155                                 </optionlist>
 156                         </parameter>
 157                 </syntax>
 158                 <description>
 159                         <para>This application is provided by res_fax, which is a FAX technology agnostic module
 160                         that utilizes FAX technology resource modules to complete a FAX transmission.</para>
 161                         <para>Session arguments can be set by the FAXOPT function and to check results of the SendFax() application.</para>
 162                 </description>
 163                 <see-also>
 164                         <ref type="function">FAXOPT</ref>
 165                 </see-also>
 166         </application>
 167         <function name="FAXOPT" language="en_US" module="res_fax">
 168                 <synopsis>
 169                         Gets/sets various pieces of information about a fax session.
 170                 </synopsis>
 171                 <syntax>
 172                         <parameter name="item" required="true">
 173                                 <enumlist>
 174                                         <enum name="ecm">
 175                                                 <para>R/W Error Correction Mode (ECM) enable with 'yes', disable with 'no'.</para>
 176                                         </enum>
 177                                         <enum name="error">
 178                                                 <para>R/O FAX transmission error code upon failure.</para>
 179                                         </enum>
 180                                         <enum name="filename">
 181                                                 <para>R/O Filename of the first file of the FAX transmission.</para>
 182                                         </enum>
 183                                         <enum name="filenames">
 184                                                 <para>R/O Filenames of all of the files in the FAX transmission (comma separated).</para>
 185                                         </enum>
 186                                         <enum name="headerinfo">
 187                                                 <para>R/W FAX header information.</para>
 188                                         </enum>
 189                                         <enum name="localstationid">
 190                                                 <para>R/W Local Station Identification.</para>
 191                                         </enum>
 192                                         <enum name="minrate">
 193                                                 <para>R/W Minimum transfer rate set before transmission.</para>
 194                                         </enum>
 195                                         <enum name="maxrate">
 196                                                 <para>R/W Maximum transfer rate set before transmission.</para>
 197                                         </enum>
 198                                         <enum name="modem">
 199                                                 <para>R/W Modem type (v17/v27/v29).</para>
 200                                         </enum>
 201                                         <enum name="gateway">
 202                                                 <para>R/W T38 fax gateway, with optional fax activity timeout in seconds (yes[,timeout]/no)</para>
 203                                         </enum>
 204                                         <enum name="faxdetect">
 205                                                 <para>R/W Enable FAX detect with optional timeout in seconds (yes,t38,cng[,timeout]/no)</para>
 206                                         </enum>
 207                                         <enum name="pages">
 208                                                 <para>R/O Number of pages transferred.</para>
 209                                         </enum>
 210                                         <enum name="rate">
 211                                                 <para>R/O Negotiated transmission rate.</para>
 212                                         </enum>
 213                                         <enum name="remotestationid">
 214                                                 <para>R/O Remote Station Identification after transmission.</para>
 215                                         </enum>
 216                                         <enum name="resolution">
 217                                                 <para>R/O Negotiated image resolution after transmission.</para>
 218                                         </enum>
 219                                         <enum name="sessionid">
 220                                                 <para>R/O Session ID of the FAX transmission.</para>
 221                                         </enum>
 222                                         <enum name="status">
 223                                                 <para>R/O Result Status of the FAX transmission.</para>
 224                                         </enum>
 225                                         <enum name="statusstr">
 226                                                 <para>R/O Verbose Result Status of the FAX transmission.</para>
 227                                         </enum>
 228                                         <enum name="t38timeout">
 229                                                 <para>R/W The timeout used for T.38 negotiation.</para>
 230                                         </enum>
 231                                 </enumlist>
 232                         </parameter>
 233                 </syntax>
 234                 <description>
 235                         <para>FAXOPT can be used to override the settings for a FAX session listed in <filename>res_fax.conf</filename>,
 236                         it can also be used to retreive information about a FAX session that has finished eg. pages/status.</para>
 237                 </description>
 238                 <see-also>
 239                         <ref type="application">ReceiveFax</ref>
 240                         <ref type="application">SendFax</ref>
 241                 </see-also>
 242         </function>
 243         <manager name="FAXSessions" language="en_US">
 244                 <synopsis>
 245                         Lists active FAX sessions
 246                 </synopsis>
 247                 <syntax>
 248                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 249                 </syntax>
 250                 <description>
 251                         <para>Will generate a series of FAXSession events with information about each FAXSession. Closes with
 252                         a FAXSessionsComplete event which includes a count of the included FAX sessions. This action works in
 253                         the same manner as the CLI command 'fax show sessions'</para>
 254                 </description>
 255         </manager>
 256         <managerEvent language="en_US" name="FAXSessionsEntry">
 257                 <managerEventInstance class="EVENT_FLAG_REPORTING">
 258                         <synopsis>A single list item for the FAXSessions AMI command</synopsis>
 259                         <syntax>
 260                                 <parameter name="ActionID" required="false"/>
 261                                 <parameter name="Channel">
 262                                         <para>Name of the channel responsible for the FAX session</para>
 263                                 </parameter>
 264                                 <parameter name="Technology">
 265                                         <para>The FAX technology that the FAX session is using</para>
 266                                 </parameter>
 267                                 <parameter name="SessionNumber">
 268                                         <para>The numerical identifier for this particular session</para>
 269                                 </parameter>
 270                                 <parameter name="SessionType">
 271                                         <para>FAX session passthru/relay type</para>
 272                                         <enumlist>
 273                                                 <enum name="G.711" />
 274                                                 <enum name="T.38" />
 275                                         </enumlist>
 276                                 </parameter>
 277                                 <parameter name="Operation">
 278                                         <para>FAX session operation type</para>
 279                                         <enumlist>
 280                                                 <enum name="gateway" />
 281                                                 <enum name="V.21" />
 282                                                 <enum name="send" />
 283                                                 <enum name="receive" />
 284                                                 <enum name="none" />
 285                                         </enumlist>
 286                                 </parameter>
 287                                 <parameter name="State">
 288                                         <para>Current state of the FAX session</para>
 289                                         <enumlist>
 290                                                 <enum name="Uninitialized" />
 291                                                 <enum name="Initialized" />
 292                                                 <enum name="Open" />
 293                                                 <enum name="Active" />
 294                                                 <enum name="Complete" />
 295                                                 <enum name="Reserved" />
 296                                                 <enum name="Inactive" />
 297                                                 <enum name="Unknown" />
 298                                         </enumlist>
 299                                 </parameter>
 300                                 <parameter name="Files">
 301                                         <para>File or list of files associated with this FAX session</para>
 302                                 </parameter>
 303                         </syntax>
 304                 </managerEventInstance>
 305         </managerEvent>
 306         <managerEvent language="en_US" name="FAXSessionsComplete">
 307                 <managerEventInstance class="EVENT_FLAG_CALL">
 308                         <synopsis>Raised when all FAXSession events are completed for a FAXSessions command</synopsis>
 309                         <syntax>
 310                                 <parameter name="ActionID" required="false"/>
 311                                 <parameter name="Total">
 312                                         <para>Count of FAXSession events sent in response to FAXSessions action</para>
 313                                 </parameter>
 314                         </syntax>
 315                 </managerEventInstance>
 316         </managerEvent>
 317         <manager name="FAXSession" language="en_US">
 318                 <synopsis>
 319                         Responds with a detailed description of a single FAX session
 320                 </synopsis>
 321                 <syntax>
 322                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 323                         <parameter name="SessionNumber" required="true">
 324                                 <para>The session ID of the fax the user is interested in.</para>
 325                         </parameter>
 326                 </syntax>
 327                 <description>
 328                         <para>Provides details about a specific FAX session. The response will include a common subset of
 329                         the output from the CLI command 'fax show session &lt;session_number&gt;' for each technology. If the
 330                         FAX technolgy used by this session does not include a handler for FAXSession, then this action
 331                         will fail.</para>
 332                 </description>
 333         </manager>
 334         <managerEvent language="en_US" name="FAXSession">
 335                 <managerEventInstance class="EVENT_FLAG_REPORTING">
 336                         <synopsis>Raised in response to FAXSession manager command</synopsis>
 337                         <syntax>
 338                                 <parameter name="ActionID" required="false"/>
 339                                 <parameter name="SessionNumber">
 340                                         <para>The numerical identifier for this particular session</para>
 341                                 </parameter>
 342                                 <xi:include xpointer="xpointer(/docs/managerEvent[@name='FAXSessionsEntry']/managerEventInstance/syntax/parameter[@name='Operation'])" />
 343                                 <xi:include xpointer="xpointer(/docs/managerEvent[@name='FAXSessionsEntry']/managerEventInstance/syntax/parameter[@name='State'])" />
 344                                 <parameter name="ErrorCorrectionMode" required="false">
 345                                         <para>Whether error correcting mode is enabled for the FAX session. This field is not
 346                                         included when operation is 'V.21 Detect' or if operation is 'gateway' and state is
 347                                         'Uninitialized'
 348                                         </para>
 349                                         <enumlist>
 350                                                 <enum name="yes" />
 351                                                 <enum name="no" />
 352                                         </enumlist>
 353                                 </parameter>
 354                                 <parameter name="DataRate" required="false">
 355                                         <para>Bit rate of the FAX. This field is not included when operation is 'V.21 Detect' or
 356                                         if operation is 'gateway' and state is 'Uninitialized'.</para>
 357                                 </parameter>
 358                                 <parameter name="ImageResolution" required="false">
 359                                         <para>Resolution of each page of the FAX. Will be in the format of X_RESxY_RES. This field
 360                                         is not included if the operation is anything other than Receive/Transmit.</para>
 361                                 </parameter>
 362                                 <parameter name="PageNumber" required="false">
 363                                         <para>Current number of pages transferred during this FAX session. May change as the FAX
 364                                         progresses. This field is not included when operation is 'V.21 Detect' or if operation is
 365                                         'gateway' and state is 'Uninitialized'.</para>
 366                                 </parameter>
 367                                 <parameter name="FileName" required="false">
 368                                         <para>Filename of the image being sent/recieved for this FAX session. This field is not
 369                                         included if Operation isn't 'send' or 'receive'.</para>
 370                                 </parameter>
 371                                 <parameter name="PagesTransmitted" required="false">
 372                                         <para>Total number of pages sent during this session. This field is not included if
 373                                         Operation isn't 'send' or 'receive'. Will always be 0 for 'receive'.</para>
 374                                 </parameter>
 375                                 <parameter name="PagesReceived" required="false">
 376                                         <para>Total number of pages received during this session. This field is not included if
 377                                         Operation is not 'send' or 'receive'. Will be 0 for 'send'.</para>
 378                                 </parameter>
 379                                 <parameter name="TotalBadLines" required="false">
 380                                         <para>Total number of bad lines sent/recieved during this session. This field is not
 381                                         included if Operation is not 'send' or 'received'.</para>
 382                                 </parameter>
 383                         </syntax>
 384                 </managerEventInstance>
 385         </managerEvent>
 386         <manager name="FAXStats" language="en_US">
 387                 <synopsis>
 388                         Responds with fax statistics
 389                 </synopsis>
 390                 <syntax>
 391                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 392                 </syntax>
 393                 <description>
 394                         <para>Provides FAX statistics including the number of active sessions, reserved sessions, completed
 395                         sessions, failed sessions, and the number of receive/transmit attempts. This command provides all
 396                         of the non-technology specific information provided by the CLI command 'fax show stats'</para>
 397                 </description>
 398         </manager>
 399         <managerEvent language="en_US" name="FAXStats">
 400                 <managerEventInstance class="EVENT_FLAG_REPORTING">
 401                         <synopsis>Raised in response to FAXStats manager command</synopsis>
 402                         <syntax>
 403                                 <parameter name="ActionID" required="false"/>
 404                                 <parameter name="CurrentSessions" required="true">
 405                                         <para>Number of active FAX sessions</para>
 406                                 </parameter>
 407                                 <parameter name="ReservedSessions" required="true">
 408                                         <para>Number of reserved FAX sessions</para>
 409                                 </parameter>
 410                                 <parameter name="TransmitAttempts" required="true">
 411                                         <para>Total FAX sessions for which Asterisk is/was the transmitter</para>
 412                                 </parameter>
 413                                 <parameter name="ReceiveAttempts" required="true">
 414                                         <para>Total FAX sessions for which Asterisk is/was the recipient</para>
 415                                 </parameter>
 416                                 <parameter name="CompletedFAXes" required="true">
 417                                         <para>Total FAX sessions which have been completed successfully</para>
 418                                 </parameter>
 419                                 <parameter name="FailedFAXes" required="true">
 420                                         <para>Total FAX sessions which failed to complete successfully</para>
 421                                 </parameter>
 422                         </syntax>
 423                 </managerEventInstance>
 424         </managerEvent>
 425 ***/
 426
 427 static const char app_receivefax[] = "ReceiveFAX";
 428 static const char app_sendfax[] = "SendFAX";
 429
 430 struct debug_info_history {
 431         unsigned int consec_frames;
 432         unsigned int consec_ms;
 433         unsigned char silence;
 434 };
 435
 436 struct ast_fax_debug_info {
 437         struct timeval base_tv;
 438         struct debug_info_history c2s, s2c;
 439         struct ast_dsp *dsp;
 440 };
 441
 442 /*! \brief used for gateway framehook */
 443 struct fax_gateway {
 444         /*! \brief FAX Session */
 445         struct ast_fax_session *s;
 446         struct ast_fax_session *peer_v21_session;
 447         struct ast_fax_session *chan_v21_session;
 448         /*! \brief reserved fax session token */
 449         struct ast_fax_tech_token *token;
 450         /*! \brief the start of our timeout counter */
 451         struct timeval timeout_start;
 452         /*! \brief framehook used in gateway mode */
 453         int framehook;
 454         /*! \brief bridged */
 455         int bridged:1;
 456         /*! \brief 1 if a v21 preamble has been detected */
 457         int detected_v21:1;
 458         /*! \brief a flag to track the state of our negotiation */
 459         enum ast_t38_state t38_state;
 460         /*! \brief original audio formats */
 461         struct ast_format *chan_read_format;
 462         struct ast_format *chan_write_format;
 463         struct ast_format *peer_read_format;
 464         struct ast_format *peer_write_format;
 465 };
 466
 467 /*! \brief used for fax detect framehook */
 468 struct fax_detect {
 469         /*! \brief the start of our timeout counter */
 470         struct timeval timeout_start;
 471         /*! \brief faxdetect timeout */
 472         int timeout;
 473         /*! \brief DSP Processor */
 474         struct ast_dsp *dsp;
 475         /*! \brief original audio formats */
 476         struct ast_format *orig_format;
 477         /*! \brief fax session details */
 478         struct ast_fax_session_details *details;
 479         /*! \brief mode */
 480         int flags;
 481 };
 482
 483 /*! \brief FAX Detect flags */
 484 #define FAX_DETECT_MODE_CNG     (1 << 0)
 485 #define FAX_DETECT_MODE_T38     (1 << 1)
 486 #define FAX_DETECT_MODE_BOTH    (FAX_DETECT_MODE_CNG | FAX_DETECT_MODE_T38)
 487
 488 static int fax_logger_level = -1;
 489
 490 /*! \brief maximum buckets for res_fax ao2 containers */
 491 #define FAX_MAXBUCKETS 10
 492
 493 #define RES_FAX_TIMEOUT 10000
 494 #define FAX_GATEWAY_TIMEOUT RES_FAX_TIMEOUT
 495
 496 /*! \brief The faxregistry is used to manage information and statistics for all FAX sessions. */
 497 static struct {
 498         /*! The number of active FAX sessions */
 499         int active_sessions;
 500         /*! The number of reserved FAX sessions */
 501         int reserved_sessions;
 502         /*! active sessions are astobj2 objects */
 503         struct ao2_container *container;
 504         /*! Total number of Tx FAX attempts */
 505         int fax_tx_attempts;
 506         /*! Total number of Rx FAX attempts */
 507         int fax_rx_attempts;
 508         /*! Number of successful FAX transmissions */
 509         int fax_complete;
 510         /*! Number of failed FAX transmissions */
 511         int fax_failures;
 512         /*! the next unique session name */
 513         int nextsessionname;
 514 } faxregistry;
 515
 516 /*! \brief registered FAX technology modules are put into this list */
 517 struct fax_module {
 518         const struct ast_fax_tech *tech;
 519         AST_RWLIST_ENTRY(fax_module) list;
 520 };
 521 static AST_RWLIST_HEAD_STATIC(faxmodules, fax_module);
 522
 523 #define RES_FAX_MINRATE 4800
 524 #define RES_FAX_MAXRATE 14400
 525 #define RES_FAX_STATUSEVENTS 0
 526 #define RES_FAX_MODEM (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V27 | AST_FAX_MODEM_V29)
 527 #define RES_FAX_T38TIMEOUT 5000
 528
 529 struct fax_options {
 530         enum ast_fax_modems modems;
 531         uint32_t statusevents:1;
 532         uint32_t ecm:1;
 533         unsigned int minrate;
 534         unsigned int maxrate;
 535         unsigned int t38timeout;
 536 };
 537
 538 static struct fax_options general_options;
 539
 540 static const struct fax_options default_options = {
 541         .minrate = RES_FAX_MINRATE,
 542         .maxrate = RES_FAX_MAXRATE,
 543         .statusevents = RES_FAX_STATUSEVENTS,
 544         .modems = RES_FAX_MODEM,
 545         .ecm = AST_FAX_OPTFLAG_TRUE,
 546         .t38timeout = RES_FAX_T38TIMEOUT,
 547 };
 548
 549 AST_RWLOCK_DEFINE_STATIC(options_lock);
 550
 551 static void get_general_options(struct fax_options* options);
 552 static void set_general_options(const struct fax_options* options);
 553
 554 static const char *config = "res_fax.conf";
 555
 556 static int global_fax_debug = 0;
 557
 558 enum {
 559         OPT_CALLEDMODE  = (1 << 0),
 560         OPT_CALLERMODE  = (1 << 1),
 561         OPT_DEBUG       = (1 << 2),
 562         OPT_STATUS      = (1 << 3),
 563         OPT_ALLOWAUDIO  = (1 << 5),
 564         OPT_REQUEST_T38 = (1 << 6),
 565         OPT_FORCE_AUDIO = (1 << 7),
 566 };
 567
 568 AST_APP_OPTIONS(fax_exec_options, BEGIN_OPTIONS
 569         AST_APP_OPTION('a', OPT_CALLEDMODE),
 570         AST_APP_OPTION('c', OPT_CALLERMODE),
 571         AST_APP_OPTION('d', OPT_DEBUG),
 572         AST_APP_OPTION('f', OPT_ALLOWAUDIO),
 573         AST_APP_OPTION('F', OPT_FORCE_AUDIO),
 574         AST_APP_OPTION('s', OPT_STATUS),
 575         AST_APP_OPTION('z', OPT_REQUEST_T38),
 576 END_OPTIONS);
 577
 578 static void debug_check_frame_for_silence(struct ast_fax_session *s, unsigned int c2s, struct ast_frame *frame)
 579 {
 580         struct debug_info_history *history = c2s ? &s->debug_info->c2s : &s->debug_info->s2c;
 581         int dspsilence;
 582         unsigned int last_consec_frames, last_consec_ms;
 583         unsigned char wassil;
 584         struct timeval diff;
 585
 586         diff = ast_tvsub(ast_tvnow(), s->debug_info->base_tv);
 587
 588         ast_dsp_reset(s->debug_info->dsp);
 589         ast_dsp_silence(s->debug_info->dsp, frame, &dspsilence);
 590
 591         wassil = history->silence;
 592         history->silence = (dspsilence != 0) ? 1 : 0;
 593         if (history->silence != wassil) {
 594                 last_consec_frames = history->consec_frames;
 595                 last_consec_ms = history->consec_ms;
 596                 history->consec_frames = 0;
 597                 history->consec_ms = 0;
 598
 599                 if ((last_consec_frames != 0)) {
 600                         ast_verb(0, "Channel '%s' fax session '%u', [ %.3ld.%.6ld ], %s sent %u frames (%u ms) of %s.\n",
 601                                  s->channame, s->id, (long) diff.tv_sec, (long int) diff.tv_usec,
 602                                  (c2s) ? "channel" : "stack", last_consec_frames, last_consec_ms,
 603                                  (wassil) ? "silence" : "energy");
 604                 }
 605         }
 606
 607         history->consec_frames++;
 608         history->consec_ms += (frame->samples / 8);
 609 }
 610
 611 static void destroy_callback(void *data)
 612 {
 613         if (data) {
 614                 ao2_ref(data, -1);
 615         }
 616 }
 617
 618 static void fixup_callback(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan);
 619
 620 static const struct ast_datastore_info fax_datastore = {
 621         .type = "res_fax",
 622         .destroy = destroy_callback,
 623         .chan_fixup = fixup_callback,
 624 };
 625
 626 static int fax_gateway_attach(struct ast_channel *chan, struct ast_fax_session_details *details);
 627 static int fax_detect_attach(struct ast_channel *chan, int timeout, int flags);
 628 static struct ast_fax_session_details *find_or_create_details(struct ast_channel *chan);
 629
 630 /*! \brief Copies fax detection and gateway framehooks during masquerades
 631  *
 632  * \note must be called with both old_chan and new_chan locked. Since this
 633  *       is only called by do_masquerade, that shouldn't be an issue.
 634  */
 635 static void fixup_callback(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
 636 {
 637         struct ast_fax_session_details *old_details = data;
 638         struct ast_datastore *datastore = ast_channel_datastore_find(old_chan, &fax_datastore, NULL);
 639
 640         if (old_details->gateway_id >= 0) {
 641                 struct ast_fax_session_details *new_details = find_or_create_details(new_chan);
 642
 643                 ast_framehook_detach(old_chan, old_details->gateway_id);
 644                 fax_gateway_attach(new_chan, new_details);
 645                 ao2_cleanup(new_details);
 646         }
 647
 648         if (old_details->faxdetect_id >= 0) {
 649                 ast_framehook_detach(old_chan, old_details->faxdetect_id);
 650                 fax_detect_attach(new_chan, old_details->faxdetect_timeout, old_details->faxdetect_flags);
 651         }
 652
 653         if (datastore) {
 654                 ast_channel_datastore_remove(old_chan, datastore);
 655                 ast_datastore_free(datastore);
 656         }
 657 }
 658
 659 /*! \brief returns a reference counted pointer to a fax datastore, if it exists */
 660 static struct ast_fax_session_details *find_details(struct ast_channel *chan)
 661 {
 662         struct ast_fax_session_details *details;
 663         struct ast_datastore *datastore;
 664
 665         ast_channel_lock(chan);
 666         if (!(datastore = ast_channel_datastore_find(chan, &fax_datastore, NULL))) {
 667                 ast_channel_unlock(chan);
 668                 return NULL;
 669         }
 670         if (!(details = datastore->data)) {
 671                 ast_log(LOG_WARNING, "Huh?  channel '%s' has a FAX datastore without data!\n", ast_channel_name(chan));
 672                 ast_channel_unlock(chan);
 673                 return NULL;
 674         }
 675         ao2_ref(details, 1);
 676         ast_channel_unlock(chan);
 677
 678         return details;
 679 }
 680
 681 /*! \brief destroy a FAX session details structure */
 682 static void destroy_session_details(void *details)
 683 {
 684         struct ast_fax_session_details *d = details;
 685         struct ast_fax_document *doc;
 686
 687         while ((doc = AST_LIST_REMOVE_HEAD(&d->documents, next))) {
 688                 ast_free(doc);
 689         }
 690         ast_string_field_free_memory(d);
 691 }
 692
 693 /*! \brief create a FAX session details structure */
 694 static struct ast_fax_session_details *session_details_new(void)
 695 {
 696         struct ast_fax_session_details *d;
 697         struct fax_options options;
 698
 699         if (!(d = ao2_alloc(sizeof(*d), destroy_session_details))) {
 700                 return NULL;
 701         }
 702
 703         if (ast_string_field_init(d, 512)) {
 704                 ao2_ref(d, -1);
 705                 return NULL;
 706         }
 707
 708         get_general_options(&options);
 709
 710         AST_LIST_HEAD_INIT_NOLOCK(&d->documents);
 711
 712         /* These options need to be set to the configured default and may be overridden by
 713          * SendFAX, ReceiveFAX, or FAXOPT */
 714         d->option.request_t38 = AST_FAX_OPTFLAG_FALSE;
 715         d->option.send_cng = AST_FAX_OPTFLAG_FALSE;
 716         d->option.send_ced = AST_FAX_OPTFLAG_FALSE;
 717         d->option.ecm = options.ecm;
 718         d->option.statusevents = options.statusevents;
 719         d->modems = options.modems;
 720         d->minrate = options.minrate;
 721         d->maxrate = options.maxrate;
 722         d->t38timeout = options.t38timeout;
 723         d->gateway_id = -1;
 724         d->faxdetect_id = -1;
 725         d->gateway_timeout = 0;
 726
 727         return d;
 728 }
 729
 730 static struct ast_control_t38_parameters our_t38_parameters = {
 731         .version = 0,
 732         .max_ifp = 400,
 733         .rate = AST_T38_RATE_14400,
 734         .rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF,
 735 };
 736
 737 static void t38_parameters_ast_to_fax(struct ast_fax_t38_parameters *dst, const struct ast_control_t38_parameters *src)
 738 {
 739         dst->version = src->version;
 740         dst->max_ifp = src->max_ifp;
 741         dst->rate = src->rate;
 742         dst->rate_management = src->rate_management;
 743         dst->fill_bit_removal = src->fill_bit_removal;
 744         dst->transcoding_mmr = src->transcoding_mmr;
 745         dst->transcoding_jbig = src->transcoding_jbig;
 746 }
 747
 748 static void t38_parameters_fax_to_ast(struct ast_control_t38_parameters *dst, const struct ast_fax_t38_parameters *src)
 749 {
 750         dst->version = src->version;
 751         dst->max_ifp = src->max_ifp;
 752         dst->rate = src->rate;
 753         dst->rate_management = src->rate_management;
 754         dst->fill_bit_removal = src->fill_bit_removal;
 755         dst->transcoding_mmr = src->transcoding_mmr;
 756         dst->transcoding_jbig = src->transcoding_jbig;
 757 }
 758
 759 /*! \brief returns a reference counted details structure from the channel's fax datastore.  If the datastore
 760  * does not exist it will be created */
 761 static struct ast_fax_session_details *find_or_create_details(struct ast_channel *chan)
 762 {
 763         struct ast_fax_session_details *details;
 764         struct ast_datastore *datastore;
 765
 766         if ((details = find_details(chan))) {
 767                 return details;
 768         }
 769         /* channel does not have one so we must create one */
 770         if (!(details = session_details_new())) {
 771                 ast_log(LOG_WARNING, "channel '%s' can't get a FAX details structure for the datastore!\n", ast_channel_name(chan));
 772                 return NULL;
 773         }
 774         if (!(datastore = ast_datastore_alloc(&fax_datastore, NULL))) {
 775                 ao2_ref(details, -1);
 776                 ast_log(LOG_WARNING, "channel '%s' can't get a datastore!\n", ast_channel_name(chan));
 777                 return NULL;
 778         }
 779         /* add the datastore to the channel and increment the refcount */
 780         datastore->data = details;
 781
 782         /* initialize default T.38 parameters */
 783         t38_parameters_ast_to_fax(&details->our_t38_parameters, &our_t38_parameters);
 784         t38_parameters_ast_to_fax(&details->their_t38_parameters, &our_t38_parameters);
 785
 786         ao2_ref(details, 1);
 787         ast_channel_lock(chan);
 788         ast_channel_datastore_add(chan, datastore);
 789         ast_channel_unlock(chan);
 790         return details;
 791 }
 792
 793 unsigned int ast_fax_maxrate(void)
 794 {
 795         struct fax_options options;
 796         get_general_options(&options);
 797
 798         return options.maxrate;
 799 }
 800
 801 unsigned int ast_fax_minrate(void)
 802 {
 803         struct fax_options options;
 804         get_general_options(&options);
 805
 806         return options.minrate;
 807 }
 808
 809 static int update_modem_bits(enum ast_fax_modems *bits, const char *value)
 810 {
 811         char *m[5], *tok, *v = (char *)value;
 812         int i = 0, j;
 813
 814         if (!strchr(v, ',')) {
 815                 m[i++] = v;
 816                 m[i] = NULL;
 817         } else {
 818                 tok = strtok(v, ", ");
 819                 while (tok && i < ARRAY_LEN(m) - 1) {
 820                         m[i++] = tok;
 821                         tok = strtok(NULL, ", ");
 822                 }
 823                 m[i] = NULL;
 824         }
 825
 826         *bits = 0;
 827         for (j = 0; j < i; j++) {
 828                 if (!strcasecmp(m[j], "v17")) {
 829                         *bits |= AST_FAX_MODEM_V17;
 830                 } else if (!strcasecmp(m[j], "v27")) {
 831                         *bits |= AST_FAX_MODEM_V27;
 832                 } else if (!strcasecmp(m[j], "v29")) {
 833                         *bits |= AST_FAX_MODEM_V29;
 834                 } else if (!strcasecmp(m[j], "v34")) {
 835                         *bits |= AST_FAX_MODEM_V34;
 836                 } else {
 837                         ast_log(LOG_WARNING, "ignoring invalid modem setting: '%s', valid options {v17 | v27 | v29 | v34}\n", m[j]);
 838                 }
 839         }
 840         return 0;
 841 }
 842
 843 static char *ast_fax_caps_to_str(enum ast_fax_capabilities caps, char *buf, size_t bufsize)
 844 {
 845         char *out = buf;
 846         size_t size = bufsize;
 847         int first = 1;
 848
 849         if (caps & AST_FAX_TECH_SEND) {
 850                 if (!first) {
 851                         ast_build_string(&buf, &size, ",");
 852                 }
 853                 ast_build_string(&buf, &size, "SEND");
 854                 first = 0;
 855         }
 856         if (caps & AST_FAX_TECH_RECEIVE) {
 857                 if (!first) {
 858                         ast_build_string(&buf, &size, ",");
 859                 }
 860                 ast_build_string(&buf, &size, "RECEIVE");
 861                 first = 0;
 862         }
 863         if (caps & AST_FAX_TECH_AUDIO) {
 864                 if (!first) {
 865                         ast_build_string(&buf, &size, ",");
 866                 }
 867                 ast_build_string(&buf, &size, "AUDIO");
 868                 first = 0;
 869         }
 870         if (caps & AST_FAX_TECH_T38) {
 871                 if (!first) {
 872                         ast_build_string(&buf, &size, ",");
 873                 }
 874                 ast_build_string(&buf, &size, "T38");
 875                 first = 0;
 876         }
 877         if (caps & AST_FAX_TECH_MULTI_DOC) {
 878                 if (!first) {
 879                         ast_build_string(&buf, &size, ",");
 880                 }
 881                 ast_build_string(&buf, &size, "MULTI_DOC");
 882                 first = 0;
 883         }
 884         if (caps & AST_FAX_TECH_GATEWAY) {
 885                 if (!first) {
 886                         ast_build_string(&buf, &size, ",");
 887                 }
 888                 ast_build_string(&buf, &size, "GATEWAY");
 889                 first = 0;
 890         }
 891         if (caps & AST_FAX_TECH_V21_DETECT) {
 892                 if (!first) {
 893                         ast_build_string(&buf, &size, ",");
 894                 }
 895                 ast_build_string(&buf, &size, "V21");
 896                 first = 0;
 897         }
 898
 899         return out;
 900 }
 901
 902 static int ast_fax_modem_to_str(enum ast_fax_modems bits, char *tbuf, size_t bufsize)
 903 {
 904         int count = 0;
 905
 906         if (bits & AST_FAX_MODEM_V17) {
 907                 strcat(tbuf, "V17");
 908                 count++;
 909         }
 910         if (bits & AST_FAX_MODEM_V27) {
 911                 if (count) {
 912                         strcat(tbuf, ",");
 913                 }
 914                 strcat(tbuf, "V27");
 915                 count++;
 916         }
 917         if (bits & AST_FAX_MODEM_V29) {
 918                 if (count) {
 919                         strcat(tbuf, ",");
 920                 }
 921                 strcat(tbuf, "V29");
 922                 count++;
 923         }
 924         if (bits & AST_FAX_MODEM_V34) {
 925                 if (count) {
 926                         strcat(tbuf, ",");
 927                 }
 928                 strcat(tbuf, "V34");
 929                 count++;
 930         }
 931
 932         return 0;
 933 }
 934
 935 static int check_modem_rate(enum ast_fax_modems modems, unsigned int rate)
 936 {
 937         switch (rate) {
 938         case 2400:
 939                 if (!(modems & (AST_FAX_MODEM_V34))) {
 940                         return 1;
 941                 }
 942                 break;
 943         case 4800:
 944                 if (!(modems & (AST_FAX_MODEM_V27 | AST_FAX_MODEM_V34))) {
 945                         return 1;
 946                 }
 947                 break;
 948         case 7200:
 949                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V29 | AST_FAX_MODEM_V34))) {
 950                         return 1;
 951                 }
 952                 break;
 953         case 9600:
 954                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V27 | AST_FAX_MODEM_V29 | AST_FAX_MODEM_V34))) {
 955                         return 1;
 956                 }
 957                 break;
 958         case 12000:
 959         case 14400:
 960                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V34))) {
 961                         return 1;
 962                 }
 963                 break;
 964         case 28800:
 965         case 33600:
 966                 if (!(modems & AST_FAX_MODEM_V34)) {
 967                         return 1;
 968                 }
 969                 break;
 970         default:
 971                 /* this should never happen */
 972                 return 1;
 973         }
 974
 975         return 0;
 976 }
 977
 978 /*! \brief register a FAX technology module */
 979 int ast_fax_tech_register(struct ast_fax_tech *tech)
 980 {
 981         struct fax_module *fax;
 982
 983         if (!(fax = ast_calloc(1, sizeof(*fax)))) {
 984                 return -1;
 985         }
 986         fax->tech = tech;
 987         AST_RWLIST_WRLOCK(&faxmodules);
 988         AST_RWLIST_INSERT_TAIL(&faxmodules, fax, list);
 989         AST_RWLIST_UNLOCK(&faxmodules);
 990         ast_module_ref(ast_module_info->self);
 991
 992         ast_verb(3, "Registered handler for '%s' (%s)\n", fax->tech->type, fax->tech->description);
 993
 994         return 0;
 995 }
 996
 997 /*! \brief unregister a FAX technology module */
 998 void ast_fax_tech_unregister(struct ast_fax_tech *tech)
 999 {
1000         struct fax_module *fax;
1001
1002         ast_verb(3, "Unregistering FAX module type '%s'\n", tech->type);
1003
1004         AST_RWLIST_WRLOCK(&faxmodules);
1005         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&faxmodules, fax, list) {
1006                 if (fax->tech != tech) {
1007                         continue;
1008                 }
1009                 AST_RWLIST_REMOVE_CURRENT(list);
1010                 ast_module_unref(ast_module_info->self);
1011                 ast_free(fax);
1012                 ast_verb(4, "Unregistered FAX module type '%s'\n", tech->type);
1013                 break;
1014         }
1015         AST_RWLIST_TRAVERSE_SAFE_END;
1016         AST_RWLIST_UNLOCK(&faxmodules);
1017 }
1018
1019 /*! \brief convert a ast_fax_state to a string */
1020 const char *ast_fax_state_to_str(enum ast_fax_state state)
1021 {
1022         switch (state) {
1023         case AST_FAX_STATE_UNINITIALIZED:
1024                 return "Uninitialized";
1025         case AST_FAX_STATE_INITIALIZED:
1026                 return "Initialized";
1027         case AST_FAX_STATE_OPEN:
1028                 return "Open";
1029         case AST_FAX_STATE_ACTIVE:
1030                 return "Active";
1031         case AST_FAX_STATE_COMPLETE:
1032                 return "Complete";
1033         case AST_FAX_STATE_RESERVED:
1034                 return "Reserved";
1035         case AST_FAX_STATE_INACTIVE:
1036                 return "Inactive";
1037         default:
1038                 ast_log(LOG_WARNING, "unhandled FAX state: %u\n", state);
1039                 return "Unknown";
1040         }
1041 }
1042
1043 void ast_fax_log(int level, const char *file, const int line, const char *function, const char *msg)
1044 {
1045         if (fax_logger_level != -1) {
1046                 ast_log_dynamic_level(fax_logger_level, "%s", msg);
1047         } else {
1048                 ast_log(level, file, line, function, "%s", msg);
1049         }
1050 }
1051
1052 /*! \brief convert a rate string to a rate */
1053 static unsigned int fax_rate_str_to_int(const char *ratestr)
1054 {
1055         int rate;
1056
1057         if (sscanf(ratestr, "%d", &rate) != 1) {
1058                 ast_log(LOG_ERROR, "failed to sscanf '%s' to rate\n", ratestr);
1059                 return 0;
1060         }
1061         switch (rate) {
1062         case 2400:
1063         case 4800:
1064         case 7200:
1065         case 9600:
1066         case 12000:
1067         case 14400:
1068         case 28800:
1069         case 33600:
1070                 return rate;
1071         default:
1072                 ast_log(LOG_WARNING, "ignoring invalid rate '%s'.  Valid options are {2400 | 4800 | 7200 | 9600 | 12000 | 14400 | 28800 | 33600}\n", ratestr);
1073                 return 0;
1074         }
1075 }
1076
1077 /*! \brief Release a session token.
1078  * \param s a session returned from fax_session_reserve()
1079  * \param token a token generated from fax_session_reserve()
1080  *
1081  * This function releases the given token and marks the given session as no
1082  * longer reserved. It is safe to call on a session that is not actually
1083  * reserved and with a NULL token. This is so that sessions returned by
1084  * technologies that do not support reserved sessions don't require extra logic
1085  * to handle.
1086  *
1087  * \note This function DOES NOT release the given fax session, only the given
1088  * token.
1089  */
1090 static void fax_session_release(struct ast_fax_session *s, struct ast_fax_tech_token *token)
1091 {
1092         if (token) {
1093                 s->tech->release_token(token);
1094         }
1095
1096         if (s->state == AST_FAX_STATE_RESERVED) {
1097                 ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, -1);
1098                 s->state = AST_FAX_STATE_INACTIVE;
1099         }
1100 }
1101
1102 /*! \brief destroy a FAX session structure */
1103 static void destroy_session(void *session)
1104 {
1105         struct ast_fax_session *s = session;
1106
1107         if (s->tech) {
1108                 fax_session_release(s, NULL);
1109                 if (s->tech_pvt) {
1110                         s->tech->destroy_session(s);
1111                 }
1112                 ast_module_unref(s->tech->module);
1113         }
1114
1115         if (s->details) {
1116                 if (s->details->caps & AST_FAX_TECH_GATEWAY) {
1117                         s->details->caps &= ~AST_FAX_TECH_GATEWAY;
1118                 }
1119                 ao2_ref(s->details, -1);
1120         }
1121
1122         if (s->debug_info) {
1123                 ast_dsp_free(s->debug_info->dsp);
1124                 ast_free(s->debug_info);
1125         }
1126
1127         if (s->smoother) {
1128                 ast_smoother_free(s->smoother);
1129         }
1130
1131         if (s->state != AST_FAX_STATE_INACTIVE) {
1132                 ast_atomic_fetchadd_int(&faxregistry.active_sessions, -1);
1133         }
1134
1135         ast_free(s->channame);
1136         ast_free(s->chan_uniqueid);
1137 }
1138
1139 /*! \brief Reserve a fax session.
1140  * \param details the fax session details
1141  * \param token a pointer to a place to store a token to be passed to fax_session_new() later
1142  *
1143  * This function reserves a fax session for use later. If the selected fax
1144  * technology does not support reserving sessions a session will still be
1145  * returned but token will not be set.
1146  *
1147  * \note The reference returned by this function does not get consumed by
1148  * fax_session_new() and must always be dereferenced separately.
1149  *
1150  * \return NULL or an uninitialized and possibly reserved session
1151  */
1152 static struct ast_fax_session *fax_session_reserve(struct ast_fax_session_details *details, struct ast_fax_tech_token **token)
1153 {
1154         struct ast_fax_session *s;
1155         struct fax_module *faxmod;
1156
1157         if (!(s = ao2_alloc(sizeof(*s), destroy_session))) {
1158                 return NULL;
1159         }
1160
1161         s->state = AST_FAX_STATE_INACTIVE;
1162         s->details = details;
1163         ao2_ref(s->details, 1);
1164
1165         /* locate a FAX technology module that can handle said requirements
1166          * Note: the requirements have not yet been finalized as T.38
1167          * negotiation has not yet occured. */
1168         AST_RWLIST_RDLOCK(&faxmodules);
1169         AST_RWLIST_TRAVERSE(&faxmodules, faxmod, list) {
1170                 if ((faxmod->tech->caps & details->caps) != details->caps) {
1171                         continue;
1172                 }
1173                 ast_debug(4, "Reserving a FAX session from '%s'.\n", faxmod->tech->description);
1174                 ast_module_ref(faxmod->tech->module);
1175                 s->tech = faxmod->tech;
1176                 break;
1177         }
1178         AST_RWLIST_UNLOCK(&faxmodules);
1179
1180         if (!faxmod) {
1181                 char caps[128] = "";
1182                 ast_log(LOG_ERROR, "Could not locate a FAX technology module with capabilities (%s)\n", ast_fax_caps_to_str(details->caps, caps, sizeof(caps)));
1183                 ao2_ref(s, -1);
1184                 return NULL;
1185         }
1186
1187         if (!s->tech->reserve_session) {
1188                 ast_debug(1, "Selected FAX technology module (%s) does not support reserving sessions.\n", s->tech->description);
1189                 return s;
1190         }
1191
1192         if (!(*token = s->tech->reserve_session(s))) {
1193                 ao2_ref(s, -1);
1194                 return NULL;
1195         }
1196
1197         s->state = AST_FAX_STATE_RESERVED;
1198         ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, 1);
1199
1200         return s;
1201 }
1202
1203 /*! \brief create a FAX session
1204  *
1205  * \param details details for the session
1206  * \param chan the channel the session will run on
1207  * \param reserved a reserved session to base this session on (can be NULL)
1208  * \param token the token for a reserved session (can be NULL)
1209  *
1210  * Create a new fax session based on the given details structure.
1211  *
1212  * \note The given token is always consumed (by tech->new_session() or by
1213  * fax_session_release() in the event of a failure). The given reference to a
1214  * reserved session is never consumed and must be dereferenced separately from
1215  * the reference returned by this function.
1216  *
1217  * \return NULL or a reference to a new fax session
1218  */
1219 static struct ast_fax_session *fax_session_new(struct ast_fax_session_details *details, struct ast_channel *chan, struct ast_fax_session *reserved, struct ast_fax_tech_token *token)
1220 {
1221         struct ast_fax_session *s = NULL;
1222         struct fax_module *faxmod;
1223
1224         if (reserved) {
1225                 s = reserved;
1226                 ao2_ref(reserved, +1);
1227                 ao2_unlink(faxregistry.container, reserved);
1228
1229                 /* NOTE: we don't consume the reference to the reserved
1230                  * session. The session returned from fax_session_new() is a
1231                  * new reference and must be derefed in addition to the
1232                  * reserved session.
1233                  */
1234
1235                 if (s->state == AST_FAX_STATE_RESERVED) {
1236                         ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, -1);
1237                         s->state = AST_FAX_STATE_UNINITIALIZED;
1238                 }
1239         }
1240
1241         if (!s && !(s = ao2_alloc(sizeof(*s), destroy_session))) {
1242                 return NULL;
1243         }
1244
1245         ast_atomic_fetchadd_int(&faxregistry.active_sessions, 1);
1246         s->state = AST_FAX_STATE_UNINITIALIZED;
1247
1248         if (details->option.debug && (details->caps & AST_FAX_TECH_AUDIO)) {
1249                 if (!(s->debug_info = ast_calloc(1, sizeof(*(s->debug_info))))) {
1250                         fax_session_release(s, token);
1251                         ao2_ref(s, -1);
1252                         return NULL;
1253                 }
1254                 if (!(s->debug_info->dsp = ast_dsp_new())) {
1255                         ast_free(s->debug_info);
1256                         s->debug_info = NULL;
1257                         fax_session_release(s, token);
1258                         ao2_ref(s, -1);
1259                         return NULL;
1260                 }
1261                 ast_dsp_set_threshold(s->debug_info->dsp, 128);
1262         }
1263
1264         if (!(s->channame = ast_strdup(ast_channel_name(chan)))) {
1265                 fax_session_release(s, token);
1266                 ao2_ref(s, -1);
1267                 return NULL;
1268         }
1269
1270         if (!(s->chan_uniqueid = ast_strdup(ast_channel_uniqueid(chan)))) {
1271                 fax_session_release(s, token);
1272                 ao2_ref(s, -1);
1273                 return NULL;
1274         }
1275
1276         s->chan = chan;
1277         if (!s->details) {
1278                 s->details = details;
1279                 ao2_ref(s->details, 1);
1280         }
1281
1282         details->id = s->id = ast_atomic_fetchadd_int(&faxregistry.nextsessionname, 1);
1283
1284         if (!token) {
1285                 /* locate a FAX technology module that can handle said requirements */
1286                 AST_RWLIST_RDLOCK(&faxmodules);
1287                 AST_RWLIST_TRAVERSE(&faxmodules, faxmod, list) {
1288                         if ((faxmod->tech->caps & details->caps) != details->caps) {
1289                                 continue;
1290                         }
1291                         ast_debug(4, "Requesting a new FAX session from '%s'.\n", faxmod->tech->description);
1292                         ast_module_ref(faxmod->tech->module);
1293                         if (reserved) {
1294                                 /* Balance module ref from reserved session */
1295                                 ast_module_unref(reserved->tech->module);
1296                         }
1297                         s->tech = faxmod->tech;
1298                         break;
1299                 }
1300                 AST_RWLIST_UNLOCK(&faxmodules);
1301
1302                 if (!faxmod) {
1303                         char caps[128] = "";
1304                         ast_log(LOG_ERROR, "Could not locate a FAX technology module with capabilities (%s)\n", ast_fax_caps_to_str(details->caps, caps, sizeof(caps)));
1305                         ao2_ref(s, -1);
1306                         return NULL;
1307                 }
1308         }
1309
1310         if (!(s->tech_pvt = s->tech->new_session(s, token))) {
1311                 ast_log(LOG_ERROR, "FAX session failed to initialize.\n");
1312                 ao2_ref(s, -1);
1313                 return NULL;
1314         }
1315         /* link the session to the session container */
1316         if (!(ao2_link(faxregistry.container, s))) {
1317                 ast_log(LOG_ERROR, "failed to add FAX session '%u' to container.\n", s->id);
1318                 ao2_ref(s, -1);
1319                 return NULL;
1320         }
1321         ast_debug(4, "channel '%s' using FAX session '%u'\n", s->channame, s->id);
1322
1323         return s;
1324 }
1325
1326 /*!
1327  * \internal
1328  * \brief Convert the filenames in a fax session into a JSON array
1329  * \retval NULL on error
1330  * \retval A \ref ast_json array on success
1331  */
1332 static struct ast_json *generate_filenames_json(struct ast_fax_session_details *details)
1333 {
1334         RAII_VAR(struct ast_json *, json_array, ast_json_array_create(), ast_json_unref);
1335         struct ast_fax_document *doc;
1336
1337         if (!details || !json_array) {
1338                 return NULL;
1339         }
1340
1341         /* don't process empty lists */
1342         if (AST_LIST_EMPTY(&details->documents)) {
1343                 return NULL;
1344         }
1345
1346         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1347                 struct ast_json *entry = ast_json_string_create(doc->filename);
1348                 if (!entry) {
1349                         return NULL;
1350                 }
1351                 if (ast_json_array_append(json_array, entry)) {
1352                         return NULL;
1353                 }
1354         }
1355
1356         ast_json_ref(json_array);
1357         return json_array;
1358 }
1359
1360 /*!
1361  * \brief Generate a string of filenames using the given prefix and separator.
1362  * \param details the fax session details
1363  * \param prefix the prefix to each filename
1364  * \param separator the separator between filenames
1365  *
1366  * This function generates a string of filenames from the given details
1367  * structure and using the given prefix and separator.
1368  *
1369  * \retval NULL there was an error generating the string
1370  * \return the string generated string
1371  */
1372 static char *generate_filenames_string(struct ast_fax_session_details *details, char *prefix, char *separator)
1373 {
1374         char *filenames, *c;
1375         size_t size = 0;
1376         int first = 1;
1377         struct ast_fax_document *doc;
1378
1379         /* don't process empty lists */
1380         if (AST_LIST_EMPTY(&details->documents)) {
1381                 return ast_strdup("");
1382         }
1383
1384         /* Calculate the total length of all of the file names */
1385         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1386                 size += strlen(separator) + strlen(prefix) + strlen(doc->filename);
1387         }
1388         size += 1; /* add space for the terminating null */
1389
1390         if (!(filenames = ast_malloc(size))) {
1391                 return NULL;
1392         }
1393         c = filenames;
1394
1395         ast_build_string(&c, &size, "%s%s", prefix, AST_LIST_FIRST(&details->documents)->filename);
1396         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1397                 if (first) {
1398                         first = 0;
1399                         continue;
1400                 }
1401
1402                 ast_build_string(&c, &size, "%s%s%s", separator, prefix, doc->filename);
1403         }
1404
1405         return filenames;
1406 }
1407
1408 /*! \brief send a FAX status manager event */
1409 static int report_fax_status(struct ast_channel *chan, struct ast_fax_session_details *details, const char *status)
1410 {
1411         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
1412         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
1413         struct ast_json *json_filenames = NULL;
1414
1415         if (!details->option.statusevents) {
1416                 return 0;
1417         }
1418
1419         json_filenames = generate_filenames_json(details);
1420         if (!json_filenames) {
1421                 return -1;
1422         }
1423
1424         json_object = ast_json_pack("{s: s, s: s, s: s, s: s, s: o}",
1425                         "type", "status",
1426                         "operation", (details->caps & AST_FAX_TECH_GATEWAY) ? "gateway" : (details->caps & AST_FAX_TECH_RECEIVE) ? "receive" : "send",
1427                         "status", status,
1428                         "local_station_id", details->localstationid,
1429                         "filenames", json_filenames);
1430         if (!json_object) {
1431                 return -1;
1432         }
1433
1434         {
1435                 SCOPED_CHANNELLOCK(lock, chan);
1436
1437                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_object);
1438                 if (!message) {
1439                         return -1;
1440                 }
1441                 stasis_publish(ast_channel_topic(chan), message);
1442         }
1443         return 0;
1444 }
1445
1446 /*! \brief Set fax related channel variables. */
1447 static void set_channel_variables(struct ast_channel *chan, struct ast_fax_session_details *details)
1448 {
1449         char buf[10];
1450         pbx_builtin_setvar_helper(chan, "FAXSTATUS", S_OR(details->result, NULL));
1451         pbx_builtin_setvar_helper(chan, "FAXERROR", S_OR(details->error, NULL));
1452         pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", S_OR(details->resultstr, NULL));
1453         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", S_OR(details->remotestationid, NULL));
1454         pbx_builtin_setvar_helper(chan, "LOCALSTATIONID", S_OR(details->localstationid, NULL));
1455         pbx_builtin_setvar_helper(chan, "FAXBITRATE", S_OR(details->transfer_rate, NULL));
1456         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", S_OR(details->resolution, NULL));
1457
1458         snprintf(buf, sizeof(buf), "%u", details->pages_transferred);
1459         pbx_builtin_setvar_helper(chan, "FAXPAGES", buf);
1460 }
1461
1462 #define GENERIC_FAX_EXEC_SET_VARS(fax, chan, errorstr, reason) \
1463         do {    \
1464                 if (ast_strlen_zero(fax->details->result)) \
1465                         ast_string_field_set(fax->details, result, "FAILED"); \
1466                 if (ast_strlen_zero(fax->details->resultstr)) \
1467                         ast_string_field_set(fax->details, resultstr, reason); \
1468                 if (ast_strlen_zero(fax->details->error)) \
1469                         ast_string_field_set(fax->details, error, errorstr); \
1470                 set_channel_variables(chan, fax->details); \
1471         } while (0)
1472
1473 #define GENERIC_FAX_EXEC_ERROR_QUIET(fax, chan, errorstr, reason) \
1474         do {    \
1475                 GENERIC_FAX_EXEC_SET_VARS(fax, chan, errorstr, reason); \
1476         } while (0)
1477
1478 #define GENERIC_FAX_EXEC_ERROR(fax, chan, errorstr, reason)     \
1479         do {    \
1480                 ast_log(LOG_ERROR, "channel '%s' FAX session '%u' failure, reason: '%s' (%s)\n", ast_channel_name(chan), fax->id, reason, errorstr); \
1481                 GENERIC_FAX_EXEC_ERROR_QUIET(fax, chan, errorstr, reason); \
1482         } while (0)
1483
1484 static int set_fax_t38_caps(struct ast_channel *chan, struct ast_fax_session_details *details)
1485 {
1486         switch (ast_channel_get_t38_state(chan)) {
1487         case T38_STATE_UNKNOWN:
1488                 details->caps |= AST_FAX_TECH_T38;
1489                 break;
1490         case T38_STATE_REJECTED:
1491         case T38_STATE_UNAVAILABLE:
1492                 details->caps |= AST_FAX_TECH_AUDIO;
1493                 break;
1494         case T38_STATE_NEGOTIATED:
1495                 /* already in T.38 mode? This should not happen. */
1496         case T38_STATE_NEGOTIATING: {
1497                 /* the other end already sent us a T.38 reinvite, so we need to prod the channel
1498                  * driver into resending their parameters to us if it supports doing so... if
1499                  * not, we can't proceed, because we can't create a proper reply without them.
1500                  * if it does work, the channel driver will send an AST_CONTROL_T38_PARAMETERS
1501                  * with a request of AST_T38_REQUEST_NEGOTIATE, which will be read by the function
1502                  * that gets called after this one completes
1503                  */
1504                 struct ast_control_t38_parameters parameters = { .request_response = AST_T38_REQUEST_PARMS, };
1505                 if (ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters)) != AST_T38_REQUEST_PARMS) {
1506                         ast_log(LOG_ERROR, "channel '%s' is in an unsupported T.38 negotiation state, cannot continue.\n", ast_channel_name(chan));
1507                         return -1;
1508                 }
1509                 details->caps |= AST_FAX_TECH_T38;
1510                 break;
1511         }
1512         default:
1513                 ast_log(LOG_ERROR, "channel '%s' is in an unsupported T.38 negotiation state, cannot continue.\n", ast_channel_name(chan));
1514                 return -1;
1515         }
1516
1517         return 0;
1518 }
1519
1520 static int disable_t38(struct ast_channel *chan)
1521 {
1522         int timeout_ms;
1523         struct ast_frame *frame = NULL;
1524         struct ast_control_t38_parameters t38_parameters = { .request_response = AST_T38_REQUEST_TERMINATE, };
1525         struct timeval start;
1526         int ms;
1527
1528         ast_debug(1, "Shutting down T.38 on %s\n", ast_channel_name(chan));
1529         if (ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0) {
1530                 ast_debug(1, "error while disabling T.38 on channel '%s'\n", ast_channel_name(chan));
1531                 return -1;
1532         }
1533
1534         /* wait up to five seconds for negotiation to complete */
1535         timeout_ms = 5000;
1536         start = ast_tvnow();
1537         while ((ms = ast_remaining_ms(start, timeout_ms))) {
1538                 ms = ast_waitfor(chan, ms);
1539
1540                 if (ms == 0) {
1541                         break;
1542                 }
1543                 if (ms < 0) {
1544                         ast_debug(1, "error while disabling T.38 on channel '%s'\n", ast_channel_name(chan));
1545                         return -1;
1546                 }
1547
1548                 if (!(frame = ast_read(chan))) {
1549                         return -1;
1550                 }
1551                 if ((frame->frametype == AST_FRAME_CONTROL) &&
1552                     (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1553                     (frame->datalen == sizeof(t38_parameters))) {
1554                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
1555
1556                         switch (parameters->request_response) {
1557                         case AST_T38_TERMINATED:
1558                                 ast_debug(1, "Shut down T.38 on %s\n", ast_channel_name(chan));
1559                                 break;
1560                         case AST_T38_REFUSED:
1561                                 ast_log(LOG_WARNING, "channel '%s' refused to disable T.38\n", ast_channel_name(chan));
1562                                 ast_frfree(frame);
1563                                 return -1;
1564                         default:
1565                                 ast_log(LOG_ERROR, "channel '%s' failed to disable T.38\n", ast_channel_name(chan));
1566                                 ast_frfree(frame);
1567                                 return -1;
1568                         }
1569                         ast_frfree(frame);
1570                         break;
1571                 }
1572                 ast_frfree(frame);
1573         }
1574
1575         if (ms == 0) { /* all done, nothing happened */
1576                 ast_debug(1, "channel '%s' timed-out during T.38 shutdown\n", ast_channel_name(chan));
1577         }
1578
1579         return 0;
1580 }
1581
1582 /*! \brief this is the generic FAX session handling function */
1583 static int generic_fax_exec(struct ast_channel *chan, struct ast_fax_session_details *details, struct ast_fax_session *reserved, struct ast_fax_tech_token *token)
1584 {
1585         int ms;
1586         int timeout = RES_FAX_TIMEOUT;
1587         int chancount;
1588         unsigned int expected_frametype = -1;
1589         struct ast_frame_subclass expected_framesubclass = { .integer = 0, };
1590         unsigned int t38negotiated = (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED);
1591         struct ast_control_t38_parameters t38_parameters;
1592         const char *tempvar;
1593         struct ast_fax_session *fax = NULL;
1594         struct ast_frame *frame = NULL;
1595         struct ast_channel *c = chan;
1596         RAII_VAR(struct ast_format *, orig_write_format, NULL, ao2_cleanup);
1597         RAII_VAR(struct ast_format *, orig_read_format, NULL, ao2_cleanup);
1598         int remaining_time;
1599         struct timeval start;
1600
1601         chancount = 1;
1602
1603         /* create the FAX session */
1604         if (!(fax = fax_session_new(details, chan, reserved, token))) {
1605                 ast_log(LOG_ERROR, "Can't create a FAX session, FAX attempt failed.\n");
1606                 report_fax_status(chan, details, "No Available Resource");
1607                 return -1;
1608         }
1609
1610         ast_channel_lock(chan);
1611         /* update session details */
1612         if (ast_strlen_zero(details->headerinfo) && (tempvar = pbx_builtin_getvar_helper(chan, "LOCALHEADERINFO"))) {
1613                 ast_string_field_set(details, headerinfo, tempvar);
1614         }
1615         if (ast_strlen_zero(details->localstationid)) {
1616                 tempvar = pbx_builtin_getvar_helper(chan, "LOCALSTATIONID");
1617                 ast_string_field_set(details, localstationid, tempvar ? tempvar : "unknown");
1618         }
1619         ast_channel_unlock(chan);
1620
1621         report_fax_status(chan, details, "Allocating Resources");
1622
1623         if (details->caps & AST_FAX_TECH_AUDIO) {
1624                 expected_frametype = AST_FRAME_VOICE;
1625                 expected_framesubclass.format = ast_format_slin;
1626                 orig_write_format = ao2_bump(ast_channel_writeformat(chan));
1627                 if (ast_set_write_format(chan, ast_format_slin) < 0) {
1628                         ast_log(LOG_ERROR, "channel '%s' failed to set write format to signed linear'.\n", ast_channel_name(chan));
1629                         ao2_lock(faxregistry.container);
1630                         ao2_unlink(faxregistry.container, fax);
1631                         ao2_unlock(faxregistry.container);
1632                         ao2_ref(fax, -1);
1633                         ast_channel_unlock(chan);
1634                         return -1;
1635                 }
1636                 orig_read_format = ao2_bump(ast_channel_readformat(chan));
1637                 if (ast_set_read_format(chan, ast_format_slin) < 0) {
1638                         ast_log(LOG_ERROR, "channel '%s' failed to set read format to signed linear.\n", ast_channel_name(chan));
1639                         ao2_lock(faxregistry.container);
1640                         ao2_unlink(faxregistry.container, fax);
1641                         ao2_unlock(faxregistry.container);
1642                         ao2_ref(fax, -1);
1643                         ast_channel_unlock(chan);
1644                         return -1;
1645                 }
1646                 if (fax->smoother) {
1647                         ast_smoother_free(fax->smoother);
1648                         fax->smoother = NULL;
1649                 }
1650                 if (!(fax->smoother = ast_smoother_new(320))) {
1651                         ast_log(LOG_WARNING, "Channel '%s' FAX session '%u' failed to obtain a smoother.\n", ast_channel_name(chan), fax->id);
1652                 }
1653         } else {
1654                 expected_frametype = AST_FRAME_MODEM;
1655                 expected_framesubclass.integer = AST_MODEM_T38;
1656         }
1657
1658         if (fax->debug_info) {
1659                 fax->debug_info->base_tv = ast_tvnow();
1660         }
1661
1662         /* reset our result fields just in case the fax tech driver wants to
1663          * set custom error messages */
1664         ast_string_field_set(details, result, "");
1665         ast_string_field_set(details, resultstr, "");
1666         ast_string_field_set(details, error, "");
1667         set_channel_variables(chan, details);
1668
1669         if (fax->tech->start_session(fax) < 0) {
1670                 GENERIC_FAX_EXEC_ERROR(fax, chan, "INIT_ERROR", "failed to start FAX session");
1671         }
1672
1673         report_fax_status(chan, details, "FAX Transmission In Progress");
1674
1675         ast_debug(5, "channel %s will wait on FAX fd %d\n", ast_channel_name(chan), fax->fd);
1676
1677         /* handle frames for the session */
1678         remaining_time = timeout;
1679         start = ast_tvnow();
1680         while (remaining_time > 0) {
1681                 struct ast_channel *ready_chan;
1682                 int ofd, exception;
1683
1684                 ms = 1000;
1685                 errno = 0;
1686                 ready_chan = ast_waitfor_nandfds(&c, chancount, &fax->fd, 1, &exception, &ofd, &ms);
1687                 if (ready_chan) {
1688                         if (!(frame = ast_read(chan))) {
1689                                 /* the channel is probably gone, so lets stop polling on it and let the
1690                                  * FAX session complete before we exit the application.  if needed,
1691                                  * send the FAX stack silence so the modems can finish their session without
1692                                  * any problems */
1693                                 ast_debug(1, "Channel '%s' did not return a frame; probably hung up.\n", ast_channel_name(chan));
1694                                 GENERIC_FAX_EXEC_SET_VARS(fax, chan, "HANGUP", "remote channel hungup");
1695                                 c = NULL;
1696                                 chancount = 0;
1697                                 remaining_time = ast_remaining_ms(start, timeout);
1698                                 fax->tech->cancel_session(fax);
1699                                 if (fax->tech->generate_silence) {
1700                                         fax->tech->generate_silence(fax);
1701                                 }
1702                                 continue;
1703                         }
1704
1705                         if ((frame->frametype == AST_FRAME_CONTROL) &&
1706                             (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1707                             (frame->datalen == sizeof(t38_parameters))) {
1708                                 unsigned int was_t38 = t38negotiated;
1709                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
1710
1711                                 switch (parameters->request_response) {
1712                                 case AST_T38_REQUEST_NEGOTIATE:
1713                                         /* the other end has requested a switch to T.38, so reply that we are willing, if we can
1714                                          * do T.38 as well
1715                                          */
1716                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1717                                         t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
1718                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1719                                         break;
1720                                 case AST_T38_NEGOTIATED:
1721                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1722                                         t38negotiated = 1;
1723                                         break;
1724                                 default:
1725                                         break;
1726                                 }
1727                                 if (t38negotiated && !was_t38) {
1728                                         if (fax->tech->switch_to_t38(fax)) {
1729                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "T.38 switch failed");
1730                                                 break;
1731                                         }
1732                                         details->caps &= ~AST_FAX_TECH_AUDIO;
1733                                         expected_frametype = AST_FRAME_MODEM;
1734                                         expected_framesubclass.integer = AST_MODEM_T38;
1735                                         if (fax->smoother) {
1736                                                 ast_smoother_free(fax->smoother);
1737                                                 fax->smoother = NULL;
1738                                         }
1739
1740                                         report_fax_status(chan, details, "T.38 Negotiated");
1741
1742                                         ast_verb(3, "Channel '%s' switched to T.38 FAX session '%u'.\n", ast_channel_name(chan), fax->id);
1743                                 }
1744                         } else if ((frame->frametype == expected_frametype) && (expected_framesubclass.integer == frame->subclass.integer) &&
1745                                 ((!frame->subclass.format && !expected_framesubclass.format) ||
1746                                 (frame->subclass.format && expected_framesubclass.format &&
1747                                         (ast_format_cmp(frame->subclass.format, expected_framesubclass.format) != AST_FORMAT_CMP_NOT_EQUAL)))) {
1748                                 struct ast_frame *f;
1749
1750                                 if (fax->smoother) {
1751                                         /* push the frame into a smoother */
1752                                         if (ast_smoother_feed(fax->smoother, frame) < 0) {
1753                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "Failed to feed the smoother");
1754                                         }
1755                                         while ((f = ast_smoother_read(fax->smoother)) && (f->data.ptr)) {
1756                                                 if (fax->debug_info) {
1757                                                         debug_check_frame_for_silence(fax, 1, f);
1758                                                 }
1759                                                 /* write the frame to the FAX stack */
1760                                                 fax->tech->write(fax, f);
1761                                                 fax->frames_received++;
1762                                                 if (f != frame) {
1763                                                         ast_frfree(f);
1764                                                 }
1765                                         }
1766                                 } else {
1767                                         /* write the frame to the FAX stack */
1768                                         fax->tech->write(fax, frame);
1769                                         fax->frames_received++;
1770                                 }
1771                                 start = ast_tvnow();
1772                         }
1773                         ast_frfree(frame);
1774                 } else if (ofd == fax->fd) {
1775                         /* read a frame from the FAX stack and send it out the channel.
1776                          * the FAX stack will return a NULL if the FAX session has already completed */
1777                         if (!(frame = fax->tech->read(fax))) {
1778                                 break;
1779                         }
1780
1781                         if (fax->debug_info && (frame->frametype == AST_FRAME_VOICE)) {
1782                                 debug_check_frame_for_silence(fax, 0, frame);
1783                         }
1784
1785                         ast_write(chan, frame);
1786                         fax->frames_sent++;
1787                         ast_frfree(frame);
1788                         start = ast_tvnow();
1789                 } else {
1790                         if (ms && (ofd < 0)) {
1791                                 if ((errno == 0) || (errno == EINTR)) {
1792                                         remaining_time = ast_remaining_ms(start, timeout);
1793                                         if (remaining_time <= 0)
1794                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "TIMEOUT", "fax session timed-out");
1795                                         continue;
1796                                 } else {
1797                                         ast_log(LOG_WARNING, "something bad happened while channel '%s' was polling.\n", ast_channel_name(chan));
1798                                         GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "error polling data");
1799                                         break;
1800                                 }
1801                         } else {
1802                                 /* nothing happened */
1803                                 remaining_time = ast_remaining_ms(start, timeout);
1804                                 if (remaining_time <= 0) {
1805                                         GENERIC_FAX_EXEC_ERROR(fax, chan, "TIMEOUT", "fax session timed-out");
1806                                         break;
1807                                 }
1808                         }
1809                 }
1810         }
1811         ast_debug(3, "channel '%s' - event loop stopped { timeout: %d, remaining_time: %d }\n", ast_channel_name(chan), timeout, remaining_time);
1812
1813         set_channel_variables(chan, details);
1814
1815         ast_atomic_fetchadd_int(&faxregistry.fax_complete, 1);
1816         if (!strcasecmp(details->result, "FAILED")) {
1817                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
1818         }
1819
1820         if (fax) {
1821                 ao2_lock(faxregistry.container);
1822                 ao2_unlink(faxregistry.container, fax);
1823                 ao2_unlock(faxregistry.container);
1824                 ao2_ref(fax, -1);
1825         }
1826
1827         /* if the channel is still alive, and we changed its read/write formats,
1828          * restore them now
1829          */
1830         if (chancount) {
1831                 if (orig_read_format) {
1832                         ast_set_read_format(chan, orig_read_format);
1833                 }
1834                 if (orig_write_format) {
1835                         ast_set_write_format(chan, orig_write_format);
1836                 }
1837         }
1838
1839         /* return the chancount so the calling function can determine if the channel hungup during this FAX session or not */
1840         return chancount;
1841 }
1842
1843 static int receivefax_t38_init(struct ast_channel *chan, struct ast_fax_session_details *details)
1844 {
1845         int timeout_ms;
1846         struct ast_frame *frame = NULL;
1847         struct ast_control_t38_parameters t38_parameters;
1848         struct timeval start;
1849         int ms;
1850
1851         /* don't send any audio if we've already received a T.38 reinvite */
1852         if (ast_channel_get_t38_state(chan) != T38_STATE_NEGOTIATING) {
1853                 /* generate 3 seconds of CED */
1854                 if (ast_playtones_start(chan, 1024, "!2100/3000", 1)) {
1855                         ast_log(LOG_ERROR, "error generating CED tone on %s\n", ast_channel_name(chan));
1856                         return -1;
1857                 }
1858
1859                 timeout_ms = 3000;
1860                 start = ast_tvnow();
1861                 while ((ms = ast_remaining_ms(start, timeout_ms))) {
1862                         ms = ast_waitfor(chan, ms);
1863
1864                         if (ms < 0) {
1865                                 ast_log(LOG_ERROR, "error while generating CED tone on %s\n", ast_channel_name(chan));
1866                                 ast_playtones_stop(chan);
1867                                 return -1;
1868                         }
1869
1870                         if (ms == 0) { /* all done, nothing happened */
1871                                 break;
1872                         }
1873
1874                         if (!(frame = ast_read(chan))) {
1875                                 ast_log(LOG_ERROR, "error reading frame while generating CED tone on %s\n", ast_channel_name(chan));
1876                                 ast_playtones_stop(chan);
1877                                 return -1;
1878                         }
1879
1880                         if ((frame->frametype == AST_FRAME_CONTROL) &&
1881                             (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1882                             (frame->datalen == sizeof(t38_parameters))) {
1883                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
1884
1885                                 switch (parameters->request_response) {
1886                                 case AST_T38_REQUEST_NEGOTIATE:
1887                                         /* the other end has requested a switch to T.38, so reply that we are willing, if we can
1888                                          * do T.38 as well
1889                                          */
1890                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1891                                         t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
1892                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1893                                         ast_playtones_stop(chan);
1894                                         break;
1895                                 case AST_T38_NEGOTIATED:
1896                                         ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
1897                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1898                                         details->caps &= ~AST_FAX_TECH_AUDIO;
1899                                         report_fax_status(chan, details, "T.38 Negotiated");
1900                                         break;
1901                                 default:
1902                                         break;
1903                                 }
1904                         }
1905                         ast_frfree(frame);
1906                 }
1907
1908                 ast_playtones_stop(chan);
1909         }
1910
1911         /* if T.38 was negotiated, we are done initializing */
1912         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
1913                 return 0;
1914         }
1915
1916         /* request T.38 */
1917         ast_debug(1, "Negotiating T.38 for receive on %s\n", ast_channel_name(chan));
1918
1919         /* wait for negotiation to complete */
1920         timeout_ms = details->t38timeout;
1921
1922         /* set parameters based on the session's parameters */
1923         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1924         t38_parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
1925         if ((ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0)) {
1926                 return -1;
1927         }
1928
1929         start = ast_tvnow();
1930         while ((ms = ast_remaining_ms(start, timeout_ms))) {
1931                 int break_loop = 0;
1932
1933                 ms = ast_waitfor(chan, ms);
1934                 if (ms < 0) {
1935                         ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
1936                         return -1;
1937                 }
1938                 if (ms == 0) { /* all done, nothing happened */
1939                         ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 negotiation.\n", ast_channel_name(chan));
1940                         details->caps &= ~AST_FAX_TECH_T38;
1941                         break;
1942                 }
1943
1944                 if (!(frame = ast_read(chan))) {
1945                         ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
1946                         return -1;
1947                 }
1948
1949                 if ((frame->frametype == AST_FRAME_CONTROL) &&
1950                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1951                                 (frame->datalen == sizeof(t38_parameters))) {
1952                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
1953
1954                         switch (parameters->request_response) {
1955                         case AST_T38_REQUEST_NEGOTIATE:
1956                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1957                                 t38_parameters.request_response = AST_T38_NEGOTIATED;
1958                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1959                                 break;
1960                         case AST_T38_NEGOTIATED:
1961                                 ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
1962                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1963                                 details->caps &= ~AST_FAX_TECH_AUDIO;
1964                                 report_fax_status(chan, details, "T.38 Negotiated");
1965                                 break_loop = 1;
1966                                 break;
1967                         case AST_T38_REFUSED:
1968                                 ast_log(LOG_WARNING, "channel '%s' refused to negotiate T.38\n", ast_channel_name(chan));
1969                                 details->caps &= ~AST_FAX_TECH_T38;
1970                                 break_loop = 1;
1971                                 break;
1972                         default:
1973                                 ast_log(LOG_ERROR, "channel '%s' failed to negotiate T.38\n", ast_channel_name(chan));
1974                                 details->caps &= ~AST_FAX_TECH_T38;
1975                                 break_loop = 1;
1976                                 break;
1977                         }
1978                 }
1979                 ast_frfree(frame);
1980                 if (break_loop) {
1981                         break;
1982                 }
1983         }
1984
1985         /* if T.38 was negotiated, we are done initializing */
1986         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
1987                 return 0;
1988         }
1989
1990         /* if we made it here, then T.38 failed, check the 'f' flag */
1991         if (details->option.allow_audio != AST_FAX_OPTFLAG_TRUE) {
1992                 ast_log(LOG_WARNING, "Audio FAX not allowed on channel '%s' and T.38 negotiation failed; aborting.\n", ast_channel_name(chan));
1993                 return -1;
1994         }
1995
1996         /* ok, audio fallback is allowed */
1997         details->caps |= AST_FAX_TECH_AUDIO;
1998
1999         return 0;
2000 }
2001
2002 /*! \brief Report on the final state of a receive fax operation
2003  * \note This will lock the \ref ast_channel
2004  */
2005 static int report_receive_fax_status(struct ast_channel *chan, const char *filename)
2006 {
2007         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
2008         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
2009         RAII_VAR(struct ast_json *, json_array, ast_json_array_create(), ast_json_unref);
2010         struct ast_json *json_filename = ast_json_string_create(filename);
2011
2012         if (!json_array || !json_filename) {
2013                 ast_json_unref(json_filename);
2014                 return -1;
2015         }
2016         ast_json_array_append(json_array, json_filename);
2017
2018         {
2019                 const char *remote_station_id;
2020                 const char *local_station_id;
2021                 const char *fax_pages;
2022                 const char *fax_resolution;
2023                 const char *fax_bitrate;
2024                 SCOPED_CHANNELLOCK(lock, chan);
2025
2026                 remote_station_id = S_OR(pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), "");
2027                 if (!ast_strlen_zero(remote_station_id)) {
2028                         remote_station_id = ast_strdupa(remote_station_id);
2029                 }
2030                 local_station_id = S_OR(pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), "");
2031                 if (!ast_strlen_zero(local_station_id)) {
2032                         local_station_id = ast_strdupa(local_station_id);
2033                 }
2034                 fax_pages = S_OR(pbx_builtin_getvar_helper(chan, "FAXPAGES"), "");
2035                 if (!ast_strlen_zero(fax_pages)) {
2036                         fax_pages = ast_strdupa(fax_pages);
2037                 }
2038                 fax_resolution = S_OR(pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), "");
2039                 if (!ast_strlen_zero(fax_resolution)) {
2040                         fax_resolution = ast_strdupa(fax_resolution);
2041                 }
2042                 fax_bitrate = S_OR(pbx_builtin_getvar_helper(chan, "FAXBITRATE"), "");
2043                 if (!ast_strlen_zero(fax_bitrate)) {
2044                         fax_bitrate = ast_strdupa(fax_bitrate);
2045                 }
2046
2047                 json_object = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s, s: O}",
2048                                 "type", "receive",
2049                                 "remote_station_id", S_OR(remote_station_id, ""),
2050                                 "local_station_id", S_OR(local_station_id, ""),
2051                                 "fax_pages", S_OR(fax_pages, ""),
2052                                 "fax_resolution", S_OR(fax_resolution, ""),
2053                                 "fax_bitrate", S_OR(fax_bitrate, ""),
2054                                 "filenames", json_array);
2055                 if (!json_object) {
2056                         return -1;
2057                 }
2058
2059                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_object);
2060                 if (!message) {
2061                         return -1;
2062                 }
2063                 stasis_publish(ast_channel_topic(chan), message);
2064         }
2065         return 0;
2066 }
2067
2068 /*! \brief initiate a receive FAX session */
2069 static int receivefax_exec(struct ast_channel *chan, const char *data)
2070 {
2071         char *parse, modems[128] = "";
2072         int channel_alive;
2073         RAII_VAR(struct ast_fax_session *, s, NULL, ao2_cleanup);
2074         RAII_VAR(struct ast_fax_session_details *, details, NULL, ao2_cleanup);
2075         struct ast_fax_tech_token *token = NULL;
2076         struct ast_fax_document *doc;
2077         AST_DECLARE_APP_ARGS(args,
2078                 AST_APP_ARG(filename);
2079                 AST_APP_ARG(options);
2080         );
2081         struct ast_flags opts = { 0, };
2082         enum ast_t38_state t38state;
2083
2084         /* initialize output channel variables */
2085         pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED");
2086         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL);
2087         pbx_builtin_setvar_helper(chan, "FAXPAGES", "0");
2088         pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL);
2089         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL);
2090
2091         /* Get a FAX session details structure from the channel's FAX datastore and create one if
2092          * it does not already exist. */
2093         if (!(details = find_or_create_details(chan))) {
2094                 pbx_builtin_setvar_helper(chan, "FAXERROR", "MEMORY_ERROR");
2095                 pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "error allocating memory");
2096                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2097                 return -1;
2098         }
2099
2100         ast_string_field_set(details, result, "FAILED");
2101         ast_string_field_set(details, resultstr, "error starting fax session");
2102         ast_string_field_set(details, error, "INIT_ERROR");
2103         set_channel_variables(chan, details);
2104
2105         if (details->gateway_id > 0) {
2106                 ast_string_field_set(details, resultstr, "can't receive a fax on a channel with a T.38 gateway");
2107                 set_channel_variables(chan, details);
2108                 ast_log(LOG_ERROR, "executing ReceiveFAX on a channel with a T.38 Gateway is not supported\n");
2109                 return -1;
2110         }
2111
2112         if (details->maxrate < details->minrate) {
2113                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2114                 ast_string_field_set(details, resultstr, "maxrate is less than minrate");
2115                 set_channel_variables(chan, details);
2116                 ast_log(LOG_ERROR, "maxrate %u is less than minrate %u\n", details->maxrate, details->minrate);
2117                 return -1;
2118         }
2119
2120         if (check_modem_rate(details->modems, details->minrate)) {
2121                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2122                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'minrate' setting %u\n", modems, details->minrate);
2123                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2124                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'minrate' settings");
2125                 set_channel_variables(chan, details);
2126                 return -1;
2127         }
2128
2129         if (check_modem_rate(details->modems, details->maxrate)) {
2130                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2131                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'maxrate' setting %u\n", modems, details->maxrate);
2132                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2133                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'maxrate' settings");
2134                 set_channel_variables(chan, details);
2135                 return -1;
2136         }
2137
2138         if (ast_strlen_zero(data)) {
2139                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2140                 ast_string_field_set(details, resultstr, "invalid arguments");
2141                 set_channel_variables(chan, details);
2142                 ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax);
2143                 return -1;
2144         }
2145         parse = ast_strdupa(data);
2146         AST_STANDARD_APP_ARGS(args, parse);
2147
2148         if (!ast_strlen_zero(args.options) &&
2149             ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) {
2150                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2151                 ast_string_field_set(details, resultstr, "invalid arguments");
2152                 set_channel_variables(chan, details);
2153                 return -1;
2154         }
2155         if (ast_strlen_zero(args.filename)) {
2156                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2157                 ast_string_field_set(details, resultstr, "invalid arguments");
2158                 set_channel_variables(chan, details);
2159                 ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax);
2160                 return -1;
2161         }
2162
2163         /* check for unsupported FAX application options */
2164         if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) {
2165                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2166                 ast_string_field_set(details, resultstr, "invalid arguments");
2167                 set_channel_variables(chan, details);
2168                 ast_log(LOG_WARNING, "%s does not support polling\n", app_receivefax);
2169                 return -1;
2170         }
2171
2172         ast_atomic_fetchadd_int(&faxregistry.fax_rx_attempts, 1);
2173
2174         pbx_builtin_setvar_helper(chan, "FAXERROR", "Channel Problems");
2175         pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Error before FAX transmission started.");
2176
2177         if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(args.filename) + 1))) {
2178                 ast_string_field_set(details, error, "MEMORY_ERROR");
2179                 ast_string_field_set(details, resultstr, "error allocating memory");
2180                 set_channel_variables(chan, details);
2181                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2182                 return -1;
2183         }
2184
2185         strcpy(doc->filename, args.filename);
2186         AST_LIST_INSERT_TAIL(&details->documents, doc, next);
2187
2188         ast_verb(3, "Channel '%s' receiving FAX '%s'\n", ast_channel_name(chan), args.filename);
2189
2190         details->caps = AST_FAX_TECH_RECEIVE;
2191         details->option.send_ced = AST_FAX_OPTFLAG_TRUE;
2192
2193         /* check for debug */
2194         if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) {
2195                 details->option.debug = AST_FAX_OPTFLAG_TRUE;
2196         }
2197
2198         /* check for request for status events */
2199         if (ast_test_flag(&opts, OPT_STATUS)) {
2200                 details->option.statusevents = AST_FAX_OPTFLAG_TRUE;
2201         }
2202
2203         t38state = ast_channel_get_t38_state(chan);
2204         if ((t38state == T38_STATE_UNAVAILABLE) || (t38state == T38_STATE_REJECTED) ||
2205             ast_test_flag(&opts, OPT_ALLOWAUDIO) ||
2206             ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2207                 details->option.allow_audio = AST_FAX_OPTFLAG_TRUE;
2208         }
2209
2210         if (!(s = fax_session_reserve(details, &token))) {
2211                 ast_string_field_set(details, resultstr, "error reserving fax session");
2212                 set_channel_variables(chan, details);
2213                 ast_log(LOG_ERROR, "Unable to reserve FAX session.\n");
2214                 return -1;
2215         }
2216
2217         /* make sure the channel is up */
2218         if (ast_channel_state(chan) != AST_STATE_UP) {
2219                 if (ast_answer(chan)) {
2220                         ast_string_field_set(details, resultstr, "error answering channel");
2221                         set_channel_variables(chan, details);
2222                         ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", ast_channel_name(chan));
2223                         fax_session_release(s, token);
2224                         return -1;
2225                 }
2226         }
2227
2228         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2229                 if (set_fax_t38_caps(chan, details)) {
2230                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2231                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2232                         set_channel_variables(chan, details);
2233                         fax_session_release(s, token);
2234                         return -1;
2235                 }
2236         } else {
2237                 details->caps |= AST_FAX_TECH_AUDIO;
2238         }
2239
2240         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO) && (details->caps & AST_FAX_TECH_T38)) {
2241                 if (receivefax_t38_init(chan, details)) {
2242                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2243                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2244                         set_channel_variables(chan, details);
2245                         fax_session_release(s, token);
2246                         ast_log(LOG_ERROR, "error initializing channel '%s' in T.38 mode\n", ast_channel_name(chan));
2247                         return -1;
2248                 }
2249         }
2250
2251         if ((channel_alive = generic_fax_exec(chan, details, s, token)) < 0) {
2252                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
2253         }
2254
2255         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2256                 if (disable_t38(chan)) {
2257                         ast_debug(1, "error disabling T.38 mode on %s\n", ast_channel_name(chan));
2258                 }
2259         }
2260
2261         if (report_receive_fax_status(chan, args.filename)) {
2262                 ast_log(AST_LOG_ERROR, "Error publishing ReceiveFax status message\n");
2263         }
2264
2265         /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */
2266         return (!channel_alive) ? -1 : 0;
2267 }
2268
2269 static int sendfax_t38_init(struct ast_channel *chan, struct ast_fax_session_details *details)
2270 {
2271         int timeout_ms;
2272         struct ast_frame *frame = NULL;
2273         struct ast_control_t38_parameters t38_parameters;
2274         struct timeval start;
2275         int ms;
2276
2277         /* send CNG tone while listening for the receiver to initiate a switch
2278          * to T.38 mode; if they do, stop sending the CNG tone and proceed with
2279          * the switch.
2280          *
2281          * 10500 is enough time for 3 CNG tones
2282          */
2283         timeout_ms = 10500;
2284
2285         /* don't send any audio if we've already received a T.38 reinvite */
2286         if (ast_channel_get_t38_state(chan) != T38_STATE_NEGOTIATING) {
2287                 if (ast_playtones_start(chan, 1024, "!1100/500,!0/3000,!1100/500,!0/3000,!1100/500,!0/3000", 1)) {
2288                         ast_log(LOG_ERROR, "error generating CNG tone on %s\n", ast_channel_name(chan));
2289                         return -1;
2290                 }
2291         }
2292
2293         start = ast_tvnow();
2294         while ((ms = ast_remaining_ms(start, timeout_ms))) {
2295                 int break_loop = 0;
2296                 ms = ast_waitfor(chan, ms);
2297
2298                 if (ms < 0) {
2299                         ast_log(LOG_ERROR, "error while generating CNG tone on %s\n", ast_channel_name(chan));
2300                         ast_playtones_stop(chan);
2301                         return -1;
2302                 }
2303
2304                 if (ms == 0) { /* all done, nothing happened */
2305                         break;
2306                 }
2307
2308                 if (!(frame = ast_read(chan))) {
2309                         ast_log(LOG_ERROR, "error reading frame while generating CNG tone on %s\n", ast_channel_name(chan));
2310                         ast_playtones_stop(chan);
2311                         return -1;
2312                 }
2313
2314                 if ((frame->frametype == AST_FRAME_CONTROL) &&
2315                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2316                                 (frame->datalen == sizeof(t38_parameters))) {
2317                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
2318
2319                         switch (parameters->request_response) {
2320                         case AST_T38_REQUEST_NEGOTIATE:
2321                                 /* the other end has requested a switch to T.38, so reply that we are willing, if we can
2322                                  * do T.38 as well
2323                                  */
2324                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2325                                 t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
2326                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2327                                 ast_playtones_stop(chan);
2328                                 break;
2329                         case AST_T38_NEGOTIATED:
2330                                 ast_debug(1, "Negotiated T.38 for send on %s\n", ast_channel_name(chan));
2331                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2332                                 details->caps &= ~AST_FAX_TECH_AUDIO;
2333                                 report_fax_status(chan, details, "T.38 Negotiated");
2334                                 break_loop = 1;
2335                                 break;
2336                         default:
2337                                 break;
2338                         }
2339                 }
2340                 ast_frfree(frame);
2341                 if (break_loop) {
2342                         break;
2343                 }
2344         }
2345
2346         ast_playtones_stop(chan);
2347
2348         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2349                 return 0;
2350         }
2351
2352         /* T.38 negotiation did not happen, initiate a switch if requested */
2353         if (details->option.request_t38 == AST_FAX_OPTFLAG_TRUE) {
2354                 ast_debug(1, "Negotiating T.38 for send on %s\n", ast_channel_name(chan));
2355
2356                 /* wait up to five seconds for negotiation to complete */
2357                 timeout_ms = 5000;
2358
2359                 /* set parameters based on the session's parameters */
2360                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2361                 t38_parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
2362                 if ((ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0)) {
2363                         return -1;
2364                 }
2365
2366                 start = ast_tvnow();
2367                 while ((ms = ast_remaining_ms(start, timeout_ms))) {
2368                         int break_loop = 0;
2369
2370                         ms = ast_waitfor(chan, ms);
2371                         if (ms < 0) {
2372                                 ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
2373                                 return -1;
2374                         }
2375                         if (ms == 0) { /* all done, nothing happened */
2376                                 ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 negotiation.\n", ast_channel_name(chan));
2377                                 details->caps &= ~AST_FAX_TECH_T38;
2378                                 break;
2379                         }
2380
2381                         if (!(frame = ast_read(chan))) {
2382                                 ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
2383                                 return -1;
2384                         }
2385
2386                         if ((frame->frametype == AST_FRAME_CONTROL) &&
2387                                         (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2388                                         (frame->datalen == sizeof(t38_parameters))) {
2389                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
2390
2391                                 switch (parameters->request_response) {
2392                                 case AST_T38_REQUEST_NEGOTIATE:
2393                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2394                                         t38_parameters.request_response = AST_T38_NEGOTIATED;
2395                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2396                                         break;
2397                                 case AST_T38_NEGOTIATED:
2398                                         ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
2399                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2400                                         details->caps &= ~AST_FAX_TECH_AUDIO;
2401                                         report_fax_status(chan, details, "T.38 Negotiated");
2402                                         break_loop = 1;
2403                                         break;
2404                                 case AST_T38_REFUSED:
2405                                         ast_log(LOG_WARNING, "channel '%s' refused to negotiate T.38\n", ast_channel_name(chan));
2406                                         details->caps &= ~AST_FAX_TECH_T38;
2407                                         break_loop = 1;
2408                                         break;
2409                                 default:
2410                                         ast_log(LOG_ERROR, "channel '%s' failed to negotiate T.38\n", ast_channel_name(chan));
2411                                         details->caps &= ~AST_FAX_TECH_T38;
2412                                         break_loop = 1;
2413                                         break;
2414                                 }
2415                         }
2416                         ast_frfree(frame);
2417                         if (break_loop) {
2418                                 break;
2419                         }
2420                 }
2421
2422                 /* if T.38 was negotiated, we are done initializing */
2423                 if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2424                         return 0;
2425                 }
2426
2427                 /* send one more CNG tone to get audio going again for some
2428                  * carriers if we are going to fall back to audio mode */
2429                 if (details->option.allow_audio == AST_FAX_OPTFLAG_TRUE) {
2430                         if (ast_playtones_start(chan, 1024, "!1100/500,!0/3000", 1)) {
2431                                 ast_log(LOG_ERROR, "error generating second CNG tone on %s\n", ast_channel_name(chan));
2432                                 return -1;
2433                         }
2434
2435                         timeout_ms = 3500;
2436                         start = ast_tvnow();
2437                         while ((ms = ast_remaining_ms(start, timeout_ms))) {
2438                                 int break_loop = 0;
2439
2440                                 ms = ast_waitfor(chan, ms);
2441                                 if (ms < 0) {
2442                                         ast_log(LOG_ERROR, "error while generating second CNG tone on %s\n", ast_channel_name(chan));
2443                                         ast_playtones_stop(chan);
2444                                         return -1;
2445                                 }
2446                                 if (ms == 0) { /* all done, nothing happened */
2447                                         break;
2448                                 }
2449
2450                                 if (!(frame = ast_read(chan))) {
2451                                         ast_log(LOG_ERROR, "error reading frame while generating second CNG tone on %s\n", ast_channel_name(chan));
2452                                         ast_playtones_stop(chan);
2453                                         return -1;
2454                                 }
2455
2456                                 if ((frame->frametype == AST_FRAME_CONTROL) &&
2457                                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2458                                                 (frame->datalen == sizeof(t38_parameters))) {
2459                                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
2460
2461                                         switch (parameters->request_response) {
2462                                         case AST_T38_REQUEST_NEGOTIATE:
2463                                                 /* the other end has requested a switch to T.38, so reply that we are willing, if we can
2464                                                  * do T.38 as well
2465                                                  */
2466                                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2467                                                 t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
2468                                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2469                                                 ast_playtones_stop(chan);
2470                                                 break;
2471                                         case AST_T38_NEGOTIATED:
2472                                                 ast_debug(1, "Negotiated T.38 for send on %s\n", ast_channel_name(chan));
2473                                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2474                                                 details->caps &= ~AST_FAX_TECH_AUDIO;
2475                                                 report_fax_status(chan, details, "T.38 Negotiated");
2476                                                 break_loop = 1;
2477                                                 break;
2478                                         default:
2479                                                 break;
2480                                         }
2481                                 }
2482                                 ast_frfree(frame);
2483                                 if (break_loop) {
2484                                         break;
2485                                 }
2486                         }
2487
2488                         ast_playtones_stop(chan);
2489
2490                         /* if T.38 was negotiated, we are done initializing */
2491                         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2492                                 return 0;
2493                         }
2494                 }
2495         }
2496
2497         /* if we made it here, then T.38 failed, check the 'f' flag */
2498         if (details->option.allow_audio == AST_FAX_OPTFLAG_FALSE) {
2499                 ast_log(LOG_WARNING, "Audio FAX not allowed on channel '%s' and T.38 negotiation failed; aborting.\n", ast_channel_name(chan));
2500                 return -1;
2501         }
2502
2503         /* ok, audio fallback is allowed */
2504         details->caps |= AST_FAX_TECH_AUDIO;
2505
2506         return 0;
2507 }
2508
2509 /*!
2510  * \brief Report on the status of a completed fax send attempt
2511  * \note This will lock the \ref ast_channel
2512  */
2513 static int report_send_fax_status(struct ast_channel *chan, struct ast_fax_session_details *details)
2514 {
2515         RAII_VAR(struct ast_json *, json_obj, NULL, ast_json_unref);
2516         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
2517         struct ast_json *json_filenames;
2518
2519         json_filenames = generate_filenames_json(details);
2520         if (!json_filenames) {
2521                 return -1;
2522         }
2523
2524         {
2525                 const char *remote_station_id;
2526                 const char *local_station_id;
2527                 const char *fax_pages;
2528                 const char *fax_resolution;
2529                 const char *fax_bitrate;
2530                 SCOPED_CHANNELLOCK(lock, chan);
2531
2532                 remote_station_id = S_OR(pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), "");
2533                 if (!ast_strlen_zero(remote_station_id)) {
2534                         remote_station_id = ast_strdupa(remote_station_id);
2535                 }
2536                 local_station_id = S_OR(pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), "");
2537                 if (!ast_strlen_zero(local_station_id)) {
2538                         local_station_id = ast_strdupa(local_station_id);
2539                 }
2540                 fax_pages = S_OR(pbx_builtin_getvar_helper(chan, "FAXPAGES"), "");
2541                 if (!ast_strlen_zero(fax_pages)) {
2542                         fax_pages = ast_strdupa(fax_pages);
2543                 }
2544                 fax_resolution = S_OR(pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), "");
2545                 if (!ast_strlen_zero(fax_resolution)) {
2546                         fax_resolution = ast_strdupa(fax_resolution);
2547                 }
2548                 fax_bitrate = S_OR(pbx_builtin_getvar_helper(chan, "FAXBITRATE"), "");
2549                 if (!ast_strlen_zero(fax_bitrate)) {
2550                         fax_bitrate = ast_strdupa(fax_bitrate);
2551                 }
2552                 json_obj = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s, s: o}",
2553                                 "type", "send",
2554                                 "remote_station_id", S_OR(remote_station_id, ""),
2555                                 "local_station_id", S_OR(local_station_id, ""),
2556                                 "fax_pages", S_OR(fax_pages, ""),
2557                                 "fax_resolution", S_OR(fax_resolution, ""),
2558                                 "fax_bitrate", S_OR(fax_bitrate, ""),
2559                                 "filenames", json_filenames);
2560                 if (!json_obj) {
2561                         return -1;
2562                 }
2563
2564                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_obj);
2565                 if (!message) {
2566                         return -1;
2567                 }
2568                 stasis_publish(ast_channel_topic(chan), message);
2569         }
2570         return 0;
2571 }
2572
2573
2574
2575 /*! \brief initiate a send FAX session */
2576 static int sendfax_exec(struct ast_channel *chan, const char *data)
2577 {
2578         char *parse, *filenames, *c, modems[128] = "";
2579         int channel_alive, file_count;
2580         RAII_VAR(struct ast_fax_session_details *, details, NULL, ao2_cleanup);
2581         RAII_VAR(struct ast_fax_session *, s, NULL, ao2_cleanup);
2582         struct ast_fax_tech_token *token = NULL;
2583         struct ast_fax_document *doc;
2584         AST_DECLARE_APP_ARGS(args,
2585                 AST_APP_ARG(filenames);
2586                 AST_APP_ARG(options);
2587         );
2588         struct ast_flags opts = { 0, };
2589         enum ast_t38_state t38state;
2590
2591         /* initialize output channel variables */
2592         pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED");
2593         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL);
2594         pbx_builtin_setvar_helper(chan, "FAXPAGES", "0");
2595         pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL);
2596         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL);
2597
2598         /* Get a requirement structure and set it.  This structure is used
2599          * to tell the FAX technology module about the higher level FAX session */
2600         if (!(details = find_or_create_details(chan))) {
2601                 pbx_builtin_setvar_helper(chan, "FAXERROR", "MEMORY_ERROR");
2602                 pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "error allocating memory");
2603                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2604                 return -1;
2605         }
2606
2607         ast_string_field_set(details, result, "FAILED");
2608         ast_string_field_set(details, resultstr, "error starting fax session");
2609         ast_string_field_set(details, error, "INIT_ERROR");
2610         set_channel_variables(chan, details);
2611
2612         if (details->gateway_id > 0) {
2613                 ast_string_field_set(details, resultstr, "can't send a fax on a channel with a T.38 gateway");
2614                 set_channel_variables(chan, details);
2615                 ast_log(LOG_ERROR, "executing SendFAX on a channel with a T.38 Gateway is not supported\n");
2616                 return -1;
2617         }
2618
2619         if (details->maxrate < details->minrate) {
2620                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2621                 ast_string_field_set(details, resultstr, "maxrate is less than minrate");
2622                 set_channel_variables(chan, details);
2623                 ast_log(LOG_ERROR, "maxrate %u is less than minrate %u\n", details->maxrate, details->minrate);
2624                 return -1;
2625         }
2626
2627         if (check_modem_rate(details->modems, details->minrate)) {
2628                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2629                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'minrate' setting %u\n", modems, details->minrate);
2630                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2631                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'minrate' settings");
2632                 set_channel_variables(chan, details);
2633                 return -1;
2634         }
2635
2636         if (check_modem_rate(details->modems, details->maxrate)) {
2637                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2638                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'maxrate' setting %u\n", modems, details->maxrate);
2639                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2640                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'maxrate' settings");
2641                 set_channel_variables(chan, details);
2642                 return -1;
2643         }
2644
2645         if (ast_strlen_zero(data)) {
2646                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2647                 ast_string_field_set(details, resultstr, "invalid arguments");
2648                 set_channel_variables(chan, details);
2649                 ast_log(LOG_WARNING, "%s requires an argument (filename[&filename[&filename]][,options])\n", app_sendfax);
2650                 return -1;
2651         }
2652         parse = ast_strdupa(data);
2653         AST_STANDARD_APP_ARGS(args, parse);
2654
2655
2656         if (!ast_strlen_zero(args.options) &&
2657                 ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) {
2658                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2659                 ast_string_field_set(details, resultstr, "invalid arguments");
2660                 set_channel_variables(chan, details);
2661                 return -1;
2662         }
2663         if (ast_strlen_zero(args.filenames)) {
2664                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2665                 ast_string_field_set(details, resultstr, "invalid arguments");
2666                 set_channel_variables(chan, details);
2667                 ast_log(LOG_WARNING, "%s requires an argument (filename[&filename[&filename]],options])\n", app_sendfax);
2668                 return -1;
2669         }
2670
2671         /* check for unsupported FAX application options */
2672         if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) {
2673                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2674                 ast_string_field_set(details, resultstr, "invalid arguments");
2675                 set_channel_variables(chan, details);
2676                 ast_log(LOG_WARNING, "%s does not support polling\n", app_sendfax);
2677                 return -1;
2678         }
2679
2680         ast_atomic_fetchadd_int(&faxregistry.fax_tx_attempts, 1);
2681
2682         file_count = 0;
2683         filenames = args.filenames;
2684         while ((c = strsep(&filenames, "&"))) {
2685                 if (access(c, (F_OK | R_OK)) < 0) {
2686                         ast_string_field_set(details, error, "FILE_ERROR");
2687                         ast_string_field_set(details, resultstr, "error reading file");
2688                         set_channel_variables(chan, details);
2689                         ast_log(LOG_ERROR, "access failure.  Verify '%s' exists and check permissions.\n", args.filenames);
2690                         return -1;
2691                 }
2692
2693                 if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(c) + 1))) {
2694                         ast_string_field_set(details, error, "MEMORY_ERROR");
2695                         ast_string_field_set(details, resultstr, "error allocating memory");
2696                         set_channel_variables(chan, details);
2697                         ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2698                         return -1;
2699                 }
2700
2701                 strcpy(doc->filename, c);
2702                 AST_LIST_INSERT_TAIL(&details->documents, doc, next);
2703                 file_count++;
2704         }
2705
2706         ast_verb(3, "Channel '%s' sending FAX:\n", ast_channel_name(chan));
2707         AST_LIST_TRAVERSE(&details->documents, doc, next) {
2708                 ast_verb(3, "   %s\n", doc->filename);
2709         }
2710
2711         details->caps = AST_FAX_TECH_SEND;
2712
2713         if (file_count > 1) {
2714                 details->caps |= AST_FAX_TECH_MULTI_DOC;
2715         }
2716
2717         /* check for debug */
2718         if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) {
2719                 details->option.debug = AST_FAX_OPTFLAG_TRUE;
2720         }
2721
2722         /* check for request for status events */
2723         if (ast_test_flag(&opts, OPT_STATUS)) {
2724                 details->option.statusevents = AST_FAX_OPTFLAG_TRUE;
2725         }
2726
2727         t38state = ast_channel_get_t38_state(chan);
2728         if ((t38state == T38_STATE_UNAVAILABLE) || (t38state == T38_STATE_REJECTED) ||
2729             ast_test_flag(&opts, OPT_ALLOWAUDIO) ||
2730             ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2731                 details->option.allow_audio = AST_FAX_OPTFLAG_TRUE;
2732         }
2733
2734         if (ast_test_flag(&opts, OPT_REQUEST_T38)) {
2735                 details->option.request_t38 = AST_FAX_OPTFLAG_TRUE;
2736         }
2737
2738         if (!(s = fax_session_reserve(details, &token))) {
2739                 ast_string_field_set(details, resultstr, "error reserving fax session");
2740                 set_channel_variables(chan, details);
2741                 ast_log(LOG_ERROR, "Unable to reserve FAX session.\n");
2742                 return -1;
2743         }
2744
2745         /* make sure the channel is up */
2746         if (ast_channel_state(chan) != AST_STATE_UP) {
2747                 if (ast_answer(chan)) {
2748                         ast_string_field_set(details, resultstr, "error answering channel");
2749                         set_channel_variables(chan, details);
2750                         ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", ast_channel_name(chan));
2751                         fax_session_release(s, token);
2752                         return -1;
2753                 }
2754         }
2755
2756         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2757                 if (set_fax_t38_caps(chan, details)) {
2758                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2759                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2760                         set_channel_variables(chan, details);
2761                         fax_session_release(s, token);
2762                         return -1;
2763                 }
2764         } else {
2765                 details->caps |= AST_FAX_TECH_AUDIO;
2766         }
2767
2768         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO) && (details->caps & AST_FAX_TECH_T38)) {
2769                 if (sendfax_t38_init(chan, details)) {
2770                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2771                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2772                         set_channel_variables(chan, details);
2773                         fax_session_release(s, token);
2774                         ast_log(LOG_ERROR, "error initializing channel '%s' in T.38 mode\n", ast_channel_name(chan));
2775                         return -1;
2776                 }
2777         } else {
2778                 details->option.send_cng = 1;
2779         }
2780
2781         if ((channel_alive = generic_fax_exec(chan, details, s, token)) < 0) {
2782                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
2783         }
2784
2785         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2786                 if (disable_t38(chan)) {
2787                         ast_debug(1, "error disabling T.38 mode on %s\n", ast_channel_name(chan));
2788                 }
2789         }
2790
2791         if (!(filenames = generate_filenames_string(details, "FileName: ", "\r\n"))) {
2792                 ast_log(LOG_ERROR, "Error generating SendFAX manager event\n");
2793                 return (!channel_alive) ? -1 : 0;
2794         }
2795
2796         /* send out the AMI completion event */
2797         if (report_send_fax_status(chan, details)) {
2798                 ast_log(AST_LOG_ERROR, "Error publishing SendFAX status message\n");
2799         }
2800
2801         /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */
2802         return (!channel_alive) ? -1 : 0;
2803 }
2804
2805 /*! \brief destroy the v21 detection parts of a fax gateway session */
2806 static void destroy_v21_sessions(struct fax_gateway *gateway)
2807 {
2808         if (gateway->chan_v21_session) {
2809                 ao2_lock(faxregistry.container);
2810                 ao2_unlink(faxregistry.container, gateway->chan_v21_session);
2811                 ao2_unlock(faxregistry.container);
2812
2813                 ao2_ref(gateway->chan_v21_session, -1);
2814                 gateway->chan_v21_session = NULL;
2815         }
2816
2817         if (gateway->peer_v21_session) {
2818                 ao2_lock(faxregistry.container);
2819                 ao2_unlink(faxregistry.container, gateway->peer_v21_session);
2820                 ao2_unlock(faxregistry.container);
2821
2822                 ao2_ref(gateway->peer_v21_session, -1);
2823                 gateway->peer_v21_session = NULL;
2824         }
2825 }
2826
2827 /*! \brief destroy a FAX gateway session structure */
2828 static void destroy_gateway(void *data)
2829 {
2830         struct fax_gateway *gateway = data;
2831
2832         destroy_v21_sessions(gateway);
2833
2834         if (gateway->s) {
2835                 fax_session_release(gateway->s, gateway->token);
2836                 gateway->token = NULL;
2837
2838                 ao2_lock(faxregistry.container);
2839                 ao2_unlink(faxregistry.container, gateway->s);
2840                 ao2_unlock(faxregistry.container);
2841
2842                 ao2_ref(gateway->s, -1);
2843                 gateway->s = NULL;
2844         }
2845
2846         ao2_cleanup(gateway->chan_read_format);
2847         ao2_cleanup(gateway->chan_write_format);
2848         ao2_cleanup(gateway->peer_read_format);
2849         ao2_cleanup(gateway->peer_write_format);
2850 }
2851
2852 /*! \brief Create a new fax gateway object.
2853  * \param chan the channel the gateway object will be attached to
2854  * \param details the fax session details
2855  * \return NULL or a fax gateway object
2856  */
2857 static struct fax_gateway *fax_gateway_new(struct ast_channel *chan, struct ast_fax_session_details *details)
2858 {
2859         struct fax_gateway *gateway = ao2_alloc(sizeof(*gateway), destroy_gateway);
2860         struct ast_fax_session_details *v21_details;
2861         if (!gateway) {
2862                 return NULL;
2863         }
2864
2865         if (!(v21_details = session_details_new())) {
2866                 ao2_ref(gateway, -1);
2867                 return NULL;
2868         }
2869
2870         v21_details->caps = AST_FAX_TECH_V21_DETECT;
2871         if (!(gateway->chan_v21_session = fax_session_new(v21_details, chan, NULL, NULL))) {
2872                 ao2_ref(v21_details, -1);
2873                 ao2_ref(gateway, -1);
2874                 return NULL;
2875         }
2876
2877         if (!(gateway->peer_v21_session = fax_session_new(v21_details, chan, NULL, NULL))) {
2878                 ao2_ref(v21_details, -1);
2879                 ao2_ref(gateway, -1);
2880                 return NULL;
2881         }
2882         ao2_ref(v21_details, -1);
2883
2884         gateway->framehook = -1;
2885
2886         details->caps = AST_FAX_TECH_GATEWAY;
2887         if (details->gateway_timeout && !(gateway->s = fax_session_reserve(details, &gateway->token))) {
2888                 details->caps &= ~AST_FAX_TECH_GATEWAY;
2889                 ast_log(LOG_ERROR, "Can't reserve a FAX session, gateway attempt failed.\n");
2890                 ao2_ref(gateway, -1);
2891                 return NULL;
2892         }
2893
2894         return gateway;
2895 }
2896
2897 /*! \brief Create a fax session and start T.30<->T.38 gateway mode
2898  * \param gateway a fax gateway object
2899  * \param details fax session details
2900  * \param chan active channel
2901  * \return 0 on error 1 on success*/
2902 static int fax_gateway_start(struct fax_gateway *gateway, struct ast_fax_session_details *details, struct ast_channel *chan)
2903 {
2904         struct ast_fax_session *s;
2905
2906         /* create the FAX session */
2907         if (!(s = fax_session_new(details, chan, gateway->s, gateway->token))) {
2908                 gateway->token = NULL;
2909                 ast_string_field_set(details, result, "FAILED");
2910                 ast_string_field_set(details, resultstr, "error starting gateway session");
2911                 ast_string_field_set(details, error, "INIT_ERROR");
2912                 set_channel_variables(chan, details);
2913                 report_fax_status(chan, details, "No Available Resource");
2914                 ast_log(LOG_ERROR, "Can't create a FAX session, gateway attempt failed.\n");
2915                 return -1;
2916         }
2917         /* release the reference for the reserved session and replace it with
2918          * the real session */
2919         if (gateway->s) {
2920                 ao2_ref(gateway->s, -1);
2921         }
2922         gateway->s = s;
2923         gateway->token = NULL;
2924
2925         if (gateway->s->tech->start_session(gateway->s) < 0) {
2926                 ast_string_field_set(details, result, "FAILED");
2927                 ast_string_field_set(details, resultstr, "error starting gateway session");
2928                 ast_string_field_set(details, error, "INIT_ERROR");
2929                 set_channel_variables(chan, details);
2930                 return -1;
2931         }
2932
2933         gateway->timeout_start.tv_sec = 0;
2934         gateway->timeout_start.tv_usec = 0;
2935
2936         report_fax_status(chan, details, "FAX Transmission In Progress");
2937
2938         return 0;
2939 }
2940
2941 static struct ast_frame *fax_gateway_request_t38(struct fax_gateway *gateway, struct ast_channel *chan, struct ast_frame *f)
2942 {
2943         struct ast_frame *fp;
2944         struct ast_control_t38_parameters t38_parameters = {
2945                 .request_response = AST_T38_REQUEST_NEGOTIATE,
2946         };
2947         struct ast_frame control_frame = {
2948                 .src = "res_fax",
2949                 .frametype = AST_FRAME_CONTROL,
2950                 .datalen = sizeof(t38_parameters),
2951                 .subclass.integer = AST_CONTROL_T38_PARAMETERS,
2952                 .data.ptr = &t38_parameters,
2953         };
2954
2955         struct ast_fax_session_details *details = find_details(chan);
2956
2957         if (!details) {
2958                 ast_log(LOG_ERROR, "no FAX session details found on chan %s for T.38 gateway session, odd\n", ast_channel_name(chan));
2959                 ast_framehook_detach(chan, gateway->framehook);
2960                 return f;
2961         }
2962
2963         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2964         ao2_ref(details, -1);
2965
2966         if (!(fp = ast_frisolate(&control_frame))) {
2967                 ast_log(LOG_ERROR, "error generating T.38 request control frame on chan %s for T.38 gateway session\n", ast_channel_name(chan));
2968                 return f;
2969         }
2970
2971         gateway->t38_state = T38_STATE_NEGOTIATING;
2972         gateway->timeout_start = ast_tvnow();
2973         details->gateway_timeout = FAX_GATEWAY_TIMEOUT;
2974
2975         ast_debug(1, "requesting T.38 for gateway session for %s\n", ast_channel_name(chan));
2976         return fp;
2977 }
2978
2979 static struct ast_frame *fax_gateway_detect_v21(struct fax_gateway *gateway, struct ast_channel *chan, struct ast_channel *peer, struct ast_channel *active, struct ast_frame *f)
2980 {
2981         struct ast_channel *other = (active == chan) ? peer : chan;
2982         struct ast_fax_session *active_v21_session = (active == chan) ? gateway->chan_v21_session : gateway->peer_v21_session;
2983
2984         if (!active_v21_session || gateway->detected_v21) {
2985                 return f;
2986         }
2987
2988         if (active_v21_session->tech->write(active_v21_session, f) == 0 &&
2989             active_v21_session->details->option.v21_detected) {
2990                 gateway->detected_v21 = 1;
2991         }
2992
2993         if (gateway->detected_v21) {
2994                 destroy_v21_sessions(gateway);
2995                 if (ast_channel_get_t38_state(other) == T38_STATE_UNKNOWN) {
2996                         ast_debug(1, "detected v21 preamble from %s\n", ast_channel_name(active));
2997                         return fax_gateway_request_t38(gateway, chan, f);
2998                 } else {
2999                         ast_debug(1, "detected v21 preamble on %s, but %s does not support T.38 for T.38 gateway session\n", ast_channel_name(active), ast_channel_name(other));
3000                 }
3001         }
3002
3003         return f;
3004 }
3005
3006 static int fax_gateway_indicate_t38(struct ast_channel *chan, struct ast_channel *active, struct ast_control_t38_parameters *control_params)
3007 {
3008         if (active == chan) {
3009                 return ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, control_params, sizeof(*control_params));
3010         } else {
3011                 return ast_queue_control_data(chan, AST_CONTROL_T38_PARAMETERS, control_params, sizeof(*control_params));
3012         }
3013 }
3014
3015 /*! \brief T38 Gateway Negotiate t38 parameters
3016  * \param gateway gateway object
3017  * \param chan channel running the gateway
3018  * \param peer channel im bridged too
3019  * \param active channel the frame originated on
3020  * \param f the control frame to process
3021  * \return processed control frame or null frame
3022  */
3023 static struct ast_frame *fax_gateway_detect_t38(struct fax_gateway *gateway, struct ast_channel *chan, struct ast_channel *peer, struct ast_channel *active, struct ast_frame *f)
3024 {
3025         struct ast_control_t38_parameters *control_params = f->data.ptr;
3026         struct ast_channel *other = (active == chan) ? peer : chan;
3027         struct ast_fax_session_details *details;
3028
3029         if (f->datalen != sizeof(struct ast_control_t38_parameters)) {
3030                 /* invalaid AST_CONTROL_T38_PARAMETERS frame, we can't
3031                  * do anything with it, pass it on */
3032                 return f;
3033         }
3034
3035         /* ignore frames from ourselves */
3036         if ((gateway->t38_state == T38_STATE_NEGOTIATED && control_params->request_response == AST_T38_NEGOTIATED)
3037                 || (gateway->t38_state == T38_STATE_REJECTED && control_params->request_response == AST_T38_REFUSED)
3038                 || (gateway->t38_state == T38_STATE_NEGOTIATING && control_params->request_response == AST_T38_REQUEST_TERMINATE)) {
3039
3040                 return f;
3041         }
3042
3043         if (!(details = find_details(chan))) {
3044                 ast_log(LOG_ERROR, "no FAX session details found on chan %s for T.38 gateway session, odd\n", ast_channel_name(chan));
3045                 ast_framehook_detach(chan, gateway->framehook);
3046                 return f;
3047         }
3048
3049         if (control_params->request_response == AST_T38_REQUEST_NEGOTIATE) {
3050                 enum ast_t38_state state = ast_channel_get_t38_state(other);
3051
3052                 if (state == T38_STATE_UNKNOWN) {
3053                         /* we detected a request to negotiate T.38 and the
3054                          * other channel appears to support T.38, we'll pass
3055                          * the request through and only step in if the other
3056                          * channel rejects the request */
3057                         ast_debug(1, "%s is attempting to negotiate T.38 with %s, we'll see what happens\n", ast_channel_name(active), ast_channel_name(other));
3058                         t38_parameters_ast_to_fax(&details->their_t38_parameters, control_params);
3059                         gateway->t38_state = T38_STATE_UNKNOWN;
3060                         gateway->timeout_start = ast_tvnow();
3061                         details->gateway_timeout = FAX_GATEWAY_TIMEOUT;
3062                         ao2_ref(details, -1);
3063                         return f;
3064                 } else if (state == T38_STATE_UNAVAILABLE || state == T38_STATE_REJECTED) {
3065                         /* the other channel does not support T.38, we need to
3066                          * step in here */
3067                         ast_debug(1, "%s is attempting to negotiate T.38 but %s does not support it\n", ast_channel_name(active), ast_channel_name(other));
3068                         ast_debug(1, "starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(active), ast_channel_name(other));
3069
3070                         t38_parameters_ast_to_fax(&details->their_t38_parameters, control_params);
3071                         t38_parameters_fax_to_ast(control_params, &details->our_t38_parameters);
3072
3073                         if (fax_gateway_start(gateway, details, chan)) {
3074                                 ast_log(LOG_ERROR, "error starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(active), ast_channel_name(other));
3075                                 gateway->t38_state = T38_STATE_REJECTED;
3076                                 control_params->request_response = AST_T38_REFUSED;
3077
3078                                 ast_framehook_detach(chan, details->gateway_id);
3079                                 details->gateway_id = -1;
3080                         } else {
3081                                 gateway->t38_state = T38_STATE_NEGOTIATED;
3082                                 control_params->request_response = AST_T38_NEGOTIATED;
3083                                 report_fax_status(chan, details, "T.38 Negotiated");
3084                         }
3085
3086                         fax_gateway_indicate_t38(chan, active, control_params);
3087
3088                         ao2_ref(details, -1);
3089                         return &ast_null_frame;
3090                 } else if (gateway->t38_state == T38_STATE_NEGOTIATING) {
3091                         /* we got a request to negotiate T.38 after we already
3092                          * sent one to the other party based on v21 preamble
3093                          * detection. We'll just pretend we passed this request
3094                          * through in the first place. */
3095
3096                         t38_parameters_ast_to_fax(&details->their_t38_parameters, control_params);
3097                         gateway->t38_state = T38_STATE_UNKNOWN;
3098                         gateway->timeout_start = ast_tvnow();
3099                         details->gateway_timeout = FAX_GATEWAY_TIMEOUT;
3100
3101                         ast_debug(1, "%s is attempting to negotiate T.38 after we already sent a negotiation request based on v21 preamble detection\n", ast_channel_name(active));
3102                         ao2_ref(details, -1);
3103                         return &ast_null_frame;
3104                 } else if (gateway->t38_state == T38_STATE_NEGOTIATED) {
3105                         /* we got a request to negotiate T.38 after we already
3106                          * sent one to the other party based on v21 preamble
3107                          * detection and received a response. We need to
3108                          * respond to this and shut down the gateway. */
3109
3110                         t38_parameters_fax_to_ast(control_params, &details->their_t38_parameters);
3111                         ast_framehook_detach(chan, details->gateway_id);
3112                         details->gateway_id = -1;
3113
3114                         control_params->request_response = AST_T38_NEGOTIATED;
3115
3116                         fax_gateway_indicate_t38(chan, active, control_params);
3117
3118                         ast_string_field_set(details, result, "SUCCESS");
3119                         ast_string_field_set(details, resultstr, "no gateway necessary");
3120                         ast_string_field_set(details, error, "NATIVE_T38");
3121                         set_channel_variables(chan, details);
3122
3123                         ast_debug(1, "%s is attempting to negotiate T.38 after we already negotiated T.38 with %s, disabling the gateway\n", ast_channel_name(active), ast_channel_name(other));
3124                         ao2_ref(details, -1);
3125                         return &ast_null_frame;
3126                 } else {
3127                         ast_log(LOG_WARNING, "%s is attempting to negotiate T.38 while %s is in an unsupported state\n", ast_channel_name(active), ast_channel_name(other));
3128                         ao2_ref(details, -1);
3129                         return f;
3130                 }
3131         } else if (gateway->t38_state == T38_STATE_NEGOTIATING
3132                 && control_params->request_response == AST_T38_REFUSED) {
3133
3134                 ast_debug(1, "unable to negotiate T.38 on %s for fax gateway\n", ast_channel_name(active));
3135
3136                 /* our request to negotiate T.38 was refused, if the other
3137                  * channel supports T.38, they might still reinvite and save
3138                  * the day.  Otherwise disable the gateway. */
3139                 if (ast_channel_get_t38_state(other) == T38_STATE_UNKNOWN) {
3140                         gateway->t38_state = T38_STATE_UNAVAILABLE;
3141                 } else {
3142                         ast_framehook_detach(chan, details->gateway_id);
3143                         details->gateway_id = -1;
3144
3145                         ast_string_field_set(details, result, "FAILED");
3146                         ast_string_field_set(details, resultstr, "unable to negotiate T.38");
3147                         ast_string_field_set(details, error, "T38_NEG_ERROR");
3148                         set_channel_variables(chan, details);
3149                 }
3150
3151                 ao2_ref(details, -1);
3152                 return &ast_null_frame;
3153         } else if (gateway->t38_state == T38_STATE_NEGOTIATING
3154                 && control_params->request_response == AST_T38_NEGOTIATED) {
3155
3156                 ast_debug(1, "starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(active), ast_channel_name(other));
3157
3158                 t38_parameters_ast_to_fax(&details->their_t38_parameters, control_params);
3159
3160                 if (fax_gateway_start(gateway, details, chan)) {
3161                         ast_log(LOG_ERROR, "error starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(active), ast_channel_name(other));
3162                         gateway->t38_state = T38_STATE_NEGOTIATING;
3163                         control_params->request_response = AST_T38_REQUEST_TERMINATE;
3164
3165                         fax_gateway_indicate_t38(chan, active, control_params);
3166                 } else {
3167                         gateway->t38_state = T38_STATE_NEGOTIATED;
3168                         report_fax_status(chan, details, "T.38 Negotiated");
3169                 }
3170
3171                 ao2_ref(details, -1);
3172                 return &ast_null_frame;
3173         } else if (control_params->request_response == AST_T38_REFUSED) {
3174                 /* the other channel refused the request to negotiate T.38,
3175                  * we'll step in here and pretend the request was accepted */
3176
3177                 ast_debug(1, "%s attempted to negotiate T.38 but %s refused the request\n", ast_channel_name(other), ast_channel_name(active));
3178                 ast_debug(1, "starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(other), ast_channel_name(active));
3179
3180                 t38_parameters_fax_to_ast(control_params, &details->our_t38_parameters);
3181
3182                 if (fax_gateway_start(gateway, details, chan)) {
3183                         ast_log(LOG_ERROR, "error starting T.38 gateway for T.38 channel %s and G.711 channel %s\n", ast_channel_name(active), ast_channel_name(other));
3184                         gateway->t38_state = T38_STATE_REJECTED;
3185                         control_params->request_response = AST_T38_REFUSED;
3186
3187                         ast_framehook_detach(chan, details->gateway_id);
3188                         details->gateway_id = -1;
3189                 } else {
3190                         gateway->t38_state = T38_STATE_NEGOTIATED;
3191                         control_params->request_response = AST_T38_NEGOTIATED;
3192                 }
3193
3194                 ao2_ref(details, -1);
3195                 return f;
3196         } else if (control_params->request_response == AST_T38_REQUEST_TERMINATE) {
3197                 /* the channel wishes to end our short relationship, we shall
3198                  * oblige */
3199
3200                 ast_debug(1, "T.38 channel %s is requesting a shutdown of T.38, disabling the gateway\n", ast_channel_name(active));
3201
3202                 ast_framehook_detach(chan, details->gateway_id);
3203                 details->gateway_id = -1;
3204
3205                 gateway->t38_state = T38_STATE_REJECTED;
3206                 control_params->request_response = AST_T38_TERMINATED;
3207
3208                 fax_gateway_indicate_t38(chan, active, control_params);
3209
3210                 ao2_ref(details, -1);
3211                 return &ast_null_frame;
3212         } else if (control_params->request_response == AST_T38_NEGOTIATED) {
3213                 ast_debug(1, "T.38 successfully negotiated between %s and %s, no gateway necessary\n", ast_channel_name(active), ast_channel_name(other));
3214
3215                 ast_framehook_detach(chan, details->gateway_id);
3216                 details->gateway_id = -1;
3217
3218                 ast_string_field_set(details, result, "SUCCESS");
3219                 ast_string_field_set(details, resultstr, "no gateway necessary");
3220                 ast_string_field_set(details, error, "NATIVE_T38");
3221                 set_channel_variables(chan, details);
3222
3223                 ao2_ref(details, -1);
3224                 return f;
3225         } else if (control_params->request_response == AST_T38_TERMINATED) {
3226                 ast_debug(1, "T.38 disabled on channel %s\n", ast_channel_name(active));
3227
3228                 ast_framehook_detach(chan, details->gateway_id);
3229                 details->gateway_id = -1;
3230
3231                 ao2_ref(details, -1);
3232                 return &ast_null_frame;
3233         }
3234
3235         ao2_ref(details, -1);
3236         return f;
3237 }
3238
3239 /*! \brief Destroy the gateway data structure when the framehook is detached
3240  * \param data framehook data (gateway data)*/
3241 static void fax_gateway_framehook_destroy(void *data)
3242 {
3243         struct fax_gateway *gateway = data;
3244
3245         if (gateway->s) {
3246                 switch (gateway->s->state) {
3247                 case AST_FAX_STATE_INITIALIZED:
3248                 case AST_FAX_STATE_OPEN:
3249                 case AST_FAX_STATE_ACTIVE:
3250                 case AST_FAX_STATE_COMPLETE:
3251                         if (gateway->s->tech->cancel_session) {
3252                                 gateway->s->tech->cancel_session(gateway->s);
3253                         }
3254                         /* fall through */
3255                 default:
3256                         break;
3257                 }
3258         }
3259
3260         ao2_ref(gateway, -1);
3261 }
3262
3263 /*! \brief T.30<->T.38 gateway framehook.
3264  *
3265  * Intercept packets on bridged channels and determine if a T.38 gateway is
3266  * required. If a gateway is required, start a gateway and handle T.38
3267  * negotiation if necessary.
3268  *
3269  * \param chan channel running the gateway
3270  * \param f frame to handle may be NULL
3271  * \param event framehook event
3272  * \param data framehook data (struct fax_gateway *)
3273  *
3274  * \return processed frame or NULL when f is NULL or a null frame
3275  */
3276 static struct ast_frame *fax_gateway_framehook(struct ast_channel *chan, struct ast_frame *f, enum ast_framehook_event event, void *data)
3277 {
3278         struct fax_gateway *gateway = data;
3279         struct ast_channel *active;
3280         RAII_VAR(struct ast_fax_session_details *, details, NULL, ao2_cleanup);
3281         RAII_VAR(struct ast_channel *, peer, NULL, ao2_cleanup);
3282         RAII_VAR(struct ast_channel *, chan_ref, chan, ao2_cleanup);
3283
3284         /* Ref bump channel for when we have to unlock it */
3285         ao2_ref(chan_ref, 1);
3286
3287         if (gateway->s) {
3288                 details = gateway->s->details;
3289                 ao2_ref(details, 1);
3290         } else {
3291                 if (!(details = find_details(chan))) {
3292                         ast_log(LOG_ERROR, "no FAX session details found on chan %s for T.38 gateway session, odd\n", ast_channel_name(chan));
3293                         ast_framehook_detach(chan, gateway->framehook);
3294                         return f;
3295                 }
3296         }
3297
3298         /* restore audio formats when we are detached */
3299         if (event == AST_FRAMEHOOK_EVENT_DETACHED) {
3300                 set_channel_variables(chan, details);
3301
3302                 if (gateway->bridged) {
3303                         ast_set_read_format(chan, gateway->chan_read_format);
3304                         ast_set_read_format(chan, gateway->chan_write_format);
3305
3306                         ast_channel_unlock(chan);
3307                         peer = ast_channel_bridge_peer(chan);
3308                         if (peer) {
3309                                 ast_set_read_format(peer, gateway->peer_read_format);
3310                                 ast_set_read_format(peer, gateway->peer_write_format);
3311                                 ast_channel_make_compatible(chan, peer);
3312                         }
3313                         ast_channel_lock(chan);
3314                 }
3315                 return NULL;
3316         }
3317
3318         if (!f || (event == AST_FRAMEHOOK_EVENT_ATTACHED)) {
3319                 return NULL;
3320         };
3321
3322         /* this frame was generated by the fax gateway, pass it on */
3323         if (ast_test_flag(f, AST_FAX_FRFLAG_GATEWAY)) {
3324                 return f;
3325         }
3326
3327         /* If we aren't bridged or we don't have a peer, don't do anything */
3328         ast_channel_unlock(chan);
3329         peer = ast_channel_bridge_peer(chan);
3330         ast_channel_lock(chan);
3331         if (!peer) {
3332                 return f;
3333         }
3334
3335         if (!gateway->bridged) {
3336                 /* don't start a gateway if neither channel can handle T.38 */
3337                 if (ast_channel_get_t38_state(chan) == T38_STATE_UNAVAILABLE && ast_channel_get_t38_state(peer) == T38_STATE_UNAVAILABLE) {
3338                         ast_debug(1, "not starting gateway for %s and %s; neither channel supports T.38\n", ast_channel_name(chan), ast_channel_name(peer));
3339                         ast_framehook_detach(chan, gateway->framehook);
3340                         details->gateway_id = -1;
3341
3342                         ast_string_field_set(details, result, "FAILED");
3343                         ast_string_field_set(details, resultstr, "neither channel supports T.38");
3344                         ast_string_field_set(details, error, "T38_NEG_ERROR");
3345                         set_channel_variables(chan, details);
3346                         return f;
3347                 }
3348
3349                 if (details->gateway_timeout) {
3350                         gateway->timeout_start = ast_tvnow();
3351                 }
3352
3353                 /* we are bridged, change r/w formats to SLIN for v21 preamble
3354                  * detection and T.30 */
3355                 ao2_replace(gateway->chan_read_format, ast_channel_readformat(chan));
3356                 ao2_replace(gateway->chan_write_format, ast_channel_readformat(chan));
3357
3358                 ao2_replace(gateway->peer_read_format, ast_channel_readformat(peer));
3359                 ao2_replace(gateway->peer_write_format, ast_channel_readformat(peer));
3360
3361                 ast_set_read_format(chan, ast_format_slin);
3362                 ast_set_write_format(chan, ast_format_slin);
3363
3364                 ast_channel_unlock(chan);
3365                 ast_set_read_format(peer, ast_format_slin);
3366                 ast_set_write_format(peer, ast_format_slin);
3367
3368                 ast_channel_make_compatible(chan, peer);
3369                 ast_channel_lock(chan);
3370                 gateway->bridged = 1;
3371         }
3372
3373         if (gateway->bridged && !ast_tvzero(gateway->timeout_start)) {
3374                 if (ast_tvdiff_ms(ast_tvnow(), gateway->timeout_start) > details->gateway_timeout) {
3375                         ast_debug(1, "no fax activity between %s and %s after %d ms, disabling gateway\n", ast_channel_name(chan), ast_channel_name(peer), details->gateway_timeout);
3376                         ast_framehook_detach(chan, gateway->framehook);
3377                         details->gateway_id = -1;
3378
3379                         ast_string_field_set(details, result, "FAILED");
3380                         ast_string_field_build(details, resultstr, "no fax activity after %d ms", details->gateway_timeout);
3381                         ast_string_field_set(details, error, "TIMEOUT");
3382                         set_channel_variables(chan, details);
3383                         return f;
3384                 }
3385         }
3386
3387         /* only handle VOICE, MODEM, and CONTROL frames*/
3388         switch (f->frametype) {
3389         case AST_FRAME_VOICE:
3390                 if ((ast_format_cmp(f->subclass.format, ast_format_slin) != AST_FORMAT_CMP_EQUAL) &&
3391                         (ast_format_cmp(f->subclass.format, ast_format_alaw) != AST_FORMAT_CMP_EQUAL) &&
3392                         (ast_format_cmp(f->subclass.format, ast_format_ulaw) != AST_FORMAT_CMP_EQUAL)) {
3393                         return f;
3394                 }
3395                 break;
3396         case AST_FRAME_MODEM:
3397                 if (f->subclass.integer == AST_MODEM_T38) {
3398                         break;
3399                 }
3400                 return f;
3401         case AST_FRAME_CONTROL:
3402                 if (f->subclass.integer == AST_CONTROL_T38_PARAMETERS) {
3403                         break;
3404                 }
3405                 return f;
3406         default:
3407                 return f;
3408         }
3409
3410         /* detect the active channel */
3411         switch (event) {
3412         case AST_FRAMEHOOK_EVENT_WRITE:
3413                 active = peer;
3414                 break;
3415         case AST_FRAMEHOOK_EVENT_READ:
3416                 active = chan;
3417                 break;
3418         default:
3419                 ast_log(LOG_WARNING, "unhandled framehook event %u\n", event);
3420                 return f;
3421         }
3422
3423         /* handle control frames */
3424         if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_T38_PARAMETERS) {
3425                 return fax_gateway_detect_t38(gateway, chan, peer, active, f);
3426         }
3427
3428         if (!gateway->detected_v21 && gateway->t38_state == T38_STATE_UNAVAILABLE && f->frametype == AST_FRAME_VOICE) {
3429                 /* not in gateway mode and have not detected v21 yet, listen
3430