res_fax: Add T.38 negotiation timeout option
[asterisk/asterisk.git] / 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 static char *ast_fax_caps_to_str(enum ast_fax_capabilities caps, char *buf, size_t bufsize)
843 {
844         char *out = buf;
845         size_t size = bufsize;
846         int first = 1;
847
848         if (caps & AST_FAX_TECH_SEND) {
849                 if (!first) {
850                         ast_build_string(&buf, &size, ",");
851                 }
852                 ast_build_string(&buf, &size, "SEND");
853                 first = 0;
854         }
855         if (caps & AST_FAX_TECH_RECEIVE) {
856                 if (!first) {
857                         ast_build_string(&buf, &size, ",");
858                 }
859                 ast_build_string(&buf, &size, "RECEIVE");
860                 first = 0;
861         }
862         if (caps & AST_FAX_TECH_AUDIO) {
863                 if (!first) {
864                         ast_build_string(&buf, &size, ",");
865                 }
866                 ast_build_string(&buf, &size, "AUDIO");
867                 first = 0;
868         }
869         if (caps & AST_FAX_TECH_T38) {
870                 if (!first) {
871                         ast_build_string(&buf, &size, ",");
872                 }
873                 ast_build_string(&buf, &size, "T38");
874                 first = 0;
875         }
876         if (caps & AST_FAX_TECH_MULTI_DOC) {
877                 if (!first) {
878                         ast_build_string(&buf, &size, ",");
879                 }
880                 ast_build_string(&buf, &size, "MULTI_DOC");
881                 first = 0;
882         }
883         if (caps & AST_FAX_TECH_GATEWAY) {
884                 if (!first) {
885                         ast_build_string(&buf, &size, ",");
886                 }
887                 ast_build_string(&buf, &size, "GATEWAY");
888                 first = 0;
889         }
890         if (caps & AST_FAX_TECH_V21_DETECT) {
891                 if (!first) {
892                         ast_build_string(&buf, &size, ",");
893                 }
894                 ast_build_string(&buf, &size, "V21");
895                 first = 0;
896         }
897
898         return out;
899 }
900
901 static int ast_fax_modem_to_str(enum ast_fax_modems bits, char *tbuf, size_t bufsize)
902 {
903         int count = 0;
904
905         if (bits & AST_FAX_MODEM_V17) {
906                 strcat(tbuf, "V17");
907                 count++;
908         }
909         if (bits & AST_FAX_MODEM_V27) {
910                 if (count) {
911                         strcat(tbuf, ",");
912                 }
913                 strcat(tbuf, "V27");
914                 count++;
915         }
916         if (bits & AST_FAX_MODEM_V29) {
917                 if (count) {
918                         strcat(tbuf, ",");
919                 }
920                 strcat(tbuf, "V29");
921                 count++;
922         }
923         if (bits & AST_FAX_MODEM_V34) {
924                 if (count) {
925                         strcat(tbuf, ",");
926                 }
927                 strcat(tbuf, "V34");
928                 count++;
929         }
930
931         return 0;
932 }
933
934 static int check_modem_rate(enum ast_fax_modems modems, unsigned int rate)
935 {
936         switch (rate) {
937         case 2400:
938                 if (!(modems & (AST_FAX_MODEM_V34))) {
939                         return 1;
940                 }
941                 break;
942         case 4800:
943                 if (!(modems & (AST_FAX_MODEM_V27 | AST_FAX_MODEM_V34))) {
944                         return 1;
945                 }
946                 break;
947         case 7200:
948                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V29 | AST_FAX_MODEM_V34))) {
949                         return 1;
950                 }
951                 break;
952         case 9600:
953                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V27 | AST_FAX_MODEM_V29 | AST_FAX_MODEM_V34))) {
954                         return 1;
955                 }
956                 break;
957         case 12000:
958         case 14400:
959                 if (!(modems & (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V34))) {
960                         return 1;
961                 }
962                 break;
963         case 28800:
964         case 33600:
965                 if (!(modems & AST_FAX_MODEM_V34)) {
966                         return 1;
967                 }
968                 break;
969         default:
970                 /* this should never happen */
971                 return 1;
972         }
973
974         return 0;
975 }
976
977 /*! \brief register a FAX technology module */
978 int ast_fax_tech_register(struct ast_fax_tech *tech)
979 {
980         struct fax_module *fax;
981
982         if (!(fax = ast_calloc(1, sizeof(*fax)))) {
983                 return -1;
984         }
985         fax->tech = tech;
986         AST_RWLIST_WRLOCK(&faxmodules);
987         AST_RWLIST_INSERT_TAIL(&faxmodules, fax, list);
988         AST_RWLIST_UNLOCK(&faxmodules);
989         ast_module_ref(ast_module_info->self);
990
991         ast_verb(3, "Registered handler for '%s' (%s)\n", fax->tech->type, fax->tech->description);
992
993         return 0;
994 }
995
996 /*! \brief unregister a FAX technology module */
997 void ast_fax_tech_unregister(struct ast_fax_tech *tech)
998 {
999         struct fax_module *fax;
1000
1001         ast_verb(3, "Unregistering FAX module type '%s'\n", tech->type);
1002
1003         AST_RWLIST_WRLOCK(&faxmodules);
1004         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&faxmodules, fax, list) {
1005                 if (fax->tech != tech) {
1006                         continue;
1007                 }
1008                 AST_RWLIST_REMOVE_CURRENT(list);
1009                 ast_module_unref(ast_module_info->self);
1010                 ast_free(fax);
1011                 ast_verb(4, "Unregistered FAX module type '%s'\n", tech->type);
1012                 break;
1013         }
1014         AST_RWLIST_TRAVERSE_SAFE_END;
1015         AST_RWLIST_UNLOCK(&faxmodules);
1016 }
1017
1018 /*! \brief convert a ast_fax_state to a string */
1019 const char *ast_fax_state_to_str(enum ast_fax_state state)
1020 {
1021         switch (state) {
1022         case AST_FAX_STATE_UNINITIALIZED:
1023                 return "Uninitialized";
1024         case AST_FAX_STATE_INITIALIZED:
1025                 return "Initialized";
1026         case AST_FAX_STATE_OPEN:
1027                 return "Open";
1028         case AST_FAX_STATE_ACTIVE:
1029                 return "Active";
1030         case AST_FAX_STATE_COMPLETE:
1031                 return "Complete";
1032         case AST_FAX_STATE_RESERVED:
1033                 return "Reserved";
1034         case AST_FAX_STATE_INACTIVE:
1035                 return "Inactive";
1036         default:
1037                 ast_log(LOG_WARNING, "unhandled FAX state: %u\n", state);
1038                 return "Unknown";
1039         }
1040 }
1041
1042 void ast_fax_log(int level, const char *file, const int line, const char *function, const char *msg)
1043 {
1044         if (fax_logger_level != -1) {
1045                 ast_log_dynamic_level(fax_logger_level, "%s", msg);
1046         } else {
1047                 ast_log(level, file, line, function, "%s", msg);
1048         }
1049 }
1050
1051 /*! \brief convert a rate string to a rate */
1052 static unsigned int fax_rate_str_to_int(const char *ratestr)
1053 {
1054         int rate;
1055
1056         if (sscanf(ratestr, "%d", &rate) != 1) {
1057                 ast_log(LOG_ERROR, "failed to sscanf '%s' to rate\n", ratestr);
1058                 return 0;
1059         }
1060         switch (rate) {
1061         case 2400:
1062         case 4800:
1063         case 7200:
1064         case 9600:
1065         case 12000:
1066         case 14400:
1067         case 28800:
1068         case 33600:
1069                 return rate;
1070         default:
1071                 ast_log(LOG_WARNING, "ignoring invalid rate '%s'.  Valid options are {2400 | 4800 | 7200 | 9600 | 12000 | 14400 | 28800 | 33600}\n", ratestr);
1072                 return 0;
1073         }
1074 }
1075
1076 /*! \brief Release a session token.
1077  * \param s a session returned from fax_session_reserve()
1078  * \param token a token generated from fax_session_reserve()
1079  *
1080  * This function releases the given token and marks the given session as no
1081  * longer reserved. It is safe to call on a session that is not actually
1082  * reserved and with a NULL token. This is so that sessions returned by
1083  * technologies that do not support reserved sessions don't require extra logic
1084  * to handle.
1085  *
1086  * \note This function DOES NOT release the given fax session, only the given
1087  * token.
1088  */
1089 static void fax_session_release(struct ast_fax_session *s, struct ast_fax_tech_token *token)
1090 {
1091         if (token) {
1092                 s->tech->release_token(token);
1093         }
1094
1095         if (s->state == AST_FAX_STATE_RESERVED) {
1096                 ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, -1);
1097                 s->state = AST_FAX_STATE_INACTIVE;
1098         }
1099 }
1100
1101 /*! \brief destroy a FAX session structure */
1102 static void destroy_session(void *session)
1103 {
1104         struct ast_fax_session *s = session;
1105
1106         if (s->tech) {
1107                 fax_session_release(s, NULL);
1108                 if (s->tech_pvt) {
1109                         s->tech->destroy_session(s);
1110                 }
1111                 ast_module_unref(s->tech->module);
1112         }
1113
1114         if (s->details) {
1115                 if (s->details->caps & AST_FAX_TECH_GATEWAY) {
1116                         s->details->caps &= ~AST_FAX_TECH_GATEWAY;
1117                 }
1118                 ao2_ref(s->details, -1);
1119         }
1120
1121         if (s->debug_info) {
1122                 ast_dsp_free(s->debug_info->dsp);
1123                 ast_free(s->debug_info);
1124         }
1125
1126         if (s->smoother) {
1127                 ast_smoother_free(s->smoother);
1128         }
1129
1130         if (s->state != AST_FAX_STATE_INACTIVE) {
1131                 ast_atomic_fetchadd_int(&faxregistry.active_sessions, -1);
1132         }
1133
1134         ast_free(s->channame);
1135         ast_free(s->chan_uniqueid);
1136 }
1137
1138 /*! \brief Reserve a fax session.
1139  * \param details the fax session details
1140  * \param token a pointer to a place to store a token to be passed to fax_session_new() later
1141  *
1142  * This function reserves a fax session for use later. If the selected fax
1143  * technology does not support reserving sessions a session will still be
1144  * returned but token will not be set.
1145  *
1146  * \note The reference returned by this function does not get consumed by
1147  * fax_session_new() and must always be dereferenced separately.
1148  *
1149  * \return NULL or an uninitialized and possibly reserved session
1150  */
1151 static struct ast_fax_session *fax_session_reserve(struct ast_fax_session_details *details, struct ast_fax_tech_token **token)
1152 {
1153         struct ast_fax_session *s;
1154         struct fax_module *faxmod;
1155
1156         if (!(s = ao2_alloc(sizeof(*s), destroy_session))) {
1157                 return NULL;
1158         }
1159
1160         s->state = AST_FAX_STATE_INACTIVE;
1161         s->details = details;
1162         ao2_ref(s->details, 1);
1163
1164         /* locate a FAX technology module that can handle said requirements
1165          * Note: the requirements have not yet been finalized as T.38
1166          * negotiation has not yet occured. */
1167         AST_RWLIST_RDLOCK(&faxmodules);
1168         AST_RWLIST_TRAVERSE(&faxmodules, faxmod, list) {
1169                 if ((faxmod->tech->caps & details->caps) != details->caps) {
1170                         continue;
1171                 }
1172                 ast_debug(4, "Reserving a FAX session from '%s'.\n", faxmod->tech->description);
1173                 ast_module_ref(faxmod->tech->module);
1174                 s->tech = faxmod->tech;
1175                 break;
1176         }
1177         AST_RWLIST_UNLOCK(&faxmodules);
1178
1179         if (!faxmod) {
1180                 char caps[128] = "";
1181                 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)));
1182                 ao2_ref(s, -1);
1183                 return NULL;
1184         }
1185
1186         if (!s->tech->reserve_session) {
1187                 ast_debug(1, "Selected FAX technology module (%s) does not support reserving sessions.\n", s->tech->description);
1188                 return s;
1189         }
1190
1191         if (!(*token = s->tech->reserve_session(s))) {
1192                 ao2_ref(s, -1);
1193                 return NULL;
1194         }
1195
1196         s->state = AST_FAX_STATE_RESERVED;
1197         ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, 1);
1198
1199         return s;
1200 }
1201
1202 /*! \brief create a FAX session
1203  *
1204  * \param details details for the session
1205  * \param chan the channel the session will run on
1206  * \param reserved a reserved session to base this session on (can be NULL)
1207  * \param token the token for a reserved session (can be NULL)
1208  *
1209  * Create a new fax session based on the given details structure.
1210  *
1211  * \note The given token is always consumed (by tech->new_session() or by
1212  * fax_session_release() in the event of a failure). The given reference to a
1213  * reserved session is never consumed and must be dereferenced separately from
1214  * the reference returned by this function.
1215  *
1216  * \return NULL or a reference to a new fax session
1217  */
1218 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)
1219 {
1220         struct ast_fax_session *s = NULL;
1221         struct fax_module *faxmod;
1222
1223         if (reserved) {
1224                 s = reserved;
1225                 ao2_ref(reserved, +1);
1226                 ao2_unlink(faxregistry.container, reserved);
1227
1228                 /* NOTE: we don't consume the reference to the reserved
1229                  * session. The session returned from fax_session_new() is a
1230                  * new reference and must be derefed in addition to the
1231                  * reserved session.
1232                  */
1233
1234                 if (s->state == AST_FAX_STATE_RESERVED) {
1235                         ast_atomic_fetchadd_int(&faxregistry.reserved_sessions, -1);
1236                         s->state = AST_FAX_STATE_UNINITIALIZED;
1237                 }
1238         }
1239
1240         if (!s && !(s = ao2_alloc(sizeof(*s), destroy_session))) {
1241                 return NULL;
1242         }
1243
1244         ast_atomic_fetchadd_int(&faxregistry.active_sessions, 1);
1245         s->state = AST_FAX_STATE_UNINITIALIZED;
1246
1247         if (details->option.debug && (details->caps & AST_FAX_TECH_AUDIO)) {
1248                 if (!(s->debug_info = ast_calloc(1, sizeof(*(s->debug_info))))) {
1249                         fax_session_release(s, token);
1250                         ao2_ref(s, -1);
1251                         return NULL;
1252                 }
1253                 if (!(s->debug_info->dsp = ast_dsp_new())) {
1254                         ast_free(s->debug_info);
1255                         s->debug_info = NULL;
1256                         fax_session_release(s, token);
1257                         ao2_ref(s, -1);
1258                         return NULL;
1259                 }
1260                 ast_dsp_set_threshold(s->debug_info->dsp, 128);
1261         }
1262
1263         if (!(s->channame = ast_strdup(ast_channel_name(chan)))) {
1264                 fax_session_release(s, token);
1265                 ao2_ref(s, -1);
1266                 return NULL;
1267         }
1268
1269         if (!(s->chan_uniqueid = ast_strdup(ast_channel_uniqueid(chan)))) {
1270                 fax_session_release(s, token);
1271                 ao2_ref(s, -1);
1272                 return NULL;
1273         }
1274
1275         s->chan = chan;
1276         if (!s->details) {
1277                 s->details = details;
1278                 ao2_ref(s->details, 1);
1279         }
1280
1281         details->id = s->id = ast_atomic_fetchadd_int(&faxregistry.nextsessionname, 1);
1282
1283         if (!token) {
1284                 /* locate a FAX technology module that can handle said requirements */
1285                 AST_RWLIST_RDLOCK(&faxmodules);
1286                 AST_RWLIST_TRAVERSE(&faxmodules, faxmod, list) {
1287                         if ((faxmod->tech->caps & details->caps) != details->caps) {
1288                                 continue;
1289                         }
1290                         ast_debug(4, "Requesting a new FAX session from '%s'.\n", faxmod->tech->description);
1291                         ast_module_ref(faxmod->tech->module);
1292                         if (reserved) {
1293                                 /* Balance module ref from reserved session */
1294                                 ast_module_unref(reserved->tech->module);
1295                         }
1296                         s->tech = faxmod->tech;
1297                         break;
1298                 }
1299                 AST_RWLIST_UNLOCK(&faxmodules);
1300
1301                 if (!faxmod) {
1302                         char caps[128] = "";
1303                         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)));
1304                         ao2_ref(s, -1);
1305                         return NULL;
1306                 }
1307         }
1308
1309         if (!(s->tech_pvt = s->tech->new_session(s, token))) {
1310                 ast_log(LOG_ERROR, "FAX session failed to initialize.\n");
1311                 ao2_ref(s, -1);
1312                 return NULL;
1313         }
1314         /* link the session to the session container */
1315         if (!(ao2_link(faxregistry.container, s))) {
1316                 ast_log(LOG_ERROR, "failed to add FAX session '%u' to container.\n", s->id);
1317                 ao2_ref(s, -1);
1318                 return NULL;
1319         }
1320         ast_debug(4, "channel '%s' using FAX session '%u'\n", s->channame, s->id);
1321
1322         return s;
1323 }
1324
1325 /*!
1326  * \internal
1327  * \brief Convert the filenames in a fax session into a JSON array
1328  * \retval NULL on error
1329  * \retval A \ref ast_json array on success
1330  */
1331 static struct ast_json *generate_filenames_json(struct ast_fax_session_details *details)
1332 {
1333         RAII_VAR(struct ast_json *, json_array, ast_json_array_create(), ast_json_unref);
1334         struct ast_fax_document *doc;
1335
1336         if (!details || !json_array) {
1337                 return NULL;
1338         }
1339
1340         /* don't process empty lists */
1341         if (AST_LIST_EMPTY(&details->documents)) {
1342                 return NULL;
1343         }
1344
1345         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1346                 struct ast_json *entry = ast_json_string_create(doc->filename);
1347                 if (!entry) {
1348                         return NULL;
1349                 }
1350                 if (ast_json_array_append(json_array, entry)) {
1351                         return NULL;
1352                 }
1353         }
1354
1355         ast_json_ref(json_array);
1356         return json_array;
1357 }
1358
1359 /* \brief Generate a string of filenames using the given prefix and separator.
1360  * \param details the fax session details
1361  * \param prefix the prefix to each filename
1362  * \param separator the separator between filenames
1363  *
1364  * This function generates a string of filenames from the given details
1365  * structure and using the given prefix and separator.
1366  *
1367  * \retval NULL there was an error generating the string
1368  * \return the string generated string
1369  */
1370 static char *generate_filenames_string(struct ast_fax_session_details *details, char *prefix, char *separator)
1371 {
1372         char *filenames, *c;
1373         size_t size = 0;
1374         int first = 1;
1375         struct ast_fax_document *doc;
1376
1377         /* don't process empty lists */
1378         if (AST_LIST_EMPTY(&details->documents)) {
1379                 return ast_strdup("");
1380         }
1381
1382         /* Calculate the total length of all of the file names */
1383         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1384                 size += strlen(separator) + strlen(prefix) + strlen(doc->filename);
1385         }
1386         size += 1; /* add space for the terminating null */
1387
1388         if (!(filenames = ast_malloc(size))) {
1389                 return NULL;
1390         }
1391         c = filenames;
1392
1393         ast_build_string(&c, &size, "%s%s", prefix, AST_LIST_FIRST(&details->documents)->filename);
1394         AST_LIST_TRAVERSE(&details->documents, doc, next) {
1395                 if (first) {
1396                         first = 0;
1397                         continue;
1398                 }
1399
1400                 ast_build_string(&c, &size, "%s%s%s", separator, prefix, doc->filename);
1401         }
1402
1403         return filenames;
1404 }
1405
1406 /*! \brief send a FAX status manager event */
1407 static int report_fax_status(struct ast_channel *chan, struct ast_fax_session_details *details, const char *status)
1408 {
1409         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
1410         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
1411         struct ast_json *json_filenames = NULL;
1412
1413         if (!details->option.statusevents) {
1414                 return 0;
1415         }
1416
1417         json_filenames = generate_filenames_json(details);
1418         if (!json_filenames) {
1419                 return -1;
1420         }
1421
1422         json_object = ast_json_pack("{s: s, s: s, s: s, s: s, s: o}",
1423                         "type", "status",
1424                         "operation", (details->caps & AST_FAX_TECH_GATEWAY) ? "gateway" : (details->caps & AST_FAX_TECH_RECEIVE) ? "receive" : "send",
1425                         "status", status,
1426                         "local_station_id", details->localstationid,
1427                         "filenames", json_filenames);
1428         if (!json_object) {
1429                 return -1;
1430         }
1431
1432         {
1433                 SCOPED_CHANNELLOCK(lock, chan);
1434
1435                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_object);
1436                 if (!message) {
1437                         return -1;
1438                 }
1439                 stasis_publish(ast_channel_topic(chan), message);
1440         }
1441         return 0;
1442 }
1443
1444 /*! \brief Set fax related channel variables. */
1445 static void set_channel_variables(struct ast_channel *chan, struct ast_fax_session_details *details)
1446 {
1447         char buf[10];
1448         pbx_builtin_setvar_helper(chan, "FAXSTATUS", S_OR(details->result, NULL));
1449         pbx_builtin_setvar_helper(chan, "FAXERROR", S_OR(details->error, NULL));
1450         pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", S_OR(details->resultstr, NULL));
1451         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", S_OR(details->remotestationid, NULL));
1452         pbx_builtin_setvar_helper(chan, "LOCALSTATIONID", S_OR(details->localstationid, NULL));
1453         pbx_builtin_setvar_helper(chan, "FAXBITRATE", S_OR(details->transfer_rate, NULL));
1454         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", S_OR(details->resolution, NULL));
1455
1456         snprintf(buf, sizeof(buf), "%u", details->pages_transferred);
1457         pbx_builtin_setvar_helper(chan, "FAXPAGES", buf);
1458 }
1459
1460 #define GENERIC_FAX_EXEC_SET_VARS(fax, chan, errorstr, reason) \
1461         do {    \
1462                 if (ast_strlen_zero(fax->details->result)) \
1463                         ast_string_field_set(fax->details, result, "FAILED"); \
1464                 if (ast_strlen_zero(fax->details->resultstr)) \
1465                         ast_string_field_set(fax->details, resultstr, reason); \
1466                 if (ast_strlen_zero(fax->details->error)) \
1467                         ast_string_field_set(fax->details, error, errorstr); \
1468                 set_channel_variables(chan, fax->details); \
1469         } while (0)
1470
1471 #define GENERIC_FAX_EXEC_ERROR_QUIET(fax, chan, errorstr, reason) \
1472         do {    \
1473                 GENERIC_FAX_EXEC_SET_VARS(fax, chan, errorstr, reason); \
1474         } while (0)
1475
1476 #define GENERIC_FAX_EXEC_ERROR(fax, chan, errorstr, reason)     \
1477         do {    \
1478                 ast_log(LOG_ERROR, "channel '%s' FAX session '%u' failure, reason: '%s' (%s)\n", ast_channel_name(chan), fax->id, reason, errorstr); \
1479                 GENERIC_FAX_EXEC_ERROR_QUIET(fax, chan, errorstr, reason); \
1480         } while (0)
1481
1482 static int set_fax_t38_caps(struct ast_channel *chan, struct ast_fax_session_details *details)
1483 {
1484         switch (ast_channel_get_t38_state(chan)) {
1485         case T38_STATE_UNKNOWN:
1486                 details->caps |= AST_FAX_TECH_T38;
1487                 break;
1488         case T38_STATE_REJECTED:
1489         case T38_STATE_UNAVAILABLE:
1490                 details->caps |= AST_FAX_TECH_AUDIO;
1491                 break;
1492         case T38_STATE_NEGOTIATED:
1493                 /* already in T.38 mode? This should not happen. */
1494         case T38_STATE_NEGOTIATING: {
1495                 /* the other end already sent us a T.38 reinvite, so we need to prod the channel
1496                  * driver into resending their parameters to us if it supports doing so... if
1497                  * not, we can't proceed, because we can't create a proper reply without them.
1498                  * if it does work, the channel driver will send an AST_CONTROL_T38_PARAMETERS
1499                  * with a request of AST_T38_REQUEST_NEGOTIATE, which will be read by the function
1500                  * that gets called after this one completes
1501                  */
1502                 struct ast_control_t38_parameters parameters = { .request_response = AST_T38_REQUEST_PARMS, };
1503                 if (ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters)) != AST_T38_REQUEST_PARMS) {
1504                         ast_log(LOG_ERROR, "channel '%s' is in an unsupported T.38 negotiation state, cannot continue.\n", ast_channel_name(chan));
1505                         return -1;
1506                 }
1507                 details->caps |= AST_FAX_TECH_T38;
1508                 break;
1509         }
1510         default:
1511                 ast_log(LOG_ERROR, "channel '%s' is in an unsupported T.38 negotiation state, cannot continue.\n", ast_channel_name(chan));
1512                 return -1;
1513         }
1514
1515         return 0;
1516 }
1517
1518 static int disable_t38(struct ast_channel *chan)
1519 {
1520         int timeout_ms;
1521         struct ast_frame *frame = NULL;
1522         struct ast_control_t38_parameters t38_parameters = { .request_response = AST_T38_REQUEST_TERMINATE, };
1523         struct timeval start;
1524         int ms;
1525
1526         ast_debug(1, "Shutting down T.38 on %s\n", ast_channel_name(chan));
1527         if (ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0) {
1528                 ast_debug(1, "error while disabling T.38 on channel '%s'\n", ast_channel_name(chan));
1529                 return -1;
1530         }
1531
1532         /* wait up to five seconds for negotiation to complete */
1533         timeout_ms = 5000;
1534         start = ast_tvnow();
1535         while ((ms = ast_remaining_ms(start, timeout_ms))) {
1536                 ms = ast_waitfor(chan, ms);
1537
1538                 if (ms == 0) {
1539                         break;
1540                 }
1541                 if (ms < 0) {
1542                         ast_debug(1, "error while disabling T.38 on channel '%s'\n", ast_channel_name(chan));
1543                         return -1;
1544                 }
1545
1546                 if (!(frame = ast_read(chan))) {
1547                         return -1;
1548                 }
1549                 if ((frame->frametype == AST_FRAME_CONTROL) &&
1550                     (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1551                     (frame->datalen == sizeof(t38_parameters))) {
1552                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
1553
1554                         switch (parameters->request_response) {
1555                         case AST_T38_TERMINATED:
1556                                 ast_debug(1, "Shut down T.38 on %s\n", ast_channel_name(chan));
1557                                 break;
1558                         case AST_T38_REFUSED:
1559                                 ast_log(LOG_WARNING, "channel '%s' refused to disable T.38\n", ast_channel_name(chan));
1560                                 ast_frfree(frame);
1561                                 return -1;
1562                         default:
1563                                 ast_log(LOG_ERROR, "channel '%s' failed to disable T.38\n", ast_channel_name(chan));
1564                                 ast_frfree(frame);
1565                                 return -1;
1566                         }
1567                         ast_frfree(frame);
1568                         break;
1569                 }
1570                 ast_frfree(frame);
1571         }
1572
1573         if (ms == 0) { /* all done, nothing happened */
1574                 ast_debug(1, "channel '%s' timed-out during T.38 shutdown\n", ast_channel_name(chan));
1575         }
1576
1577         return 0;
1578 }
1579
1580 /*! \brief this is the generic FAX session handling function */
1581 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)
1582 {
1583         int ms;
1584         int timeout = RES_FAX_TIMEOUT;
1585         int chancount;
1586         unsigned int expected_frametype = -1;
1587         struct ast_frame_subclass expected_framesubclass = { .integer = 0, };
1588         unsigned int t38negotiated = (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED);
1589         struct ast_control_t38_parameters t38_parameters;
1590         const char *tempvar;
1591         struct ast_fax_session *fax = NULL;
1592         struct ast_frame *frame = NULL;
1593         struct ast_channel *c = chan;
1594         RAII_VAR(struct ast_format *, orig_write_format, NULL, ao2_cleanup);
1595         RAII_VAR(struct ast_format *, orig_read_format, NULL, ao2_cleanup);
1596         int remaining_time;
1597         struct timeval start;
1598
1599         chancount = 1;
1600
1601         /* create the FAX session */
1602         if (!(fax = fax_session_new(details, chan, reserved, token))) {
1603                 ast_log(LOG_ERROR, "Can't create a FAX session, FAX attempt failed.\n");
1604                 report_fax_status(chan, details, "No Available Resource");
1605                 return -1;
1606         }
1607
1608         ast_channel_lock(chan);
1609         /* update session details */
1610         if (ast_strlen_zero(details->headerinfo) && (tempvar = pbx_builtin_getvar_helper(chan, "LOCALHEADERINFO"))) {
1611                 ast_string_field_set(details, headerinfo, tempvar);
1612         }
1613         if (ast_strlen_zero(details->localstationid)) {
1614                 tempvar = pbx_builtin_getvar_helper(chan, "LOCALSTATIONID");
1615                 ast_string_field_set(details, localstationid, tempvar ? tempvar : "unknown");
1616         }
1617         ast_channel_unlock(chan);
1618
1619         report_fax_status(chan, details, "Allocating Resources");
1620
1621         if (details->caps & AST_FAX_TECH_AUDIO) {
1622                 expected_frametype = AST_FRAME_VOICE;
1623                 expected_framesubclass.format = ast_format_slin;
1624                 orig_write_format = ao2_bump(ast_channel_writeformat(chan));
1625                 if (ast_set_write_format(chan, ast_format_slin) < 0) {
1626                         ast_log(LOG_ERROR, "channel '%s' failed to set write format to signed linear'.\n", ast_channel_name(chan));
1627                         ao2_lock(faxregistry.container);
1628                         ao2_unlink(faxregistry.container, fax);
1629                         ao2_unlock(faxregistry.container);
1630                         ao2_ref(fax, -1);
1631                         ast_channel_unlock(chan);
1632                         return -1;
1633                 }
1634                 orig_read_format = ao2_bump(ast_channel_readformat(chan));
1635                 if (ast_set_read_format(chan, ast_format_slin) < 0) {
1636                         ast_log(LOG_ERROR, "channel '%s' failed to set read format to signed linear.\n", ast_channel_name(chan));
1637                         ao2_lock(faxregistry.container);
1638                         ao2_unlink(faxregistry.container, fax);
1639                         ao2_unlock(faxregistry.container);
1640                         ao2_ref(fax, -1);
1641                         ast_channel_unlock(chan);
1642                         return -1;
1643                 }
1644                 if (fax->smoother) {
1645                         ast_smoother_free(fax->smoother);
1646                         fax->smoother = NULL;
1647                 }
1648                 if (!(fax->smoother = ast_smoother_new(320))) {
1649                         ast_log(LOG_WARNING, "Channel '%s' FAX session '%u' failed to obtain a smoother.\n", ast_channel_name(chan), fax->id);
1650                 }
1651         } else {
1652                 expected_frametype = AST_FRAME_MODEM;
1653                 expected_framesubclass.integer = AST_MODEM_T38;
1654         }
1655
1656         if (fax->debug_info) {
1657                 fax->debug_info->base_tv = ast_tvnow();
1658         }
1659
1660         /* reset our result fields just in case the fax tech driver wants to
1661          * set custom error messages */
1662         ast_string_field_set(details, result, "");
1663         ast_string_field_set(details, resultstr, "");
1664         ast_string_field_set(details, error, "");
1665         set_channel_variables(chan, details);
1666
1667         if (fax->tech->start_session(fax) < 0) {
1668                 GENERIC_FAX_EXEC_ERROR(fax, chan, "INIT_ERROR", "failed to start FAX session");
1669         }
1670
1671         report_fax_status(chan, details, "FAX Transmission In Progress");
1672
1673         ast_debug(5, "channel %s will wait on FAX fd %d\n", ast_channel_name(chan), fax->fd);
1674
1675         /* handle frames for the session */
1676         remaining_time = timeout;
1677         start = ast_tvnow();
1678         while (remaining_time > 0) {
1679                 struct ast_channel *ready_chan;
1680                 int ofd, exception;
1681
1682                 ms = 1000;
1683                 errno = 0;
1684                 ready_chan = ast_waitfor_nandfds(&c, chancount, &fax->fd, 1, &exception, &ofd, &ms);
1685                 if (ready_chan) {
1686                         if (!(frame = ast_read(chan))) {
1687                                 /* the channel is probably gone, so lets stop polling on it and let the
1688                                  * FAX session complete before we exit the application.  if needed,
1689                                  * send the FAX stack silence so the modems can finish their session without
1690                                  * any problems */
1691                                 ast_debug(1, "Channel '%s' did not return a frame; probably hung up.\n", ast_channel_name(chan));
1692                                 GENERIC_FAX_EXEC_SET_VARS(fax, chan, "HANGUP", "remote channel hungup");
1693                                 c = NULL;
1694                                 chancount = 0;
1695                                 remaining_time = ast_remaining_ms(start, timeout);
1696                                 fax->tech->cancel_session(fax);
1697                                 if (fax->tech->generate_silence) {
1698                                         fax->tech->generate_silence(fax);
1699                                 }
1700                                 continue;
1701                         }
1702
1703                         if ((frame->frametype == AST_FRAME_CONTROL) &&
1704                             (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1705                             (frame->datalen == sizeof(t38_parameters))) {
1706                                 unsigned int was_t38 = t38negotiated;
1707                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
1708
1709                                 switch (parameters->request_response) {
1710                                 case AST_T38_REQUEST_NEGOTIATE:
1711                                         /* the other end has requested a switch to T.38, so reply that we are willing, if we can
1712                                          * do T.38 as well
1713                                          */
1714                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1715                                         t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
1716                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1717                                         break;
1718                                 case AST_T38_NEGOTIATED:
1719                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1720                                         t38negotiated = 1;
1721                                         break;
1722                                 default:
1723                                         break;
1724                                 }
1725                                 if (t38negotiated && !was_t38) {
1726                                         if (fax->tech->switch_to_t38(fax)) {
1727                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "T.38 switch failed");
1728                                                 break;
1729                                         }
1730                                         details->caps &= ~AST_FAX_TECH_AUDIO;
1731                                         expected_frametype = AST_FRAME_MODEM;
1732                                         expected_framesubclass.integer = AST_MODEM_T38;
1733                                         if (fax->smoother) {
1734                                                 ast_smoother_free(fax->smoother);
1735                                                 fax->smoother = NULL;
1736                                         }
1737
1738                                         report_fax_status(chan, details, "T.38 Negotiated");
1739
1740                                         ast_verb(3, "Channel '%s' switched to T.38 FAX session '%u'.\n", ast_channel_name(chan), fax->id);
1741                                 }
1742                         } else if ((frame->frametype == expected_frametype) && (expected_framesubclass.integer == frame->subclass.integer) &&
1743                                 ((!frame->subclass.format && !expected_framesubclass.format) ||
1744                                 (frame->subclass.format && expected_framesubclass.format &&
1745                                         (ast_format_cmp(frame->subclass.format, expected_framesubclass.format) != AST_FORMAT_CMP_NOT_EQUAL)))) {
1746                                 struct ast_frame *f;
1747
1748                                 if (fax->smoother) {
1749                                         /* push the frame into a smoother */
1750                                         if (ast_smoother_feed(fax->smoother, frame) < 0) {
1751                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "Failed to feed the smoother");
1752                                         }
1753                                         while ((f = ast_smoother_read(fax->smoother)) && (f->data.ptr)) {
1754                                                 if (fax->debug_info) {
1755                                                         debug_check_frame_for_silence(fax, 1, f);
1756                                                 }
1757                                                 /* write the frame to the FAX stack */
1758                                                 fax->tech->write(fax, f);
1759                                                 fax->frames_received++;
1760                                                 if (f != frame) {
1761                                                         ast_frfree(f);
1762                                                 }
1763                                         }
1764                                 } else {
1765                                         /* write the frame to the FAX stack */
1766                                         fax->tech->write(fax, frame);
1767                                         fax->frames_received++;
1768                                 }
1769                                 start = ast_tvnow();
1770                         }
1771                         ast_frfree(frame);
1772                 } else if (ofd == fax->fd) {
1773                         /* read a frame from the FAX stack and send it out the channel.
1774                          * the FAX stack will return a NULL if the FAX session has already completed */
1775                         if (!(frame = fax->tech->read(fax))) {
1776                                 break;
1777                         }
1778
1779                         if (fax->debug_info && (frame->frametype == AST_FRAME_VOICE)) {
1780                                 debug_check_frame_for_silence(fax, 0, frame);
1781                         }
1782
1783                         ast_write(chan, frame);
1784                         fax->frames_sent++;
1785                         ast_frfree(frame);
1786                         start = ast_tvnow();
1787                 } else {
1788                         if (ms && (ofd < 0)) {
1789                                 if ((errno == 0) || (errno == EINTR)) {
1790                                         remaining_time = ast_remaining_ms(start, timeout);
1791                                         if (remaining_time <= 0)
1792                                                 GENERIC_FAX_EXEC_ERROR(fax, chan, "TIMEOUT", "fax session timed-out");
1793                                         continue;
1794                                 } else {
1795                                         ast_log(LOG_WARNING, "something bad happened while channel '%s' was polling.\n", ast_channel_name(chan));
1796                                         GENERIC_FAX_EXEC_ERROR(fax, chan, "UNKNOWN", "error polling data");
1797                                         break;
1798                                 }
1799                         } else {
1800                                 /* nothing happened */
1801                                 remaining_time = ast_remaining_ms(start, timeout);
1802                                 if (remaining_time <= 0) {
1803                                         GENERIC_FAX_EXEC_ERROR(fax, chan, "TIMEOUT", "fax session timed-out");
1804                                         break;
1805                                 }
1806                         }
1807                 }
1808         }
1809         ast_debug(3, "channel '%s' - event loop stopped { timeout: %d, remaining_time: %d }\n", ast_channel_name(chan), timeout, remaining_time);
1810
1811         set_channel_variables(chan, details);
1812
1813         ast_atomic_fetchadd_int(&faxregistry.fax_complete, 1);
1814         if (!strcasecmp(details->result, "FAILED")) {
1815                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
1816         }
1817
1818         if (fax) {
1819                 ao2_lock(faxregistry.container);
1820                 ao2_unlink(faxregistry.container, fax);
1821                 ao2_unlock(faxregistry.container);
1822                 ao2_ref(fax, -1);
1823         }
1824
1825         /* if the channel is still alive, and we changed its read/write formats,
1826          * restore them now
1827          */
1828         if (chancount) {
1829                 if (orig_read_format) {
1830                         ast_set_read_format(chan, orig_read_format);
1831                 }
1832                 if (orig_write_format) {
1833                         ast_set_write_format(chan, orig_write_format);
1834                 }
1835         }
1836
1837         /* return the chancount so the calling function can determine if the channel hungup during this FAX session or not */
1838         return chancount;
1839 }
1840
1841 static int receivefax_t38_init(struct ast_channel *chan, struct ast_fax_session_details *details)
1842 {
1843         int timeout_ms;
1844         struct ast_frame *frame = NULL;
1845         struct ast_control_t38_parameters t38_parameters;
1846         struct timeval start;
1847         int ms;
1848
1849         /* don't send any audio if we've already received a T.38 reinvite */
1850         if (ast_channel_get_t38_state(chan) != T38_STATE_NEGOTIATING) {
1851                 /* generate 3 seconds of CED */
1852                 if (ast_playtones_start(chan, 1024, "!2100/3000", 1)) {
1853                         ast_log(LOG_ERROR, "error generating CED tone on %s\n", ast_channel_name(chan));
1854                         return -1;
1855                 }
1856
1857                 timeout_ms = 3000;
1858                 start = ast_tvnow();
1859                 while ((ms = ast_remaining_ms(start, timeout_ms))) {
1860                         ms = ast_waitfor(chan, ms);
1861
1862                         if (ms < 0) {
1863                                 ast_log(LOG_ERROR, "error while generating CED tone on %s\n", ast_channel_name(chan));
1864                                 ast_playtones_stop(chan);
1865                                 return -1;
1866                         }
1867
1868                         if (ms == 0) { /* all done, nothing happened */
1869                                 break;
1870                         }
1871
1872                         if (!(frame = ast_read(chan))) {
1873                                 ast_log(LOG_ERROR, "error reading frame while generating CED tone on %s\n", ast_channel_name(chan));
1874                                 ast_playtones_stop(chan);
1875                                 return -1;
1876                         }
1877
1878                         if ((frame->frametype == AST_FRAME_CONTROL) &&
1879                             (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1880                             (frame->datalen == sizeof(t38_parameters))) {
1881                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
1882
1883                                 switch (parameters->request_response) {
1884                                 case AST_T38_REQUEST_NEGOTIATE:
1885                                         /* the other end has requested a switch to T.38, so reply that we are willing, if we can
1886                                          * do T.38 as well
1887                                          */
1888                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1889                                         t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
1890                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1891                                         ast_playtones_stop(chan);
1892                                         break;
1893                                 case AST_T38_NEGOTIATED:
1894                                         ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
1895                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1896                                         details->caps &= ~AST_FAX_TECH_AUDIO;
1897                                         report_fax_status(chan, details, "T.38 Negotiated");
1898                                         break;
1899                                 default:
1900                                         break;
1901                                 }
1902                         }
1903                         ast_frfree(frame);
1904                 }
1905
1906                 ast_playtones_stop(chan);
1907         }
1908
1909         /* if T.38 was negotiated, we are done initializing */
1910         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
1911                 return 0;
1912         }
1913
1914         /* request T.38 */
1915         ast_debug(1, "Negotiating T.38 for receive on %s\n", ast_channel_name(chan));
1916
1917         /* wait for negotiation to complete */
1918         timeout_ms = details->t38timeout;
1919
1920         /* set parameters based on the session's parameters */
1921         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1922         t38_parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
1923         if ((ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0)) {
1924                 return -1;
1925         }
1926
1927         start = ast_tvnow();
1928         while ((ms = ast_remaining_ms(start, timeout_ms))) {
1929                 int break_loop = 0;
1930
1931                 ms = ast_waitfor(chan, ms);
1932                 if (ms < 0) {
1933                         ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
1934                         return -1;
1935                 }
1936                 if (ms == 0) { /* all done, nothing happened */
1937                         ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 negotiation.\n", ast_channel_name(chan));
1938                         details->caps &= ~AST_FAX_TECH_T38;
1939                         break;
1940                 }
1941
1942                 if (!(frame = ast_read(chan))) {
1943                         ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
1944                         return -1;
1945                 }
1946
1947                 if ((frame->frametype == AST_FRAME_CONTROL) &&
1948                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
1949                                 (frame->datalen == sizeof(t38_parameters))) {
1950                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
1951
1952                         switch (parameters->request_response) {
1953                         case AST_T38_REQUEST_NEGOTIATE:
1954                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
1955                                 t38_parameters.request_response = AST_T38_NEGOTIATED;
1956                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
1957                                 break;
1958                         case AST_T38_NEGOTIATED:
1959                                 ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
1960                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
1961                                 details->caps &= ~AST_FAX_TECH_AUDIO;
1962                                 report_fax_status(chan, details, "T.38 Negotiated");
1963                                 break_loop = 1;
1964                                 break;
1965                         case AST_T38_REFUSED:
1966                                 ast_log(LOG_WARNING, "channel '%s' refused to negotiate T.38\n", ast_channel_name(chan));
1967                                 details->caps &= ~AST_FAX_TECH_T38;
1968                                 break_loop = 1;
1969                                 break;
1970                         default:
1971                                 ast_log(LOG_ERROR, "channel '%s' failed to negotiate T.38\n", ast_channel_name(chan));
1972                                 details->caps &= ~AST_FAX_TECH_T38;
1973                                 break_loop = 1;
1974                                 break;
1975                         }
1976                 }
1977                 ast_frfree(frame);
1978                 if (break_loop) {
1979                         break;
1980                 }
1981         }
1982
1983         /* if T.38 was negotiated, we are done initializing */
1984         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
1985                 return 0;
1986         }
1987
1988         /* if we made it here, then T.38 failed, check the 'f' flag */
1989         if (details->option.allow_audio != AST_FAX_OPTFLAG_TRUE) {
1990                 ast_log(LOG_WARNING, "Audio FAX not allowed on channel '%s' and T.38 negotiation failed; aborting.\n", ast_channel_name(chan));
1991                 return -1;
1992         }
1993
1994         /* ok, audio fallback is allowed */
1995         details->caps |= AST_FAX_TECH_AUDIO;
1996
1997         return 0;
1998 }
1999
2000 /*! \brief Report on the final state of a receive fax operation
2001  * \note This will lock the \ref ast_channel
2002  */
2003 static int report_receive_fax_status(struct ast_channel *chan, const char *filename)
2004 {
2005         RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
2006         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
2007         RAII_VAR(struct ast_json *, json_array, ast_json_array_create(), ast_json_unref);
2008         struct ast_json *json_filename = ast_json_string_create(filename);
2009
2010         if (!json_array || !json_filename) {
2011                 ast_json_unref(json_filename);
2012                 return -1;
2013         }
2014         ast_json_array_append(json_array, json_filename);
2015
2016         {
2017                 const char *remote_station_id;
2018                 const char *local_station_id;
2019                 const char *fax_pages;
2020                 const char *fax_resolution;
2021                 const char *fax_bitrate;
2022                 SCOPED_CHANNELLOCK(lock, chan);
2023
2024                 remote_station_id = S_OR(pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), "");
2025                 if (!ast_strlen_zero(remote_station_id)) {
2026                         remote_station_id = ast_strdupa(remote_station_id);
2027                 }
2028                 local_station_id = S_OR(pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), "");
2029                 if (!ast_strlen_zero(local_station_id)) {
2030                         local_station_id = ast_strdupa(local_station_id);
2031                 }
2032                 fax_pages = S_OR(pbx_builtin_getvar_helper(chan, "FAXPAGES"), "");
2033                 if (!ast_strlen_zero(fax_pages)) {
2034                         fax_pages = ast_strdupa(fax_pages);
2035                 }
2036                 fax_resolution = S_OR(pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), "");
2037                 if (!ast_strlen_zero(fax_resolution)) {
2038                         fax_resolution = ast_strdupa(fax_resolution);
2039                 }
2040                 fax_bitrate = S_OR(pbx_builtin_getvar_helper(chan, "FAXBITRATE"), "");
2041                 if (!ast_strlen_zero(fax_bitrate)) {
2042                         fax_bitrate = ast_strdupa(fax_bitrate);
2043                 }
2044
2045                 json_object = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s, s: O}",
2046                                 "type", "receive",
2047                                 "remote_station_id", S_OR(remote_station_id, ""),
2048                                 "local_station_id", S_OR(local_station_id, ""),
2049                                 "fax_pages", S_OR(fax_pages, ""),
2050                                 "fax_resolution", S_OR(fax_resolution, ""),
2051                                 "fax_bitrate", S_OR(fax_bitrate, ""),
2052                                 "filenames", json_array);
2053                 if (!json_object) {
2054                         return -1;
2055                 }
2056
2057                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_object);
2058                 if (!message) {
2059                         return -1;
2060                 }
2061                 stasis_publish(ast_channel_topic(chan), message);
2062         }
2063         return 0;
2064 }
2065
2066 /*! \brief initiate a receive FAX session */
2067 static int receivefax_exec(struct ast_channel *chan, const char *data)
2068 {
2069         char *parse, modems[128] = "";
2070         int channel_alive;
2071         RAII_VAR(struct ast_fax_session *, s, NULL, ao2_cleanup);
2072         RAII_VAR(struct ast_fax_session_details *, details, NULL, ao2_cleanup);
2073         struct ast_fax_tech_token *token = NULL;
2074         struct ast_fax_document *doc;
2075         AST_DECLARE_APP_ARGS(args,
2076                 AST_APP_ARG(filename);
2077                 AST_APP_ARG(options);
2078         );
2079         struct ast_flags opts = { 0, };
2080         enum ast_t38_state t38state;
2081
2082         /* initialize output channel variables */
2083         pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED");
2084         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL);
2085         pbx_builtin_setvar_helper(chan, "FAXPAGES", "0");
2086         pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL);
2087         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL);
2088
2089         /* Get a FAX session details structure from the channel's FAX datastore and create one if
2090          * it does not already exist. */
2091         if (!(details = find_or_create_details(chan))) {
2092                 pbx_builtin_setvar_helper(chan, "FAXERROR", "MEMORY_ERROR");
2093                 pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "error allocating memory");
2094                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2095                 return -1;
2096         }
2097
2098         ast_string_field_set(details, result, "FAILED");
2099         ast_string_field_set(details, resultstr, "error starting fax session");
2100         ast_string_field_set(details, error, "INIT_ERROR");
2101         set_channel_variables(chan, details);
2102
2103         if (details->gateway_id > 0) {
2104                 ast_string_field_set(details, resultstr, "can't receive a fax on a channel with a T.38 gateway");
2105                 set_channel_variables(chan, details);
2106                 ast_log(LOG_ERROR, "executing ReceiveFAX on a channel with a T.38 Gateway is not supported\n");
2107                 return -1;
2108         }
2109
2110         if (details->maxrate < details->minrate) {
2111                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2112                 ast_string_field_set(details, resultstr, "maxrate is less than minrate");
2113                 set_channel_variables(chan, details);
2114                 ast_log(LOG_ERROR, "maxrate %u is less than minrate %u\n", details->maxrate, details->minrate);
2115                 return -1;
2116         }
2117
2118         if (check_modem_rate(details->modems, details->minrate)) {
2119                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2120                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'minrate' setting %u\n", modems, details->minrate);
2121                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2122                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'minrate' settings");
2123                 set_channel_variables(chan, details);
2124                 return -1;
2125         }
2126
2127         if (check_modem_rate(details->modems, details->maxrate)) {
2128                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2129                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'maxrate' setting %u\n", modems, details->maxrate);
2130                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2131                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'maxrate' settings");
2132                 set_channel_variables(chan, details);
2133                 return -1;
2134         }
2135
2136         if (ast_strlen_zero(data)) {
2137                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2138                 ast_string_field_set(details, resultstr, "invalid arguments");
2139                 set_channel_variables(chan, details);
2140                 ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax);
2141                 return -1;
2142         }
2143         parse = ast_strdupa(data);
2144         AST_STANDARD_APP_ARGS(args, parse);
2145
2146         if (!ast_strlen_zero(args.options) &&
2147             ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) {
2148                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2149                 ast_string_field_set(details, resultstr, "invalid arguments");
2150                 set_channel_variables(chan, details);
2151                 return -1;
2152         }
2153         if (ast_strlen_zero(args.filename)) {
2154                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2155                 ast_string_field_set(details, resultstr, "invalid arguments");
2156                 set_channel_variables(chan, details);
2157                 ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax);
2158                 return -1;
2159         }
2160
2161         /* check for unsupported FAX application options */
2162         if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) {
2163                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2164                 ast_string_field_set(details, resultstr, "invalid arguments");
2165                 set_channel_variables(chan, details);
2166                 ast_log(LOG_WARNING, "%s does not support polling\n", app_receivefax);
2167                 return -1;
2168         }
2169
2170         ast_atomic_fetchadd_int(&faxregistry.fax_rx_attempts, 1);
2171
2172         pbx_builtin_setvar_helper(chan, "FAXERROR", "Channel Problems");
2173         pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Error before FAX transmission started.");
2174
2175         if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(args.filename) + 1))) {
2176                 ast_string_field_set(details, error, "MEMORY_ERROR");
2177                 ast_string_field_set(details, resultstr, "error allocating memory");
2178                 set_channel_variables(chan, details);
2179                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2180                 return -1;
2181         }
2182
2183         strcpy(doc->filename, args.filename);
2184         AST_LIST_INSERT_TAIL(&details->documents, doc, next);
2185
2186         ast_verb(3, "Channel '%s' receiving FAX '%s'\n", ast_channel_name(chan), args.filename);
2187
2188         details->caps = AST_FAX_TECH_RECEIVE;
2189         details->option.send_ced = AST_FAX_OPTFLAG_TRUE;
2190
2191         /* check for debug */
2192         if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) {
2193                 details->option.debug = AST_FAX_OPTFLAG_TRUE;
2194         }
2195
2196         /* check for request for status events */
2197         if (ast_test_flag(&opts, OPT_STATUS)) {
2198                 details->option.statusevents = AST_FAX_OPTFLAG_TRUE;
2199         }
2200
2201         t38state = ast_channel_get_t38_state(chan);
2202         if ((t38state == T38_STATE_UNAVAILABLE) || (t38state == T38_STATE_REJECTED) ||
2203             ast_test_flag(&opts, OPT_ALLOWAUDIO) ||
2204             ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2205                 details->option.allow_audio = AST_FAX_OPTFLAG_TRUE;
2206         }
2207
2208         if (!(s = fax_session_reserve(details, &token))) {
2209                 ast_string_field_set(details, resultstr, "error reserving fax session");
2210                 set_channel_variables(chan, details);
2211                 ast_log(LOG_ERROR, "Unable to reserve FAX session.\n");
2212                 return -1;
2213         }
2214
2215         /* make sure the channel is up */
2216         if (ast_channel_state(chan) != AST_STATE_UP) {
2217                 if (ast_answer(chan)) {
2218                         ast_string_field_set(details, resultstr, "error answering channel");
2219                         set_channel_variables(chan, details);
2220                         ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", ast_channel_name(chan));
2221                         fax_session_release(s, token);
2222                         return -1;
2223                 }
2224         }
2225
2226         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2227                 if (set_fax_t38_caps(chan, details)) {
2228                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2229                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2230                         set_channel_variables(chan, details);
2231                         fax_session_release(s, token);
2232                         return -1;
2233                 }
2234         } else {
2235                 details->caps |= AST_FAX_TECH_AUDIO;
2236         }
2237
2238         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO) && (details->caps & AST_FAX_TECH_T38)) {
2239                 if (receivefax_t38_init(chan, details)) {
2240                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2241                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2242                         set_channel_variables(chan, details);
2243                         fax_session_release(s, token);
2244                         ast_log(LOG_ERROR, "error initializing channel '%s' in T.38 mode\n", ast_channel_name(chan));
2245                         return -1;
2246                 }
2247         }
2248
2249         if ((channel_alive = generic_fax_exec(chan, details, s, token)) < 0) {
2250                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
2251         }
2252
2253         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2254                 if (disable_t38(chan)) {
2255                         ast_debug(1, "error disabling T.38 mode on %s\n", ast_channel_name(chan));
2256                 }
2257         }
2258
2259         if (report_receive_fax_status(chan, args.filename)) {
2260                 ast_log(AST_LOG_ERROR, "Error publishing ReceiveFax status message\n");
2261         }
2262
2263         /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */
2264         return (!channel_alive) ? -1 : 0;
2265 }
2266
2267 static int sendfax_t38_init(struct ast_channel *chan, struct ast_fax_session_details *details)
2268 {
2269         int timeout_ms;
2270         struct ast_frame *frame = NULL;
2271         struct ast_control_t38_parameters t38_parameters;
2272         struct timeval start;
2273         int ms;
2274
2275         /* send CNG tone while listening for the receiver to initiate a switch
2276          * to T.38 mode; if they do, stop sending the CNG tone and proceed with
2277          * the switch.
2278          *
2279          * 10500 is enough time for 3 CNG tones
2280          */
2281         timeout_ms = 10500;
2282
2283         /* don't send any audio if we've already received a T.38 reinvite */
2284         if (ast_channel_get_t38_state(chan) != T38_STATE_NEGOTIATING) {
2285                 if (ast_playtones_start(chan, 1024, "!1100/500,!0/3000,!1100/500,!0/3000,!1100/500,!0/3000", 1)) {
2286                         ast_log(LOG_ERROR, "error generating CNG tone on %s\n", ast_channel_name(chan));
2287                         return -1;
2288                 }
2289         }
2290
2291         start = ast_tvnow();
2292         while ((ms = ast_remaining_ms(start, timeout_ms))) {
2293                 int break_loop = 0;
2294                 ms = ast_waitfor(chan, ms);
2295
2296                 if (ms < 0) {
2297                         ast_log(LOG_ERROR, "error while generating CNG tone on %s\n", ast_channel_name(chan));
2298                         ast_playtones_stop(chan);
2299                         return -1;
2300                 }
2301
2302                 if (ms == 0) { /* all done, nothing happened */
2303                         break;
2304                 }
2305
2306                 if (!(frame = ast_read(chan))) {
2307                         ast_log(LOG_ERROR, "error reading frame while generating CNG tone on %s\n", ast_channel_name(chan));
2308                         ast_playtones_stop(chan);
2309                         return -1;
2310                 }
2311
2312                 if ((frame->frametype == AST_FRAME_CONTROL) &&
2313                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2314                                 (frame->datalen == sizeof(t38_parameters))) {
2315                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
2316
2317                         switch (parameters->request_response) {
2318                         case AST_T38_REQUEST_NEGOTIATE:
2319                                 /* the other end has requested a switch to T.38, so reply that we are willing, if we can
2320                                  * do T.38 as well
2321                                  */
2322                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2323                                 t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
2324                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2325                                 ast_playtones_stop(chan);
2326                                 break;
2327                         case AST_T38_NEGOTIATED:
2328                                 ast_debug(1, "Negotiated T.38 for send on %s\n", ast_channel_name(chan));
2329                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2330                                 details->caps &= ~AST_FAX_TECH_AUDIO;
2331                                 report_fax_status(chan, details, "T.38 Negotiated");
2332                                 break_loop = 1;
2333                                 break;
2334                         default:
2335                                 break;
2336                         }
2337                 }
2338                 ast_frfree(frame);
2339                 if (break_loop) {
2340                         break;
2341                 }
2342         }
2343
2344         ast_playtones_stop(chan);
2345
2346         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2347                 return 0;
2348         }
2349
2350         /* T.38 negotiation did not happen, initiate a switch if requested */
2351         if (details->option.request_t38 == AST_FAX_OPTFLAG_TRUE) {
2352                 ast_debug(1, "Negotiating T.38 for send on %s\n", ast_channel_name(chan));
2353
2354                 /* wait up to five seconds for negotiation to complete */
2355                 timeout_ms = 5000;
2356
2357                 /* set parameters based on the session's parameters */
2358                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2359                 t38_parameters.request_response = AST_T38_REQUEST_NEGOTIATE;
2360                 if ((ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0)) {
2361                         return -1;
2362                 }
2363
2364                 start = ast_tvnow();
2365                 while ((ms = ast_remaining_ms(start, timeout_ms))) {
2366                         int break_loop = 0;
2367
2368                         ms = ast_waitfor(chan, ms);
2369                         if (ms < 0) {
2370                                 ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
2371                                 return -1;
2372                         }
2373                         if (ms == 0) { /* all done, nothing happened */
2374                                 ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 negotiation.\n", ast_channel_name(chan));
2375                                 details->caps &= ~AST_FAX_TECH_T38;
2376                                 break;
2377                         }
2378
2379                         if (!(frame = ast_read(chan))) {
2380                                 ast_log(LOG_WARNING, "error on '%s' while waiting for T.38 negotiation.\n", ast_channel_name(chan));
2381                                 return -1;
2382                         }
2383
2384                         if ((frame->frametype == AST_FRAME_CONTROL) &&
2385                                         (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2386                                         (frame->datalen == sizeof(t38_parameters))) {
2387                                 struct ast_control_t38_parameters *parameters = frame->data.ptr;
2388
2389                                 switch (parameters->request_response) {
2390                                 case AST_T38_REQUEST_NEGOTIATE:
2391                                         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2392                                         t38_parameters.request_response = AST_T38_NEGOTIATED;
2393                                         ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2394                                         break;
2395                                 case AST_T38_NEGOTIATED:
2396                                         ast_debug(1, "Negotiated T.38 for receive on %s\n", ast_channel_name(chan));
2397                                         t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2398                                         details->caps &= ~AST_FAX_TECH_AUDIO;
2399                                         report_fax_status(chan, details, "T.38 Negotiated");
2400                                         break_loop = 1;
2401                                         break;
2402                                 case AST_T38_REFUSED:
2403                                         ast_log(LOG_WARNING, "channel '%s' refused to negotiate T.38\n", ast_channel_name(chan));
2404                                         details->caps &= ~AST_FAX_TECH_T38;
2405                                         break_loop = 1;
2406                                         break;
2407                                 default:
2408                                         ast_log(LOG_ERROR, "channel '%s' failed to negotiate T.38\n", ast_channel_name(chan));
2409                                         details->caps &= ~AST_FAX_TECH_T38;
2410                                         break_loop = 1;
2411                                         break;
2412                                 }
2413                         }
2414                         ast_frfree(frame);
2415                         if (break_loop) {
2416                                 break;
2417                         }
2418                 }
2419
2420                 /* if T.38 was negotiated, we are done initializing */
2421                 if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2422                         return 0;
2423                 }
2424
2425                 /* send one more CNG tone to get audio going again for some
2426                  * carriers if we are going to fall back to audio mode */
2427                 if (details->option.allow_audio == AST_FAX_OPTFLAG_TRUE) {
2428                         if (ast_playtones_start(chan, 1024, "!1100/500,!0/3000", 1)) {
2429                                 ast_log(LOG_ERROR, "error generating second CNG tone on %s\n", ast_channel_name(chan));
2430                                 return -1;
2431                         }
2432
2433                         timeout_ms = 3500;
2434                         start = ast_tvnow();
2435                         while ((ms = ast_remaining_ms(start, timeout_ms))) {
2436                                 int break_loop = 0;
2437
2438                                 ms = ast_waitfor(chan, ms);
2439                                 if (ms < 0) {
2440                                         ast_log(LOG_ERROR, "error while generating second CNG tone on %s\n", ast_channel_name(chan));
2441                                         ast_playtones_stop(chan);
2442                                         return -1;
2443                                 }
2444                                 if (ms == 0) { /* all done, nothing happened */
2445                                         break;
2446                                 }
2447
2448                                 if (!(frame = ast_read(chan))) {
2449                                         ast_log(LOG_ERROR, "error reading frame while generating second CNG tone on %s\n", ast_channel_name(chan));
2450                                         ast_playtones_stop(chan);
2451                                         return -1;
2452                                 }
2453
2454                                 if ((frame->frametype == AST_FRAME_CONTROL) &&
2455                                                 (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) &&
2456                                                 (frame->datalen == sizeof(t38_parameters))) {
2457                                         struct ast_control_t38_parameters *parameters = frame->data.ptr;
2458
2459                                         switch (parameters->request_response) {
2460                                         case AST_T38_REQUEST_NEGOTIATE:
2461                                                 /* the other end has requested a switch to T.38, so reply that we are willing, if we can
2462                                                  * do T.38 as well
2463                                                  */
2464                                                 t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2465                                                 t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED;
2466                                                 ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters));
2467                                                 ast_playtones_stop(chan);
2468                                                 break;
2469                                         case AST_T38_NEGOTIATED:
2470                                                 ast_debug(1, "Negotiated T.38 for send on %s\n", ast_channel_name(chan));
2471                                                 t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters);
2472                                                 details->caps &= ~AST_FAX_TECH_AUDIO;
2473                                                 report_fax_status(chan, details, "T.38 Negotiated");
2474                                                 break_loop = 1;
2475                                                 break;
2476                                         default:
2477                                                 break;
2478                                         }
2479                                 }
2480                                 ast_frfree(frame);
2481                                 if (break_loop) {
2482                                         break;
2483                                 }
2484                         }
2485
2486                         ast_playtones_stop(chan);
2487
2488                         /* if T.38 was negotiated, we are done initializing */
2489                         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2490                                 return 0;
2491                         }
2492                 }
2493         }
2494
2495         /* if we made it here, then T.38 failed, check the 'f' flag */
2496         if (details->option.allow_audio == AST_FAX_OPTFLAG_FALSE) {
2497                 ast_log(LOG_WARNING, "Audio FAX not allowed on channel '%s' and T.38 negotiation failed; aborting.\n", ast_channel_name(chan));
2498                 return -1;
2499         }
2500
2501         /* ok, audio fallback is allowed */
2502         details->caps |= AST_FAX_TECH_AUDIO;
2503
2504         return 0;
2505 }
2506
2507 /*!
2508  * \brief Report on the status of a completed fax send attempt
2509  * \note This will lock the \ref ast_channel
2510  */
2511 static int report_send_fax_status(struct ast_channel *chan, struct ast_fax_session_details *details)
2512 {
2513         RAII_VAR(struct ast_json *, json_obj, NULL, ast_json_unref);
2514         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
2515         struct ast_json *json_filenames;
2516
2517         json_filenames = generate_filenames_json(details);
2518         if (!json_filenames) {
2519                 return -1;
2520         }
2521
2522         {
2523                 const char *remote_station_id;
2524                 const char *local_station_id;
2525                 const char *fax_pages;
2526                 const char *fax_resolution;
2527                 const char *fax_bitrate;
2528                 SCOPED_CHANNELLOCK(lock, chan);
2529
2530                 remote_station_id = S_OR(pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), "");
2531                 if (!ast_strlen_zero(remote_station_id)) {
2532                         remote_station_id = ast_strdupa(remote_station_id);
2533                 }
2534                 local_station_id = S_OR(pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), "");
2535                 if (!ast_strlen_zero(local_station_id)) {
2536                         local_station_id = ast_strdupa(local_station_id);
2537                 }
2538                 fax_pages = S_OR(pbx_builtin_getvar_helper(chan, "FAXPAGES"), "");
2539                 if (!ast_strlen_zero(fax_pages)) {
2540                         fax_pages = ast_strdupa(fax_pages);
2541                 }
2542                 fax_resolution = S_OR(pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), "");
2543                 if (!ast_strlen_zero(fax_resolution)) {
2544                         fax_resolution = ast_strdupa(fax_resolution);
2545                 }
2546                 fax_bitrate = S_OR(pbx_builtin_getvar_helper(chan, "FAXBITRATE"), "");
2547                 if (!ast_strlen_zero(fax_bitrate)) {
2548                         fax_bitrate = ast_strdupa(fax_bitrate);
2549                 }
2550                 json_obj = ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: s, s: o}",
2551                                 "type", "send",
2552                                 "remote_station_id", S_OR(remote_station_id, ""),
2553                                 "local_station_id", S_OR(local_station_id, ""),
2554                                 "fax_pages", S_OR(fax_pages, ""),
2555                                 "fax_resolution", S_OR(fax_resolution, ""),
2556                                 "fax_bitrate", S_OR(fax_bitrate, ""),
2557                                 "filenames", json_filenames);
2558                 if (!json_obj) {
2559                         return -1;
2560                 }
2561
2562                 message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan), ast_channel_fax_type(), json_obj);
2563                 if (!message) {
2564                         return -1;
2565                 }
2566                 stasis_publish(ast_channel_topic(chan), message);
2567         }
2568         return 0;
2569 }
2570
2571
2572
2573 /*! \brief initiate a send FAX session */
2574 static int sendfax_exec(struct ast_channel *chan, const char *data)
2575 {
2576         char *parse, *filenames, *c, modems[128] = "";
2577         int channel_alive, file_count;
2578         RAII_VAR(struct ast_fax_session_details *, details, NULL, ao2_cleanup);
2579         RAII_VAR(struct ast_fax_session *, s, NULL, ao2_cleanup);
2580         struct ast_fax_tech_token *token = NULL;
2581         struct ast_fax_document *doc;
2582         AST_DECLARE_APP_ARGS(args,
2583                 AST_APP_ARG(filenames);
2584                 AST_APP_ARG(options);
2585         );
2586         struct ast_flags opts = { 0, };
2587         enum ast_t38_state t38state;
2588
2589         /* initialize output channel variables */
2590         pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED");
2591         pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL);
2592         pbx_builtin_setvar_helper(chan, "FAXPAGES", "0");
2593         pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL);
2594         pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL);
2595
2596         /* Get a requirement structure and set it.  This structure is used
2597          * to tell the FAX technology module about the higher level FAX session */
2598         if (!(details = find_or_create_details(chan))) {
2599                 pbx_builtin_setvar_helper(chan, "FAXERROR", "MEMORY_ERROR");
2600                 pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "error allocating memory");
2601                 ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2602                 return -1;
2603         }
2604
2605         ast_string_field_set(details, result, "FAILED");
2606         ast_string_field_set(details, resultstr, "error starting fax session");
2607         ast_string_field_set(details, error, "INIT_ERROR");
2608         set_channel_variables(chan, details);
2609
2610         if (details->gateway_id > 0) {
2611                 ast_string_field_set(details, resultstr, "can't send a fax on a channel with a T.38 gateway");
2612                 set_channel_variables(chan, details);
2613                 ast_log(LOG_ERROR, "executing SendFAX on a channel with a T.38 Gateway is not supported\n");
2614                 return -1;
2615         }
2616
2617         if (details->maxrate < details->minrate) {
2618                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2619                 ast_string_field_set(details, resultstr, "maxrate is less than minrate");
2620                 set_channel_variables(chan, details);
2621                 ast_log(LOG_ERROR, "maxrate %u is less than minrate %u\n", details->maxrate, details->minrate);
2622                 return -1;
2623         }
2624
2625         if (check_modem_rate(details->modems, details->minrate)) {
2626                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2627                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'minrate' setting %u\n", modems, details->minrate);
2628                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2629                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'minrate' settings");
2630                 set_channel_variables(chan, details);
2631                 return -1;
2632         }
2633
2634         if (check_modem_rate(details->modems, details->maxrate)) {
2635                 ast_fax_modem_to_str(details->modems, modems, sizeof(modems));
2636                 ast_log(LOG_ERROR, "'modems' setting '%s' is incompatible with 'maxrate' setting %u\n", modems, details->maxrate);
2637                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2638                 ast_string_field_set(details, resultstr, "incompatible 'modems' and 'maxrate' settings");
2639                 set_channel_variables(chan, details);
2640                 return -1;
2641         }
2642
2643         if (ast_strlen_zero(data)) {
2644                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2645                 ast_string_field_set(details, resultstr, "invalid arguments");
2646                 set_channel_variables(chan, details);
2647                 ast_log(LOG_WARNING, "%s requires an argument (filename[&filename[&filename]][,options])\n", app_sendfax);
2648                 return -1;
2649         }
2650         parse = ast_strdupa(data);
2651         AST_STANDARD_APP_ARGS(args, parse);
2652
2653
2654         if (!ast_strlen_zero(args.options) &&
2655                 ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) {
2656                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2657                 ast_string_field_set(details, resultstr, "invalid arguments");
2658                 set_channel_variables(chan, details);
2659                 return -1;
2660         }
2661         if (ast_strlen_zero(args.filenames)) {
2662                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2663                 ast_string_field_set(details, resultstr, "invalid arguments");
2664                 set_channel_variables(chan, details);
2665                 ast_log(LOG_WARNING, "%s requires an argument (filename[&filename[&filename]],options])\n", app_sendfax);
2666                 return -1;
2667         }
2668
2669         /* check for unsupported FAX application options */
2670         if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) {
2671                 ast_string_field_set(details, error, "INVALID_ARGUMENTS");
2672                 ast_string_field_set(details, resultstr, "invalid arguments");
2673                 set_channel_variables(chan, details);
2674                 ast_log(LOG_WARNING, "%s does not support polling\n", app_sendfax);
2675                 return -1;
2676         }
2677
2678         ast_atomic_fetchadd_int(&faxregistry.fax_tx_attempts, 1);
2679
2680         file_count = 0;
2681         filenames = args.filenames;
2682         while ((c = strsep(&filenames, "&"))) {
2683                 if (access(c, (F_OK | R_OK)) < 0) {
2684                         ast_string_field_set(details, error, "FILE_ERROR");
2685                         ast_string_field_set(details, resultstr, "error reading file");
2686                         set_channel_variables(chan, details);
2687                         ast_log(LOG_ERROR, "access failure.  Verify '%s' exists and check permissions.\n", args.filenames);
2688                         return -1;
2689                 }
2690
2691                 if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(c) + 1))) {
2692                         ast_string_field_set(details, error, "MEMORY_ERROR");
2693                         ast_string_field_set(details, resultstr, "error allocating memory");
2694                         set_channel_variables(chan, details);
2695                         ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n");
2696                         return -1;
2697                 }
2698
2699                 strcpy(doc->filename, c);
2700                 AST_LIST_INSERT_TAIL(&details->documents, doc, next);
2701                 file_count++;
2702         }
2703
2704         ast_verb(3, "Channel '%s' sending FAX:\n", ast_channel_name(chan));
2705         AST_LIST_TRAVERSE(&details->documents, doc, next) {
2706                 ast_verb(3, "   %s\n", doc->filename);
2707         }
2708
2709         details->caps = AST_FAX_TECH_SEND;
2710
2711         if (file_count > 1) {
2712                 details->caps |= AST_FAX_TECH_MULTI_DOC;
2713         }
2714
2715         /* check for debug */
2716         if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) {
2717                 details->option.debug = AST_FAX_OPTFLAG_TRUE;
2718         }
2719
2720         /* check for request for status events */
2721         if (ast_test_flag(&opts, OPT_STATUS)) {
2722                 details->option.statusevents = AST_FAX_OPTFLAG_TRUE;
2723         }
2724
2725         t38state = ast_channel_get_t38_state(chan);
2726         if ((t38state == T38_STATE_UNAVAILABLE) || (t38state == T38_STATE_REJECTED) ||
2727             ast_test_flag(&opts, OPT_ALLOWAUDIO) ||
2728             ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2729                 details->option.allow_audio = AST_FAX_OPTFLAG_TRUE;
2730         }
2731
2732         if (ast_test_flag(&opts, OPT_REQUEST_T38)) {
2733                 details->option.request_t38 = AST_FAX_OPTFLAG_TRUE;
2734         }
2735
2736         if (!(s = fax_session_reserve(details, &token))) {
2737                 ast_string_field_set(details, resultstr, "error reserving fax session");
2738                 set_channel_variables(chan, details);
2739                 ast_log(LOG_ERROR, "Unable to reserve FAX session.\n");
2740                 return -1;
2741         }
2742
2743         /* make sure the channel is up */
2744         if (ast_channel_state(chan) != AST_STATE_UP) {
2745                 if (ast_answer(chan)) {
2746                         ast_string_field_set(details, resultstr, "error answering channel");
2747                         set_channel_variables(chan, details);
2748                         ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", ast_channel_name(chan));
2749                         fax_session_release(s, token);
2750                         return -1;
2751                 }
2752         }
2753
2754         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO)) {
2755                 if (set_fax_t38_caps(chan, details)) {
2756                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2757                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2758                         set_channel_variables(chan, details);
2759                         fax_session_release(s, token);
2760                         return -1;
2761                 }
2762         } else {
2763                 details->caps |= AST_FAX_TECH_AUDIO;
2764         }
2765
2766         if (!ast_test_flag(&opts, OPT_FORCE_AUDIO) && (details->caps & AST_FAX_TECH_T38)) {
2767                 if (sendfax_t38_init(chan, details)) {
2768                         ast_string_field_set(details, error, "T38_NEG_ERROR");
2769                         ast_string_field_set(details, resultstr, "error negotiating T.38");
2770                         set_channel_variables(chan, details);
2771                         fax_session_release(s, token);
2772                         ast_log(LOG_ERROR, "error initializing channel '%s' in T.38 mode\n", ast_channel_name(chan));
2773                         return -1;
2774                 }
2775         } else {
2776                 details->option.send_cng = 1;
2777         }
2778
2779         if ((channel_alive = generic_fax_exec(chan, details, s, token)) < 0) {
2780                 ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1);
2781         }
2782
2783         if (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED) {
2784                 if (disable_t38(chan)) {
2785                         ast_debug(1, "error disabling T.38 mode on %s\n", ast_channel_name(chan));
2786                 }
2787         }
2788
2789         if (!(filenames = generate_filenames_string(details, "FileName: ", "\r\n"))) {
2790                 ast_log(LOG_ERROR, "Error generating SendFAX manager event\n");
2791                 return (!channel_alive) ? -1 : 0;
2792         }
2793
2794         /* send out the AMI completion event */
2795         if (report_send_fax_status(chan, details)) {
2796                 ast_log(AST_LOG_ERROR, "Error publishing SendFAX status message\n");
2797         }
2798
2799         /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */
2800         return (!channel_alive) ? -1 : 0;
2801 }
2802
2803 /*! \brief destroy the v21 detection parts of a fax gateway session */
2804 static void destroy_v21_sessions(struct fax_gateway *gateway)
2805 {
2806         if (gateway->chan_v21_session) {
2807                 ao2_lock(faxregistry.container);
2808                 ao2_unlink(faxregistry.container, gateway->chan_v21_session);
2809                 ao2_unlock(faxregistry.container);
2810
2811                 ao2_ref(gateway->chan_v21_session, -1);
2812                 gateway->chan_v21_session = NULL;
2813         }
2814
2815         if (gateway->peer_v21_session) {
2816                 ao2_lock(faxregistry.container);
2817                 ao2_unlink(faxregistry.container, gateway->peer_v21_session);
2818                 ao2_unlock(faxregistry.container);
2819
2820                 ao2_ref(gateway->peer_v21_session, -1);
2821                 gateway->peer_v21_session = NULL;
2822         }
2823 }
2824
2825 /*! \brief destroy a FAX gateway session structure */
2826 static void destroy_gateway(void *data)
2827 {
2828         struct fax_gateway *gateway = data;
2829
2830         destroy_v21_sessions(gateway);
2831
2832         if (gateway->s) {
2833                 fax_session_release(gateway->s, gateway->token);
2834                 gateway->token = NULL;
2835
2836                 ao2_lock(faxregistry.container);
2837                 ao2_unlink(faxregistry.container, gateway->s);
2838                 ao2_unlock(faxregistry.container);
2839
2840                 ao2_ref(gateway->s, -1);
2841                 gateway->s = NULL;
2842         }
2843
2844         ao2_cleanup(gateway->chan_read_format);
2845         ao2_cleanup(gateway->chan_write_format);
2846         ao2_cleanup(gateway->peer_read_format);
2847         ao2_cleanup(gateway->peer_write_format);
2848 }
2849
2850 /*! \brief Create a new fax gateway object.
2851  * \param chan the channel the gateway object will be attached to
2852  * \param details the fax session details
2853  * \return NULL or a fax gateway object
2854  */
2855 static struct fax_gateway *fax_gateway_new(struct ast_channel *chan, struct ast_fax_session_details *details)
2856 {
2857         struct fax_gateway *gateway = ao2_alloc(sizeof(*gateway), destroy_gateway);
2858         struct ast_fax_session_details *v21_details;
2859         if (!gateway) {
2860                 return NULL;
2861         }
2862
2863         if (!(v21_details = session_details_new())) {
2864                 ao2_ref(gateway, -1);
2865                 return NULL;
2866         }
2867
2868         v21_details->caps = AST_FAX_TECH_V21_DETECT;
2869         if (!(gateway->chan_v21_session = fax_session_new(v21_details, chan, NULL, NULL))) {
2870                 ao2_ref(v21_details, -1);
2871                 ao2_ref(gateway, -1);
2872                 return NULL;
2873         }
2874
2875         if (!(gateway->peer_v21_session = fax_session_new(v21_details, chan, NULL, NULL))) {
2876                 ao2_ref(v21_details, -1);
2877                 ao2_ref(gateway, -1);
2878                 return NULL;
2879         }
2880         ao2_ref(v21_details, -1);
2881
2882         gateway->framehook = -1;
2883
2884         details->caps = AST_FAX_TECH_GATEWAY;
2885         if (details->gateway_timeout && !(gateway->s = fax_session_reserve(details, &gateway->token))) {
2886                 details->caps &= ~AST_FAX_TECH_GATEWAY;
2887                 ast_log(LOG_ERROR, "Can't reserve a FAX session, gateway attempt failed.\n");
2888                 ao2_ref(gateway, -1);
2889                 return NULL;
2890         }
2891
2892         return gateway;
2893 }
2894
2895 /*! \brief Create a fax session and start T.30<->T.38 gateway mode
2896  * \param gateway a fax gateway object
2897  * \param details fax session details
2898  * \param chan active channel
2899  * \return 0 on error 1 on success*/
2900 static int fax_gateway_start(struct fax_gateway *gateway, struct ast_fax_session_details *details, struct ast_channel *chan)
2901 {
2902         struct ast_fax_session *s;
2903
2904         /* create the FAX session */
2905         if (!(s = fax_session_new(details, chan, gateway->s, gateway->token))) {
2906                 gateway->token = NULL;
2907                 ast_string_field_set(details, result, "FAILED");
2908                 ast_string_field_set(details, resultstr, "error starting gateway session");
2909                 ast_string_field_set(details, error, "INIT_ERROR");
2910                 set_channel_variables(chan, details);
2911                 report_fax_status(chan, details, "No Available Resource");
2912                 ast_log(LOG_ERROR, "Can't create a FAX session, gateway attempt failed.\n");
2913                 return -1;
2914         }
2915         /* release the reference for the reserved session and replace it with
2916          * the real session */
2917         if (gateway->s) {
2918                 ao2_ref(gateway->s, -1);
2919         }
2920         gateway->s = s;
2921         gateway->token = NULL;
2922
2923         if (gateway->s->tech->start_session(gateway->s) < 0) {
2924                 ast_string_field_set(details, result, "FAILED");
2925                 ast_string_field_set(details, resultstr, "error starting gateway session");
2926                 ast_string_field_set(details, error, "INIT_ERROR");
2927                 set_channel_variables(chan, details);
2928                 return -1;
2929         }
2930
2931         gateway->timeout_start.tv_sec = 0;
2932         gateway->timeout_start.tv_usec = 0;
2933
2934         report_fax_status(chan, details, "FAX Transmission In Progress");
2935
2936         return 0;
2937 }
2938
2939 static struct ast_frame *fax_gateway_request_t38(struct fax_gateway *gateway, struct ast_channel *chan, struct ast_frame *f)
2940 {
2941         struct ast_frame *fp;
2942         struct ast_control_t38_parameters t38_parameters = {
2943                 .request_response = AST_T38_REQUEST_NEGOTIATE,
2944         };
2945         struct ast_frame control_frame = {
2946                 .src = "res_fax",
2947                 .frametype = AST_FRAME_CONTROL,
2948                 .datalen = sizeof(t38_parameters),
2949                 .subclass.integer = AST_CONTROL_T38_PARAMETERS,
2950                 .data.ptr = &t38_parameters,
2951         };
2952
2953         struct ast_fax_session_details *details = find_details(chan);
2954
2955         if (!details) {
2956                 ast_log(LOG_ERROR, "no FAX session details found on chan %s for T.38 gateway session, odd\n", ast_channel_name(chan));
2957                 ast_framehook_detach(chan, gateway->framehook);
2958                 return f;
2959         }
2960
2961         t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters);
2962         ao2_ref(details, -1);
2963
2964         if (!(fp = ast_frisolate(&control_frame))) {
2965                 ast_log(LOG_ERROR, "error generating T.38 request control frame on chan %s for T.38 gateway session\n", ast_channel_name(chan));
2966                 return f;
2967         }
2968
2969         gateway->t38_state = T38_STATE_NEGOTIATING;
2970         gateway->timeout_start = ast_tvnow();
2971         details->gateway_timeout = FAX_GATEWAY_TIMEOUT;
2972
2973         ast_debug(1, "requesting T.38 for gateway session for %s\n", ast_channel_name(chan));
2974         return fp;
2975 }
2976
2977 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)
2978 {
2979         struct ast_channel *other = (active == chan) ? peer : chan;
2980         struct ast_fax_session *active_v21_session = (active == chan) ? gateway->chan_v21_session : gateway->peer_v21_session;
2981
2982         if (!active_v21_session || gateway->detected_v21) {
2983                 return f;
2984         }
2985
2986         if (active_v21_session->tech->write(active_v21_session, f) == 0 &&
2987             active_v21_session->details->option.v21_detected) {
2988                 gateway->detected_v21 = 1;
2989         }
2990
2991         if (gateway->detected_v21) {
2992                 destroy_v21_sessions(gateway);
2993                 if (ast_channel_get_t38_state(other) == T38_STATE_UNKNOWN) {
2994