e3f5c81ff1f9dcae1a4538c9631d1ead6da3f55c
[asterisk/asterisk.git] / channels / chan_dahdi.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2008, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief DAHDI for Pseudo TDM
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * Connects to the DAHDI telephony library as well as
26  * libpri. Libpri is optional and needed only if you are
27  * going to use ISDN connections.
28  *
29  * You need to install libraries before you attempt to compile
30  * and install the DAHDI channel.
31  *
32  * \ingroup channel_drivers
33  *
34  * \todo Deprecate the "musiconhold" configuration option post 1.4
35  */
36
37 /*! \li \ref chan_dahdi.c uses the configuration file \ref chan_dahdi.conf
38  * \addtogroup configuration_file
39  */
40
41 /*! \page chan_dahdi.conf chan_dahdi.conf
42  * \verbinclude chan_dahdi.conf.sample
43  */
44
45 /*** MODULEINFO
46         <use type="module">res_smdi</use>
47         <depend>dahdi</depend>
48         <depend>tonezone</depend>
49         <use type="external">pri</use>
50         <use type="external">ss7</use>
51         <use type="external">openr2</use>
52         <support_level>core</support_level>
53  ***/
54
55 #include "asterisk.h"
56
57 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
58
59 #if defined(__NetBSD__) || defined(__FreeBSD__)
60 #include <pthread.h>
61 #include <signal.h>
62 #else
63 #include <sys/signal.h>
64 #endif
65 #include <sys/stat.h>
66 #include <math.h>
67
68 #include "sig_analog.h"
69 /* Analog signaling is currently still present in chan_dahdi for use with
70  * radio. Sig_analog does not currently handle any radio operations. If
71  * radio only uses analog signaling, then the radio handling logic could
72  * be placed in sig_analog and the duplicated code could be removed.
73  */
74
75 #if defined(HAVE_PRI)
76 #include "sig_pri.h"
77 #ifndef PRI_RESTART
78 #error "Upgrade your libpri"
79 #endif
80 #endif  /* defined(HAVE_PRI) */
81
82 #if defined(HAVE_SS7)
83 #include "sig_ss7.h"
84 #if !defined(LIBSS7_ABI_COMPATIBILITY)
85 #error "Upgrade your libss7"
86 #elif LIBSS7_ABI_COMPATIBILITY != 2
87 #error "Your installed libss7 is not compatible"
88 #endif
89 #endif  /* defined(HAVE_SS7) */
90
91 #if defined(HAVE_OPENR2)
92 /* put this here until sig_mfcr2 comes along */
93 #define SIG_MFCR2_MAX_CHANNELS  672             /*!< No more than a DS3 per trunk group */
94 #endif  /* defined(HAVE_OPENR2) */
95
96 #include "asterisk/lock.h"
97 #include "asterisk/channel.h"
98 #include "asterisk/config.h"
99 #include "asterisk/module.h"
100 #include "asterisk/pbx.h"
101 #include "asterisk/file.h"
102 #include "asterisk/ulaw.h"
103 #include "asterisk/alaw.h"
104 #include "asterisk/callerid.h"
105 #include "asterisk/adsi.h"
106 #include "asterisk/cli.h"
107 #include "asterisk/pickup.h"
108 #include "asterisk/features.h"
109 #include "asterisk/musiconhold.h"
110 #include "asterisk/say.h"
111 #include "asterisk/tdd.h"
112 #include "asterisk/app.h"
113 #include "asterisk/dsp.h"
114 #include "asterisk/astdb.h"
115 #include "asterisk/manager.h"
116 #include "asterisk/causes.h"
117 #include "asterisk/term.h"
118 #include "asterisk/utils.h"
119 #include "asterisk/transcap.h"
120 #include "asterisk/stringfields.h"
121 #include "asterisk/abstract_jb.h"
122 #include "asterisk/smdi.h"
123 #include "asterisk/devicestate.h"
124 #include "asterisk/paths.h"
125 #include "asterisk/ccss.h"
126 #include "asterisk/data.h"
127 #include "asterisk/features_config.h"
128 #include "asterisk/bridge.h"
129 #include "asterisk/stasis_channels.h"
130 #include "asterisk/parking.h"
131 #include "asterisk/format_cache.h"
132 #include "chan_dahdi.h"
133 #include "dahdi/bridge_native_dahdi.h"
134
135 /*** DOCUMENTATION
136         <application name="DAHDISendKeypadFacility" language="en_US">
137                 <synopsis>
138                         Send digits out of band over a PRI.
139                 </synopsis>
140                 <syntax>
141                         <parameter name="digits" required="true" />
142                 </syntax>
143                 <description>
144                         <para>This application will send the given string of digits in a Keypad
145                         Facility IE over the current channel.</para>
146                 </description>
147         </application>
148         <application name="DAHDISendCallreroutingFacility" language="en_US">
149                 <synopsis>
150                         Send an ISDN call rerouting/deflection facility message.
151                 </synopsis>
152                 <syntax argsep=",">
153                         <parameter name="destination" required="true">
154                                 <para>Destination number.</para>
155                         </parameter>
156                         <parameter name="original">
157                                 <para>Original called number.</para>
158                         </parameter>
159                         <parameter name="reason">
160                                 <para>Diversion reason, if not specified defaults to <literal>unknown</literal></para>
161                         </parameter>
162                 </syntax>
163                 <description>
164                         <para>This application will send an ISDN switch specific call
165                         rerouting/deflection facility message over the current channel.
166                         Supported switches depend upon the version of libpri in use.</para>
167                 </description>
168         </application>
169         <application name="DAHDIAcceptR2Call" language="en_US">
170                 <synopsis>
171                         Accept an R2 call if its not already accepted (you still need to answer it)
172                 </synopsis>
173                 <syntax>
174                         <parameter name="charge" required="true">
175                                 <para>Yes or No.</para>
176                                 <para>Whether you want to accept the call with charge or without charge.</para>
177                         </parameter>
178                 </syntax>
179                 <description>
180                         <para>This application will Accept the R2 call either with charge or no charge.</para>
181                 </description>
182         </application>
183         <manager name="DAHDITransfer" language="en_US">
184                 <synopsis>
185                         Transfer DAHDI Channel.
186                 </synopsis>
187                 <syntax>
188                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
189                         <parameter name="DAHDIChannel" required="true">
190                                 <para>DAHDI channel number to transfer.</para>
191                         </parameter>
192                 </syntax>
193                 <description>
194                         <para>Simulate a flash hook event by the user connected to the channel.</para>
195                         <note><para>Valid only for analog channels.</para></note>
196                 </description>
197         </manager>
198         <manager name="DAHDIHangup" language="en_US">
199                 <synopsis>
200                         Hangup DAHDI Channel.
201                 </synopsis>
202                 <syntax>
203                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
204                         <parameter name="DAHDIChannel" required="true">
205                                 <para>DAHDI channel number to hangup.</para>
206                         </parameter>
207                 </syntax>
208                 <description>
209                         <para>Simulate an on-hook event by the user connected to the channel.</para>
210                         <note><para>Valid only for analog channels.</para></note>
211                 </description>
212         </manager>
213         <manager name="DAHDIDialOffhook" language="en_US">
214                 <synopsis>
215                         Dial over DAHDI channel while offhook.
216                 </synopsis>
217                 <syntax>
218                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
219                         <parameter name="DAHDIChannel" required="true">
220                                 <para>DAHDI channel number to dial digits.</para>
221                         </parameter>
222                         <parameter name="Number" required="true">
223                                 <para>Digits to dial.</para>
224                         </parameter>
225                 </syntax>
226                 <description>
227                         <para>Generate DTMF control frames to the bridged peer.</para>
228                 </description>
229         </manager>
230         <manager name="DAHDIDNDon" language="en_US">
231                 <synopsis>
232                         Toggle DAHDI channel Do Not Disturb status ON.
233                 </synopsis>
234                 <syntax>
235                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
236                         <parameter name="DAHDIChannel" required="true">
237                                 <para>DAHDI channel number to set DND on.</para>
238                         </parameter>
239                 </syntax>
240                 <description>
241                         <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> on".</para>
242                         <note><para>Feature only supported by analog channels.</para></note>
243                 </description>
244         </manager>
245         <manager name="DAHDIDNDoff" language="en_US">
246                 <synopsis>
247                         Toggle DAHDI channel Do Not Disturb status OFF.
248                 </synopsis>
249                 <syntax>
250                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
251                         <parameter name="DAHDIChannel" required="true">
252                                 <para>DAHDI channel number to set DND off.</para>
253                         </parameter>
254                 </syntax>
255                 <description>
256                         <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> off".</para>
257                         <note><para>Feature only supported by analog channels.</para></note>
258                 </description>
259         </manager>
260         <manager name="DAHDIShowChannels" language="en_US">
261                 <synopsis>
262                         Show status of DAHDI channels.
263                 </synopsis>
264                 <syntax>
265                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
266                         <parameter name="DAHDIChannel">
267                                 <para>Specify the specific channel number to show.  Show all channels if zero or not present.</para>
268                         </parameter>
269                 </syntax>
270                 <description>
271                         <para>Similar to the CLI command "dahdi show channels".</para>
272                 </description>
273         </manager>
274         <manager name="DAHDIRestart" language="en_US">
275                 <synopsis>
276                         Fully Restart DAHDI channels (terminates calls).
277                 </synopsis>
278                 <syntax>
279                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
280                 </syntax>
281                 <description>
282                         <para>Equivalent to the CLI command "dahdi restart".</para>
283                 </description>
284         </manager>
285         <manager name="PRIShowSpans" language="en_US">
286                 <synopsis>
287                         Show status of PRI spans.
288                 </synopsis>
289                 <syntax>
290                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
291                         <parameter name="Span">
292                                 <para>Specify the specific span to show.  Show all spans if zero or not present.</para>
293                         </parameter>
294                 </syntax>
295                 <description>
296                         <para>Similar to the CLI command "pri show spans".</para>
297                 </description>
298         </manager>
299         <manager name="PRIDebugSet" language="en_US">
300                 <synopsis>
301                         Set PRI debug levels for a span
302                 </synopsis>
303                 <syntax>
304                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
305                         <parameter name="Span" required="true">
306                                 <para>Which span to affect.</para>
307                         </parameter>
308                         <parameter name="Level" required="true">
309                                 <para>What debug level to set. May be a numerical value or a text value from the list below</para>
310                                 <enumlist>
311                                         <enum name="off" />
312                                         <enum name="on" />
313                                         <enum name="hex" />
314                                         <enum name="intense" />
315                                 </enumlist>
316                         </parameter>
317                 </syntax>
318                 <description>
319                         <para>Equivalent to the CLI command "pri set debug &lt;level&gt; span &lt;span&gt;".</para>
320                 </description>
321         </manager>
322         <manager name="PRIDebugFileSet" language="en_US">
323                 <synopsis>
324                         Set the file used for PRI debug message output
325                 </synopsis>
326                 <syntax>
327                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
328                         <parameter name="File" required="true">
329                                 <para>Path of file to write debug output.</para>
330                         </parameter>
331                 </syntax>
332                 <description>
333                         <para>Equivalent to the CLI command "pri set debug file &lt;output-file&gt;"</para>
334                 </description>
335         </manager>
336         <manager name="PRIDebugFileUnset" language="en_US">
337                 <synopsis>
338                         Disables file output for PRI debug messages
339                 </synopsis>
340                 <syntax>
341                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
342                 </syntax>
343         </manager>
344         <managerEvent language="en_US" name="AlarmClear">
345                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
346                         <synopsis>Raised when an alarm is cleared on a DAHDI channel.</synopsis>
347                         <syntax>
348                                 <parameter name="DAHDIChannel">
349                                         <para>The DAHDI channel on which the alarm was cleared.</para>
350                                         <note><para>This is not an Asterisk channel identifier.</para></note>
351                                 </parameter>
352                         </syntax>
353                 </managerEventInstance>
354         </managerEvent>
355         <managerEvent language="en_US" name="SpanAlarmClear">
356                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
357                         <synopsis>Raised when an alarm is cleared on a DAHDI span.</synopsis>
358                         <syntax>
359                                 <parameter name="Span">
360                                         <para>The span on which the alarm was cleared.</para>
361                                 </parameter>
362                         </syntax>
363                 </managerEventInstance>
364         </managerEvent>
365         <managerEvent language="en_US" name="DNDState">
366                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
367                         <synopsis>Raised when the Do Not Disturb state is changed on a DAHDI channel.</synopsis>
368                         <syntax>
369                                 <parameter name="DAHDIChannel">
370                                         <para>The DAHDI channel on which DND status changed.</para>
371                                         <note><para>This is not an Asterisk channel identifier.</para></note>
372                                 </parameter>
373                                 <parameter name="Status">
374                                         <enumlist>
375                                                 <enum name="enabled"/>
376                                                 <enum name="disabled"/>
377                                         </enumlist>
378                                 </parameter>
379                         </syntax>
380                 </managerEventInstance>
381         </managerEvent>
382         <managerEvent language="en_US" name="Alarm">
383                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
384                         <synopsis>Raised when an alarm is set on a DAHDI channel.</synopsis>
385                         <syntax>
386                                 <parameter name="DAHDIChannel">
387                                         <para>The channel on which the alarm occurred.</para>
388                                         <note><para>This is not an Asterisk channel identifier.</para></note>
389                                 </parameter>
390                                 <parameter name="Alarm">
391                                         <para>A textual description of the alarm that occurred.</para>
392                                 </parameter>
393                         </syntax>
394                 </managerEventInstance>
395         </managerEvent>
396         <managerEvent language="en_US" name="SpanAlarm">
397                 <managerEventInstance class="EVENT_FLAG_SYSTEM">
398                         <synopsis>Raised when an alarm is set on a DAHDI span.</synopsis>
399                         <syntax>
400                                 <parameter name="Span">
401                                         <para>The span on which the alarm occurred.</para>
402                                 </parameter>
403                                 <parameter name="Alarm">
404                                         <para>A textual description of the alarm that occurred.</para>
405                                 </parameter>
406                         </syntax>
407                 </managerEventInstance>
408         </managerEvent>
409         <managerEvent language="en_US" name="DAHDIChannel">
410                 <managerEventInstance class="EVENT_FLAG_CALL">
411                         <synopsis>Raised when a DAHDI channel is created or an underlying technology is associated with a DAHDI channel.</synopsis>
412                         <syntax>
413                                 <channel_snapshot/>
414                                 <parameter name="DAHDISpan">
415                                         <para>The DAHDI span associated with this channel.</para>
416                                 </parameter>
417                                 <parameter name="DAHDIChannel">
418                                         <para>The DAHDI channel associated with this channel.</para>
419                                 </parameter>
420                         </syntax>
421                 </managerEventInstance>
422         </managerEvent>
423  ***/
424
425 #define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */
426
427 static const char * const lbostr[] = {
428 "0 db (CSU)/0-133 feet (DSX-1)",
429 "133-266 feet (DSX-1)",
430 "266-399 feet (DSX-1)",
431 "399-533 feet (DSX-1)",
432 "533-655 feet (DSX-1)",
433 "-7.5db (CSU)",
434 "-15db (CSU)",
435 "-22.5db (CSU)"
436 };
437
438 /*! Global jitterbuffer configuration - by default, jb is disabled
439  *  \note Values shown here match the defaults shown in chan_dahdi.conf.sample */
440 static struct ast_jb_conf default_jbconf =
441 {
442         .flags = 0,
443         .max_size = 200,
444         .resync_threshold = 1000,
445         .impl = "fixed",
446         .target_extra = 40,
447 };
448 static struct ast_jb_conf global_jbconf;
449
450 /*!
451  * \note Define ZHONE_HACK to cause us to go off hook and then back on hook when
452  * the user hangs up to reset the state machine so ring works properly.
453  * This is used to be able to support kewlstart by putting the zhone in
454  * groundstart mode since their forward disconnect supervision is entirely
455  * broken even though their documentation says it isn't and their support
456  * is entirely unwilling to provide any assistance with their channel banks
457  * even though their web site says they support their products for life.
458  */
459 /* #define ZHONE_HACK */
460
461 /*! \brief Typically, how many rings before we should send Caller*ID */
462 #define DEFAULT_CIDRINGS 1
463
464 #define AST_LAW(p) (((p)->law == DAHDI_LAW_ALAW) ? ast_format_alaw : ast_format_ulaw)
465
466
467 /*! \brief Signaling types that need to use MF detection should be placed in this macro */
468 #define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
469
470 static const char tdesc[] = "DAHDI Telephony"
471 #if defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2)
472         " w/"
473         #if defined(HAVE_PRI)
474                 "PRI"
475         #endif  /* defined(HAVE_PRI) */
476         #if defined(HAVE_SS7)
477                 #if defined(HAVE_PRI)
478                 " & "
479                 #endif  /* defined(HAVE_PRI) */
480                 "SS7"
481         #endif  /* defined(HAVE_SS7) */
482         #if defined(HAVE_OPENR2)
483                 #if defined(HAVE_PRI) || defined(HAVE_SS7)
484                 " & "
485                 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
486                 "MFC/R2"
487         #endif  /* defined(HAVE_OPENR2) */
488 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2) */
489 ;
490
491 static const char config[] = "chan_dahdi.conf";
492
493 #ifdef LOTS_OF_SPANS
494 #define NUM_SPANS       DAHDI_MAX_SPANS
495 #else
496 #define NUM_SPANS               32
497 #endif
498
499 #define CHAN_PSEUDO     -2
500
501 #define CALLPROGRESS_PROGRESS           1
502 #define CALLPROGRESS_FAX_OUTGOING       2
503 #define CALLPROGRESS_FAX_INCOMING       4
504 #define CALLPROGRESS_FAX                (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)
505
506 #define NUM_CADENCE_MAX 25
507 static int num_cadence = 4;
508 static int user_has_defined_cadences = 0;
509
510 static int has_pseudo;
511
512 static struct dahdi_ring_cadence cadences[NUM_CADENCE_MAX] = {
513         { { 125, 125, 2000, 4000 } },                   /*!< Quick chirp followed by normal ring */
514         { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /*!< British style ring */
515         { { 125, 125, 125, 125, 125, 4000 } },  /*!< Three short bursts */
516         { { 1000, 500, 2500, 5000 } },  /*!< Long ring */
517 };
518
519 /*! \brief cidrings says in which pause to transmit the cid information, where the first pause
520  * is 1, the second pause is 2 and so on.
521  */
522
523 static int cidrings[NUM_CADENCE_MAX] = {
524         2,                                                                              /*!< Right after first long ring */
525         4,                                                                              /*!< Right after long part */
526         3,                                                                              /*!< After third chirp */
527         2,                                                                              /*!< Second spell */
528 };
529
530 /* ETSI EN300 659-1 specifies the ring pulse between 200 and 300 mS */
531 static struct dahdi_ring_cadence AS_RP_cadence = {{250, 10000}};
532
533 #define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
534                         (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
535
536 #define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
537 #define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
538
539 static char defaultcic[64] = "";
540 static char defaultozz[64] = "";
541
542 /*! Run this script when the MWI state changes on an FXO line, if mwimonitor is enabled */
543 static char mwimonitornotify[PATH_MAX] = "";
544 #ifndef HAVE_DAHDI_LINEREVERSE_VMWI
545 static int  mwisend_rpas = 0;
546 #endif
547
548 static char progzone[10] = "";
549
550 static int usedistinctiveringdetection = 0;
551 static int distinctiveringaftercid = 0;
552
553 static int numbufs = 4;
554
555 static int mwilevel = 512;
556 static int dtmfcid_level = 256;
557
558 #define REPORT_CHANNEL_ALARMS 1
559 #define REPORT_SPAN_ALARMS    2
560 static int report_alarms = REPORT_CHANNEL_ALARMS;
561
562 #ifdef HAVE_PRI
563 static int pridebugfd = -1;
564 static char pridebugfilename[1024] = "";
565 #endif
566
567 /*! \brief Wait up to 16 seconds for first digit (FXO logic) */
568 static int firstdigittimeout = 16000;
569
570 /*! \brief How long to wait for following digits (FXO logic) */
571 static int gendigittimeout = 8000;
572
573 /*! \brief How long to wait for an extra digit, if there is an ambiguous match */
574 static int matchdigittimeout = 3000;
575
576 /*! \brief Protect the interface list (of dahdi_pvt's) */
577 AST_MUTEX_DEFINE_STATIC(iflock);
578
579
580 static int ifcount = 0;
581
582 #ifdef HAVE_PRI
583 AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
584 #endif
585
586 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
587    when it's doing something critical. */
588 AST_MUTEX_DEFINE_STATIC(monlock);
589
590 /*! \brief This is the thread for the monitor which checks for input on the channels
591    which are not currently in use. */
592 static pthread_t monitor_thread = AST_PTHREADT_NULL;
593 static ast_cond_t ss_thread_complete;
594 AST_MUTEX_DEFINE_STATIC(ss_thread_lock);
595 AST_MUTEX_DEFINE_STATIC(restart_lock);
596 static int ss_thread_count = 0;
597 static int num_restart_pending = 0;
598
599 static int restart_monitor(void);
600
601 static int dahdi_sendtext(struct ast_channel *c, const char *text);
602
603 static void mwi_event_cb(void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
604 {
605         /* This module does not handle MWI in an event-based manner.  However, it
606          * subscribes to MWI for each mailbox that is configured so that the core
607          * knows that we care about it.  Then, chan_dahdi will get the MWI from the
608          * event cache instead of checking the mailbox directly. */
609 }
610
611 /*! \brief Avoid the silly dahdi_getevent which ignores a bunch of events */
612 static inline int dahdi_get_event(int fd)
613 {
614         int j;
615         if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
616                 return -1;
617         return j;
618 }
619
620 /*! \brief Avoid the silly dahdi_waitevent which ignores a bunch of events */
621 static inline int dahdi_wait_event(int fd)
622 {
623         int i, j = 0;
624         i = DAHDI_IOMUX_SIGEVENT;
625         if (ioctl(fd, DAHDI_IOMUX, &i) == -1)
626                 return -1;
627         if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
628                 return -1;
629         return j;
630 }
631
632 /*! Chunk size to read -- we use 20ms chunks to make things happy. */
633 #define READ_SIZE 160
634
635 #define MASK_AVAIL              (1 << 0)        /*!< Channel available for PRI use */
636 #define MASK_INUSE              (1 << 1)        /*!< Channel currently in use */
637
638 #define CALLWAITING_SILENT_SAMPLES              ((300 * 8) / READ_SIZE) /*!< 300 ms */
639 #define CALLWAITING_REPEAT_SAMPLES              ((10000 * 8) / READ_SIZE) /*!< 10,000 ms */
640 #define CALLWAITING_SUPPRESS_SAMPLES    ((100 * 8) / READ_SIZE) /*!< 100 ms */
641 #define CIDCW_EXPIRE_SAMPLES                    ((500 * 8) / READ_SIZE) /*!< 500 ms */
642 #define MIN_MS_SINCE_FLASH                              ((2000) )       /*!< 2000 ms */
643 #define DEFAULT_RINGT                                   ((8000 * 8) / READ_SIZE) /*!< 8,000 ms */
644 #define DEFAULT_DIALTONE_DETECT_TIMEOUT ((10000 * 8) / READ_SIZE) /*!< 10,000 ms */
645
646 /*!
647  * \brief Configured ring timeout base.
648  * \note Value computed from "ringtimeout" read in from chan_dahdi.conf if it exists.
649  */
650 static int ringt_base = DEFAULT_RINGT;
651
652 #if defined(HAVE_SS7)
653
654 struct dahdi_ss7 {
655         struct sig_ss7_linkset ss7;
656 };
657
658 static struct dahdi_ss7 linksets[NUM_SPANS];
659
660 static int cur_ss7type = -1;
661 static int cur_slc = -1;
662 static int cur_linkset = -1;
663 static int cur_pointcode = -1;
664 static int cur_cicbeginswith = -1;
665 static int cur_adjpointcode = -1;
666 static int cur_networkindicator = -1;
667 static int cur_defaultdpc = -1;
668 #endif  /* defined(HAVE_SS7) */
669
670 #ifdef HAVE_OPENR2
671 struct dahdi_mfcr2_conf {
672         openr2_variant_t variant;
673         int mfback_timeout;
674         int metering_pulse_timeout;
675         int max_ani;
676         int max_dnis;
677 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
678         int dtmf_time_on;
679         int dtmf_time_off;
680 #endif
681 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
682         int dtmf_end_timeout;
683 #endif
684         signed int get_ani_first:2;
685 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
686         signed int skip_category_request:2;
687 #endif
688         unsigned int call_files:1;
689         unsigned int allow_collect_calls:1;
690         unsigned int charge_calls:1;
691         unsigned int accept_on_offer:1;
692         unsigned int forced_release:1;
693         unsigned int double_answer:1;
694         signed int immediate_accept:2;
695 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
696         signed int dtmf_dialing:2;
697         signed int dtmf_detection:2;
698 #endif
699         char logdir[OR2_MAX_PATH];
700         char r2proto_file[OR2_MAX_PATH];
701         openr2_log_level_t loglevel;
702         openr2_calling_party_category_t category;
703 };
704
705 /* MFC-R2 pseudo-link structure */
706 struct dahdi_mfcr2 {
707         pthread_t r2master;                    /*!< Thread of master */
708         openr2_context_t *protocol_context;    /*!< OpenR2 context handle */
709         struct dahdi_pvt *pvts[SIG_MFCR2_MAX_CHANNELS];     /*!< Member channel pvt structs */
710         int numchans;                          /*!< Number of channels in this R2 block */
711         struct dahdi_mfcr2_conf conf;         /*!< Configuration used to setup this pseudo-link */
712 };
713
714 /* malloc'd array of malloc'd r2links */
715 static struct dahdi_mfcr2 **r2links;
716 /* how many r2links have been malloc'd */
717 static int r2links_count = 0;
718
719 #endif /* HAVE_OPENR2 */
720
721 #ifdef HAVE_PRI
722
723 struct dahdi_pri {
724         int dchannels[SIG_PRI_NUM_DCHANS];              /*!< What channel are the dchannels on */
725         int mastertrunkgroup;                                   /*!< What trunk group is our master */
726         int prilogicalspan;                                             /*!< Logical span number within trunk group */
727         struct sig_pri_span pri;
728 };
729
730 static struct dahdi_pri pris[NUM_SPANS];
731
732 #if defined(HAVE_PRI_CCSS)
733 /*! DAHDI PRI CCSS agent and monitor type name. */
734 static const char dahdi_pri_cc_type[] = "DAHDI/PRI";
735 #endif  /* defined(HAVE_PRI_CCSS) */
736
737 #else
738 /*! Shut up the compiler */
739 struct dahdi_pri;
740 #endif
741
742 /* Polarity states */
743 #define POLARITY_IDLE   0
744 #define POLARITY_REV    1
745
746 const char * const subnames[] = {
747         "Real",
748         "Callwait",
749         "Threeway"
750 };
751
752 #define DATA_EXPORT_DAHDI_PVT(MEMBER)                                   \
753         MEMBER(dahdi_pvt, cid_rxgain, AST_DATA_DOUBLE)                  \
754         MEMBER(dahdi_pvt, rxgain, AST_DATA_DOUBLE)                      \
755         MEMBER(dahdi_pvt, txgain, AST_DATA_DOUBLE)                      \
756         MEMBER(dahdi_pvt, txdrc, AST_DATA_DOUBLE)                       \
757         MEMBER(dahdi_pvt, rxdrc, AST_DATA_DOUBLE)                       \
758         MEMBER(dahdi_pvt, adsi, AST_DATA_BOOLEAN)                       \
759         MEMBER(dahdi_pvt, answeronpolarityswitch, AST_DATA_BOOLEAN)     \
760         MEMBER(dahdi_pvt, busydetect, AST_DATA_BOOLEAN)                 \
761         MEMBER(dahdi_pvt, callreturn, AST_DATA_BOOLEAN)                 \
762         MEMBER(dahdi_pvt, callwaiting, AST_DATA_BOOLEAN)                \
763         MEMBER(dahdi_pvt, callwaitingcallerid, AST_DATA_BOOLEAN)        \
764         MEMBER(dahdi_pvt, cancallforward, AST_DATA_BOOLEAN)             \
765         MEMBER(dahdi_pvt, canpark, AST_DATA_BOOLEAN)                    \
766         MEMBER(dahdi_pvt, confirmanswer, AST_DATA_BOOLEAN)              \
767         MEMBER(dahdi_pvt, destroy, AST_DATA_BOOLEAN)                    \
768         MEMBER(dahdi_pvt, didtdd, AST_DATA_BOOLEAN)                     \
769         MEMBER(dahdi_pvt, dialednone, AST_DATA_BOOLEAN)                 \
770         MEMBER(dahdi_pvt, dialing, AST_DATA_BOOLEAN)                    \
771         MEMBER(dahdi_pvt, digital, AST_DATA_BOOLEAN)                    \
772         MEMBER(dahdi_pvt, dnd, AST_DATA_BOOLEAN)                        \
773         MEMBER(dahdi_pvt, echobreak, AST_DATA_BOOLEAN)                  \
774         MEMBER(dahdi_pvt, echocanbridged, AST_DATA_BOOLEAN)             \
775         MEMBER(dahdi_pvt, echocanon, AST_DATA_BOOLEAN)                  \
776         MEMBER(dahdi_pvt, faxhandled, AST_DATA_BOOLEAN)                 \
777         MEMBER(dahdi_pvt, usefaxbuffers, AST_DATA_BOOLEAN)              \
778         MEMBER(dahdi_pvt, bufferoverrideinuse, AST_DATA_BOOLEAN)        \
779         MEMBER(dahdi_pvt, firstradio, AST_DATA_BOOLEAN)                 \
780         MEMBER(dahdi_pvt, hanguponpolarityswitch, AST_DATA_BOOLEAN)     \
781         MEMBER(dahdi_pvt, hardwaredtmf, AST_DATA_BOOLEAN)               \
782         MEMBER(dahdi_pvt, hidecallerid, AST_DATA_BOOLEAN)               \
783         MEMBER(dahdi_pvt, hidecalleridname, AST_DATA_BOOLEAN)           \
784         MEMBER(dahdi_pvt, ignoredtmf, AST_DATA_BOOLEAN)                 \
785         MEMBER(dahdi_pvt, immediate, AST_DATA_BOOLEAN)                  \
786         MEMBER(dahdi_pvt, inalarm, AST_DATA_BOOLEAN)                    \
787         MEMBER(dahdi_pvt, mate, AST_DATA_BOOLEAN)                       \
788         MEMBER(dahdi_pvt, outgoing, AST_DATA_BOOLEAN)                   \
789         MEMBER(dahdi_pvt, permcallwaiting, AST_DATA_BOOLEAN)            \
790         MEMBER(dahdi_pvt, priindication_oob, AST_DATA_BOOLEAN)          \
791         MEMBER(dahdi_pvt, priexclusive, AST_DATA_BOOLEAN)               \
792         MEMBER(dahdi_pvt, pulse, AST_DATA_BOOLEAN)                      \
793         MEMBER(dahdi_pvt, pulsedial, AST_DATA_BOOLEAN)                  \
794         MEMBER(dahdi_pvt, restartpending, AST_DATA_BOOLEAN)             \
795         MEMBER(dahdi_pvt, restrictcid, AST_DATA_BOOLEAN)                \
796         MEMBER(dahdi_pvt, threewaycalling, AST_DATA_BOOLEAN)            \
797         MEMBER(dahdi_pvt, transfer, AST_DATA_BOOLEAN)                   \
798         MEMBER(dahdi_pvt, use_callerid, AST_DATA_BOOLEAN)               \
799         MEMBER(dahdi_pvt, use_callingpres, AST_DATA_BOOLEAN)            \
800         MEMBER(dahdi_pvt, usedistinctiveringdetection, AST_DATA_BOOLEAN)        \
801         MEMBER(dahdi_pvt, dahditrcallerid, AST_DATA_BOOLEAN)                    \
802         MEMBER(dahdi_pvt, transfertobusy, AST_DATA_BOOLEAN)                     \
803         MEMBER(dahdi_pvt, mwimonitor_neon, AST_DATA_BOOLEAN)                    \
804         MEMBER(dahdi_pvt, mwimonitor_fsk, AST_DATA_BOOLEAN)                     \
805         MEMBER(dahdi_pvt, mwimonitor_rpas, AST_DATA_BOOLEAN)                    \
806         MEMBER(dahdi_pvt, mwimonitoractive, AST_DATA_BOOLEAN)                   \
807         MEMBER(dahdi_pvt, mwisendactive, AST_DATA_BOOLEAN)                      \
808         MEMBER(dahdi_pvt, inservice, AST_DATA_BOOLEAN)                          \
809         MEMBER(dahdi_pvt, locallyblocked, AST_DATA_UNSIGNED_INTEGER)            \
810         MEMBER(dahdi_pvt, remotelyblocked, AST_DATA_UNSIGNED_INTEGER)           \
811         MEMBER(dahdi_pvt, manages_span_alarms, AST_DATA_BOOLEAN)                \
812         MEMBER(dahdi_pvt, use_smdi, AST_DATA_BOOLEAN)                           \
813         MEMBER(dahdi_pvt, context, AST_DATA_STRING)                             \
814         MEMBER(dahdi_pvt, defcontext, AST_DATA_STRING)                          \
815         MEMBER(dahdi_pvt, description, AST_DATA_STRING)                         \
816         MEMBER(dahdi_pvt, exten, AST_DATA_STRING)                               \
817         MEMBER(dahdi_pvt, language, AST_DATA_STRING)                            \
818         MEMBER(dahdi_pvt, mohinterpret, AST_DATA_STRING)                        \
819         MEMBER(dahdi_pvt, mohsuggest, AST_DATA_STRING)                          \
820         MEMBER(dahdi_pvt, parkinglot, AST_DATA_STRING)
821
822 AST_DATA_STRUCTURE(dahdi_pvt, DATA_EXPORT_DAHDI_PVT);
823
824 static struct dahdi_pvt *iflist = NULL; /*!< Main interface list start */
825 static struct dahdi_pvt *ifend = NULL;  /*!< Main interface list end */
826
827 #if defined(HAVE_PRI)
828 struct doomed_pri {
829         struct sig_pri_span *pri;
830         AST_LIST_ENTRY(doomed_pri) list;
831 };
832 static AST_LIST_HEAD_STATIC(doomed_pris, doomed_pri);
833
834 static void pri_destroy_span(struct sig_pri_span *pri);
835
836 static struct dahdi_parms_pseudo {
837         int buf_no;                                     /*!< Number of buffers */
838         int buf_policy;                         /*!< Buffer policy */
839         int faxbuf_no;              /*!< Number of Fax buffers */
840         int faxbuf_policy;          /*!< Fax buffer policy */
841 } dahdi_pseudo_parms;
842 #endif  /* defined(HAVE_PRI) */
843
844 /*! \brief Channel configuration from chan_dahdi.conf .
845  * This struct is used for parsing the [channels] section of chan_dahdi.conf.
846  * Generally there is a field here for every possible configuration item.
847  *
848  * The state of fields is saved along the parsing and whenever a 'channel'
849  * statement is reached, the current dahdi_chan_conf is used to configure the
850  * channel (struct dahdi_pvt)
851  *
852  * \see dahdi_chan_init for the default values.
853  */
854 struct dahdi_chan_conf {
855         struct dahdi_pvt chan;
856 #ifdef HAVE_PRI
857         struct dahdi_pri pri;
858 #endif
859
860 #if defined(HAVE_SS7)
861         struct dahdi_ss7 ss7;
862 #endif  /* defined(HAVE_SS7) */
863
864 #ifdef HAVE_OPENR2
865         struct dahdi_mfcr2_conf mfcr2;
866 #endif
867         struct dahdi_params timing;
868         int is_sig_auto; /*!< Use channel signalling from DAHDI? */
869         /*! Continue configuration even if a channel is not there. */
870         int ignore_failed_channels;
871
872         /*!
873          * \brief The serial port to listen for SMDI data on
874          * \note Set from the "smdiport" string read in from chan_dahdi.conf
875          */
876         char smdi_port[SMDI_MAX_FILENAME_LEN];
877
878         /*!
879          * \brief Don't create channels below this number
880          * \note by default is 0 (no limit)
881          */
882         int wanted_channels_start;
883
884         /*!
885          * \brief Don't create channels above this number (infinity by default)
886          * \note by default is 0 (special value that means "no limit").
887          */
888         int wanted_channels_end;
889 };
890
891 /*! returns a new dahdi_chan_conf with default values (by-value) */
892 static struct dahdi_chan_conf dahdi_chan_conf_default(void)
893 {
894         /* recall that if a field is not included here it is initialized
895          * to 0 or equivalent
896          */
897         struct dahdi_chan_conf conf = {
898 #ifdef HAVE_PRI
899                 .pri.pri = {
900                         .nsf = PRI_NSF_NONE,
901                         .switchtype = PRI_SWITCH_NI2,
902                         .dialplan = PRI_UNKNOWN + 1,
903                         .localdialplan = PRI_NATIONAL_ISDN + 1,
904                         .nodetype = PRI_CPE,
905                         .qsigchannelmapping = DAHDI_CHAN_MAPPING_PHYSICAL,
906
907 #if defined(HAVE_PRI_CCSS)
908                         .cc_ptmp_recall_mode = 1,/* specificRecall */
909                         .cc_qsig_signaling_link_req = 1,/* retain */
910                         .cc_qsig_signaling_link_rsp = 1,/* retain */
911 #endif  /* defined(HAVE_PRI_CCSS) */
912
913                         .minunused = 2,
914                         .idleext = "",
915                         .idledial = "",
916                         .internationalprefix = "",
917                         .nationalprefix = "",
918                         .localprefix = "",
919                         .privateprefix = "",
920                         .unknownprefix = "",
921                         .colp_send = SIG_PRI_COLP_UPDATE,
922                         .resetinterval = -1,
923                 },
924 #endif
925 #if defined(HAVE_SS7)
926                 .ss7.ss7 = {
927                         .called_nai = SS7_NAI_NATIONAL,
928                         .calling_nai = SS7_NAI_NATIONAL,
929                         .internationalprefix = "",
930                         .nationalprefix = "",
931                         .subscriberprefix = "",
932                         .unknownprefix = "",
933                         .networkroutedprefix = ""
934                 },
935 #endif  /* defined(HAVE_SS7) */
936 #ifdef HAVE_OPENR2
937                 .mfcr2 = {
938                         .variant = OR2_VAR_ITU,
939                         .mfback_timeout = -1,
940                         .metering_pulse_timeout = -1,
941                         .max_ani = 10,
942                         .max_dnis = 4,
943                         .get_ani_first = -1,
944 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
945                         .skip_category_request = -1,
946 #endif
947                         .call_files = 0,
948                         .allow_collect_calls = 0,
949                         .charge_calls = 1,
950                         .accept_on_offer = 1,
951                         .forced_release = 0,
952                         .double_answer = 0,
953                         .immediate_accept = -1,
954 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
955                         .dtmf_dialing = -1,
956                         .dtmf_detection = -1,
957                         .dtmf_time_on = OR2_DEFAULT_DTMF_ON,
958                         .dtmf_time_off = OR2_DEFAULT_DTMF_OFF,
959 #endif
960 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
961                         .dtmf_end_timeout = -1,
962 #endif
963                         .logdir = "",
964                         .r2proto_file = "",
965                         .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING,
966                         .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER
967                 },
968 #endif
969                 .chan = {
970                         .context = "default",
971                         .cid_num = "",
972                         .cid_name = "",
973                         .cid_tag = "",
974                         .mohinterpret = "default",
975                         .mohsuggest = "",
976                         .parkinglot = "",
977                         .transfertobusy = 1,
978
979                         .cid_signalling = CID_SIG_BELL,
980                         .cid_start = CID_START_RING,
981                         .dahditrcallerid = 0,
982                         .use_callerid = 1,
983                         .sig = -1,
984                         .outsigmod = -1,
985
986                         .cid_rxgain = +5.0,
987
988                         .tonezone = -1,
989
990                         .echocancel.head.tap_length = 1,
991
992                         .busycount = 3,
993
994                         .accountcode = "",
995
996                         .mailbox = "",
997
998 #ifdef HAVE_DAHDI_LINEREVERSE_VMWI
999                         .mwisend_fsk = 1,
1000 #endif
1001                         .polarityonanswerdelay = 600,
1002
1003                         .sendcalleridafter = DEFAULT_CIDRINGS,
1004
1005                         .buf_policy = DAHDI_POLICY_IMMEDIATE,
1006                         .buf_no = numbufs,
1007                         .usefaxbuffers = 0,
1008                         .cc_params = ast_cc_config_params_init(),
1009                 },
1010                 .timing = {
1011                         .prewinktime = -1,
1012                         .preflashtime = -1,
1013                         .winktime = -1,
1014                         .flashtime = -1,
1015                         .starttime = -1,
1016                         .rxwinktime = -1,
1017                         .rxflashtime = -1,
1018                         .debouncetime = -1
1019                 },
1020                 .is_sig_auto = 1,
1021                 .ignore_failed_channels = 1,
1022                 .smdi_port = "/dev/ttyS0",
1023         };
1024
1025         return conf;
1026 }
1027
1028
1029 static struct ast_channel *dahdi_request(const char *type, struct ast_format_cap *cap,
1030         const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor,
1031         const char *data, int *cause);
1032 static int dahdi_digit_begin(struct ast_channel *ast, char digit);
1033 static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
1034 static int dahdi_sendtext(struct ast_channel *c, const char *text);
1035 static int dahdi_call(struct ast_channel *ast, const char *rdest, int timeout);
1036 static int dahdi_hangup(struct ast_channel *ast);
1037 static int dahdi_answer(struct ast_channel *ast);
1038 static struct ast_frame *dahdi_read(struct ast_channel *ast);
1039 static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame);
1040 static struct ast_frame *dahdi_exception(struct ast_channel *ast);
1041 static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
1042 static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1043 static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen);
1044 static int dahdi_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
1045 static int dahdi_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len);
1046 static int dahdi_func_write(struct ast_channel *chan, const char *function, char *data, const char *value);
1047 static int dahdi_devicestate(const char *data);
1048 static int dahdi_cc_callback(struct ast_channel *inbound, const char *dest, ast_cc_callback_fn callback);
1049
1050 static struct ast_channel_tech dahdi_tech = {
1051         .type = "DAHDI",
1052         .description = tdesc,
1053         .requester = dahdi_request,
1054         .send_digit_begin = dahdi_digit_begin,
1055         .send_digit_end = dahdi_digit_end,
1056         .send_text = dahdi_sendtext,
1057         .call = dahdi_call,
1058         .hangup = dahdi_hangup,
1059         .answer = dahdi_answer,
1060         .read = dahdi_read,
1061         .write = dahdi_write,
1062         .exception = dahdi_exception,
1063         .indicate = dahdi_indicate,
1064         .fixup = dahdi_fixup,
1065         .setoption = dahdi_setoption,
1066         .queryoption = dahdi_queryoption,
1067         .func_channel_read = dahdi_func_read,
1068         .func_channel_write = dahdi_func_write,
1069         .devicestate = dahdi_devicestate,
1070         .cc_callback = dahdi_cc_callback,
1071 };
1072
1073 #define GET_CHANNEL(p) ((p)->channel)
1074
1075 static enum analog_sigtype dahdisig_to_analogsig(int sig)
1076 {
1077         switch (sig) {
1078         case SIG_FXOLS:
1079                 return ANALOG_SIG_FXOLS;
1080         case SIG_FXOGS:
1081                 return ANALOG_SIG_FXOGS;
1082         case SIG_FXOKS:
1083                 return ANALOG_SIG_FXOKS;
1084         case SIG_FXSLS:
1085                 return ANALOG_SIG_FXSLS;
1086         case SIG_FXSGS:
1087                 return ANALOG_SIG_FXSGS;
1088         case SIG_FXSKS:
1089                 return ANALOG_SIG_FXSKS;
1090         case SIG_EMWINK:
1091                 return ANALOG_SIG_EMWINK;
1092         case SIG_EM:
1093                 return ANALOG_SIG_EM;
1094         case SIG_EM_E1:
1095                 return ANALOG_SIG_EM_E1;
1096         case SIG_FEATD:
1097                 return ANALOG_SIG_FEATD;
1098         case SIG_FEATDMF:
1099                 return ANALOG_SIG_FEATDMF;
1100         case SIG_E911:
1101                 return SIG_E911;
1102         case SIG_FGC_CAMA:
1103                 return ANALOG_SIG_FGC_CAMA;
1104         case SIG_FGC_CAMAMF:
1105                 return ANALOG_SIG_FGC_CAMAMF;
1106         case SIG_FEATB:
1107                 return ANALOG_SIG_FEATB;
1108         case SIG_SFWINK:
1109                 return ANALOG_SIG_SFWINK;
1110         case SIG_SF:
1111                 return ANALOG_SIG_SF;
1112         case SIG_SF_FEATD:
1113                 return ANALOG_SIG_SF_FEATD;
1114         case SIG_SF_FEATDMF:
1115                 return ANALOG_SIG_SF_FEATDMF;
1116         case SIG_FEATDMF_TA:
1117                 return ANALOG_SIG_FEATDMF_TA;
1118         case SIG_SF_FEATB:
1119                 return ANALOG_SIG_FEATB;
1120         default:
1121                 return -1;
1122         }
1123 }
1124
1125
1126 static int analog_tone_to_dahditone(enum analog_tone tone)
1127 {
1128         switch (tone) {
1129         case ANALOG_TONE_RINGTONE:
1130                 return DAHDI_TONE_RINGTONE;
1131         case ANALOG_TONE_STUTTER:
1132                 return DAHDI_TONE_STUTTER;
1133         case ANALOG_TONE_CONGESTION:
1134                 return DAHDI_TONE_CONGESTION;
1135         case ANALOG_TONE_DIALTONE:
1136                 return DAHDI_TONE_DIALTONE;
1137         case ANALOG_TONE_DIALRECALL:
1138                 return DAHDI_TONE_DIALRECALL;
1139         case ANALOG_TONE_INFO:
1140                 return DAHDI_TONE_INFO;
1141         default:
1142                 return -1;
1143         }
1144 }
1145
1146 static int analogsub_to_dahdisub(enum analog_sub analogsub)
1147 {
1148         int index;
1149
1150         switch (analogsub) {
1151         case ANALOG_SUB_REAL:
1152                 index = SUB_REAL;
1153                 break;
1154         case ANALOG_SUB_CALLWAIT:
1155                 index = SUB_CALLWAIT;
1156                 break;
1157         case ANALOG_SUB_THREEWAY:
1158                 index = SUB_THREEWAY;
1159                 break;
1160         default:
1161                 ast_log(LOG_ERROR, "Unidentified sub!\n");
1162                 index = SUB_REAL;
1163         }
1164
1165         return index;
1166 }
1167
1168 /*!
1169  * \internal
1170  * \brief release all members on the doomed pris list
1171  * \since 13.0
1172  *
1173  * Called priodically by the monitor threads to release spans marked for
1174  * removal.
1175  */
1176 static void release_doomed_pris(void)
1177 {
1178 #ifdef HAVE_PRI
1179         struct doomed_pri *entry;
1180
1181         AST_LIST_LOCK(&doomed_pris);
1182         while ((entry = AST_LIST_REMOVE_HEAD(&doomed_pris, list))) {
1183                 /* The span destruction must be done with this lock not held */
1184                 AST_LIST_UNLOCK(&doomed_pris);
1185                 ast_debug(4, "Destroying span %d from doomed queue.\n",
1186                                 entry->pri->span);
1187                 pri_destroy_span(entry->pri);
1188                 ast_free(entry);
1189                 AST_LIST_LOCK(&doomed_pris);
1190         }
1191         AST_LIST_UNLOCK(&doomed_pris);
1192 #endif
1193 }
1194
1195 #ifdef HAVE_PRI
1196 /*!
1197  * \brief Queue a span for destruction
1198  * \since 13.0
1199  *
1200  * \param pri the span to destroy
1201  *
1202  * Add a span to the list of spans to be destroyed later on
1203  * by the monitor thread. Allows destroying a span while holding its
1204  * lock.
1205  */
1206 static void pri_queue_for_destruction(struct sig_pri_span *pri)
1207 {
1208         struct doomed_pri *entry;
1209
1210         AST_LIST_LOCK(&doomed_pris);
1211         AST_LIST_TRAVERSE(&doomed_pris, entry, list) {
1212                 if (entry->pri == pri) {
1213                         AST_LIST_UNLOCK(&doomed_pris);
1214                         return;
1215                 }
1216         }
1217         entry = ast_calloc(sizeof(struct doomed_pri), 1);
1218         if (!entry) {
1219                 /* Nothing useful to do here. Panic? */
1220                 ast_log(LOG_WARNING, "Failed allocating memory for a doomed_pri.\n");
1221                 AST_LIST_UNLOCK(&doomed_pris);
1222                 return;
1223         }
1224         entry->pri = pri;
1225         ast_debug(4, "Queue span %d for destruction.\n", pri->span);
1226         AST_LIST_INSERT_TAIL(&doomed_pris, entry, list);
1227         AST_LIST_UNLOCK(&doomed_pris);
1228 }
1229 #endif
1230
1231 /*!
1232  * \internal
1233  * \brief Send a dial string to DAHDI.
1234  * \since 12.0.0
1235  *
1236  * \param pvt DAHDI private pointer
1237  * \param operation DAHDI dial operation to do to string
1238  * \param dial_str Dial string to send
1239  *
1240  * \retval 0 on success.
1241  * \retval non-zero on error.
1242  */
1243 static int dahdi_dial_str(struct dahdi_pvt *pvt, int operation, const char *dial_str)
1244 {
1245         int res;
1246         int offset;
1247         const char *pos;
1248         struct dahdi_dialoperation zo = {
1249                 .op = operation,
1250         };
1251
1252         /* Convert the W's to ww. */
1253         pos = dial_str;
1254         for (offset = 0; offset < sizeof(zo.dialstr) - 1; ++offset) {
1255                 if (!*pos) {
1256                         break;
1257                 }
1258                 if (*pos == 'W') {
1259                         /* Convert 'W' to "ww" */
1260                         ++pos;
1261                         if (offset >= sizeof(zo.dialstr) - 3) {
1262                                 /* No room to expand */
1263                                 break;
1264                         }
1265                         zo.dialstr[offset] = 'w';
1266                         ++offset;
1267                         zo.dialstr[offset] = 'w';
1268                         continue;
1269                 }
1270                 zo.dialstr[offset] = *pos++;
1271         }
1272         /* The zo initialization has already terminated the dialstr. */
1273
1274         ast_debug(1, "Channel %d: Dial str '%s' expanded to '%s' sent to DAHDI_DIAL.\n",
1275                 pvt->channel, dial_str, zo.dialstr);
1276         res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_DIAL, &zo);
1277         if (res) {
1278                 ast_log(LOG_WARNING, "Channel %d: Couldn't dial '%s': %s\n",
1279                         pvt->channel, dial_str, strerror(errno));
1280         }
1281
1282         return res;
1283 }
1284
1285 static enum analog_event dahdievent_to_analogevent(int event);
1286 static int bump_gains(struct dahdi_pvt *p);
1287 static int dahdi_setlinear(int dfd, int linear);
1288
1289 static int my_start_cid_detect(void *pvt, int cid_signalling)
1290 {
1291         struct dahdi_pvt *p = pvt;
1292         int index = SUB_REAL;
1293         p->cs = callerid_new(cid_signalling);
1294         if (!p->cs) {
1295                 ast_log(LOG_ERROR, "Unable to alloc callerid\n");
1296                 return -1;
1297         }
1298         bump_gains(p);
1299         dahdi_setlinear(p->subs[index].dfd, 0);
1300
1301         return 0;
1302 }
1303
1304 static int restore_gains(struct dahdi_pvt *p);
1305
1306 static int my_stop_cid_detect(void *pvt)
1307 {
1308         struct dahdi_pvt *p = pvt;
1309         int index = SUB_REAL;
1310
1311         if (p->cs) {
1312                 callerid_free(p->cs);
1313         }
1314
1315         /* Restore linear mode after Caller*ID processing */
1316         dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
1317         restore_gains(p);
1318
1319         return 0;
1320 }
1321
1322 static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
1323 {
1324         struct dahdi_pvt *p = pvt;
1325         struct analog_pvt *analog_p = p->sig_pvt;
1326         struct pollfd poller;
1327         char *name, *num;
1328         int index = SUB_REAL;
1329         int res;
1330         unsigned char buf[256];
1331         int flags;
1332
1333         poller.fd = p->subs[SUB_REAL].dfd;
1334         poller.events = POLLPRI | POLLIN;
1335         poller.revents = 0;
1336
1337         res = poll(&poller, 1, timeout);
1338
1339         if (poller.revents & POLLPRI) {
1340                 *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd));
1341                 return 1;
1342         }
1343
1344         if (poller.revents & POLLIN) {
1345                 /*** NOTES ***/
1346                 /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function
1347                  * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until
1348                  * either a timeout occurs or CID is detected (returns 0). returning 1 should be event received, and -1 should be
1349                  * a failure and die, and returning 2 means no event was received. */
1350                 res = read(p->subs[index].dfd, buf, sizeof(buf));
1351                 if (res < 0) {
1352                         ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1353                         return -1;
1354                 }
1355
1356                 if (analog_p->ringt > 0) {
1357                         if (!(--analog_p->ringt)) {
1358                                 /* only return if we timeout from a ring event */
1359                                 return -1;
1360                         }
1361                 }
1362
1363                 if (p->cid_signalling == CID_SIG_V23_JP) {
1364                         res = callerid_feed_jp(p->cs, buf, res, AST_LAW(p));
1365                 } else {
1366                         res = callerid_feed(p->cs, buf, res, AST_LAW(p));
1367                 }
1368                 if (res < 0) {
1369                         /*
1370                          * The previous diagnostic message output likely
1371                          * explains why it failed.
1372                          */
1373                         ast_log(LOG_WARNING, "Failed to decode CallerID\n");
1374                         return -1;
1375                 }
1376
1377                 if (res == 1) {
1378                         callerid_get(p->cs, &name, &num, &flags);
1379                         if (name)
1380                                 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
1381                         if (num)
1382                                 ast_copy_string(numbuf, num, ANALOG_MAX_CID);
1383
1384                         ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
1385                         return 0;
1386                 }
1387         }
1388
1389         *ev = ANALOG_EVENT_NONE;
1390         return 2;
1391 }
1392
1393 static const char *event2str(int event);
1394
1395 static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
1396 {
1397         unsigned char buf[256];
1398         int distMatches;
1399         int curRingData[RING_PATTERNS];
1400         int receivedRingT;
1401         int counter1;
1402         int counter;
1403         int i;
1404         int res;
1405         int checkaftercid = 0;
1406         const char *matched_context;
1407         struct dahdi_pvt *p = pvt;
1408         struct analog_pvt *analog_p = p->sig_pvt;
1409
1410         if (ringdata == NULL) {
1411                 ringdata = curRingData;
1412         } else {
1413                 checkaftercid = 1;
1414         }
1415
1416         /* We must have a ring by now so lets try to listen for distinctive ringing */
1417         if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
1418                 /* Clear the current ring data array so we don't have old data in it. */
1419                 for (receivedRingT = 0; receivedRingT < RING_PATTERNS; receivedRingT++)
1420                         ringdata[receivedRingT] = 0;
1421                 receivedRingT = 0;
1422
1423                 if (checkaftercid && distinctiveringaftercid) {
1424                         ast_verb(3, "Detecting post-CID distinctive ring\n");
1425                 }
1426
1427                 for (;;) {
1428                         i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1429                         res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i);
1430                         if (res) {
1431                                 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
1432                                 ast_hangup(chan);
1433                                 return 1;
1434                         }
1435                         if (i & DAHDI_IOMUX_SIGEVENT) {
1436                                 res = dahdi_get_event(p->subs[idx].dfd);
1437                                 ast_debug(3, "Got event %d (%s)...\n", res, event2str(res));
1438                                 if (res == DAHDI_EVENT_NOALARM) {
1439                                         p->inalarm = 0;
1440                                         analog_p->inalarm = 0;
1441                                 } else if (res == DAHDI_EVENT_RINGOFFHOOK) {
1442                                         /* Let us detect distinctive ring */
1443                                         ringdata[receivedRingT] = analog_p->ringt;
1444
1445                                         if (analog_p->ringt < analog_p->ringt_base / 2) {
1446                                                 break;
1447                                         }
1448                                         /* Increment the ringT counter so we can match it against
1449                                            values in chan_dahdi.conf for distinctive ring */
1450                                         if (++receivedRingT == RING_PATTERNS) {
1451                                                 break;
1452                                         }
1453                                 }
1454                         } else if (i & DAHDI_IOMUX_READ) {
1455                                 res = read(p->subs[idx].dfd, buf, sizeof(buf));
1456                                 if (res < 0) {
1457                                         if (errno != ELAST) {
1458                                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1459                                                 ast_hangup(chan);
1460                                                 return 1;
1461                                         }
1462                                         break;
1463                                 }
1464                                 if (analog_p->ringt > 0) {
1465                                         if (!(--analog_p->ringt)) {
1466                                                 break;
1467                                         }
1468                                 }
1469                         }
1470                 }
1471         }
1472
1473         /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
1474         ast_verb(3, "Detected ring pattern: %d,%d,%d\n", ringdata[0], ringdata[1], ringdata[2]);
1475         matched_context = p->defcontext;
1476         for (counter = 0; counter < 3; counter++) {
1477                 int range = p->drings.ringnum[counter].range;
1478
1479                 distMatches = 0;
1480                 ast_verb(3, "Checking %d,%d,%d with +/- %d range\n",
1481                         p->drings.ringnum[counter].ring[0],
1482                         p->drings.ringnum[counter].ring[1],
1483                         p->drings.ringnum[counter].ring[2],
1484                         range);
1485                 for (counter1 = 0; counter1 < 3; counter1++) {
1486                         int ring = p->drings.ringnum[counter].ring[counter1];
1487
1488                         if (ring == -1) {
1489                                 ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1490                                         ringdata[counter1]);
1491                                 distMatches++;
1492                         } else if (ring - range <= ringdata[counter1] && ringdata[counter1] <= ring + range) {
1493                                 ast_verb(3, "Ring pattern %d is in range: %d to %d\n",
1494                                         ringdata[counter1], ring - range, ring + range);
1495                                 distMatches++;
1496                         } else {
1497                                 /* The current dring pattern cannot match. */
1498                                 break;
1499                         }
1500                 }
1501
1502                 if (distMatches == 3) {
1503                         /* The ring matches, set the context to whatever is for distinctive ring.. */
1504                         matched_context = S_OR(p->drings.ringContext[counter].contextData, p->defcontext);
1505                         ast_verb(3, "Matched Distinctive Ring context %s\n", matched_context);
1506                         break;
1507                 }
1508         }
1509
1510         /* Set selected distinctive ring context if not already set. */
1511         if (strcmp(p->context, matched_context) != 0) {
1512                 ast_copy_string(p->context, matched_context, sizeof(p->context));
1513                 ast_channel_context_set(chan, matched_context);
1514         }
1515
1516         return 0;
1517 }
1518
1519 static int my_stop_callwait(void *pvt)
1520 {
1521         struct dahdi_pvt *p = pvt;
1522         p->callwaitingrepeat = 0;
1523         p->cidcwexpire = 0;
1524         p->cid_suppress_expire = 0;
1525
1526         return 0;
1527 }
1528
1529 static int send_callerid(struct dahdi_pvt *p);
1530 static int save_conference(struct dahdi_pvt *p);
1531 static int restore_conference(struct dahdi_pvt *p);
1532
1533 static int my_callwait(void *pvt)
1534 {
1535         struct dahdi_pvt *p = pvt;
1536
1537         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1538         if (p->cidspill) {
1539                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1540                 ast_free(p->cidspill);
1541         }
1542
1543         /*
1544          * SAS: Subscriber Alert Signal, 440Hz for 300ms
1545          * CAS: CPE Alert Signal, 2130Hz * 2750Hz sine waves
1546          */
1547         if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1548                 return -1;
1549         save_conference(p);
1550         /* Silence */
1551         memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1552         if (!p->callwaitrings && p->callwaitingcallerid) {
1553                 ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
1554                 p->callwaitcas = 1;
1555                 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1556         } else {
1557                 ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
1558                 p->callwaitcas = 0;
1559                 p->cidlen = 2400 + READ_SIZE * 4;
1560         }
1561         p->cidpos = 0;
1562         send_callerid(p);
1563
1564         return 0;
1565 }
1566
1567 static int my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
1568 {
1569         struct dahdi_pvt *p = pvt;
1570
1571         ast_debug(2, "Starting cid spill\n");
1572
1573         if (p->cidspill) {
1574                 ast_log(LOG_WARNING, "cidspill already exists??\n");
1575                 ast_free(p->cidspill);
1576         }
1577
1578         if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1579                 if (cwcid == 0) {
1580                         p->cidlen = ast_callerid_generate(p->cidspill,
1581                                 caller->id.name.str,
1582                                 caller->id.number.str,
1583                                 AST_LAW(p));
1584                 } else {
1585                         ast_verb(3, "CPE supports Call Waiting Caller*ID.  Sending '%s/%s'\n",
1586                                 caller->id.name.str, caller->id.number.str);
1587                         p->callwaitcas = 0;
1588                         p->cidcwexpire = 0;
1589                         p->cidlen = ast_callerid_callwaiting_generate(p->cidspill,
1590                                 caller->id.name.str,
1591                                 caller->id.number.str,
1592                                 AST_LAW(p));
1593                         p->cidlen += READ_SIZE * 4;
1594                 }
1595                 p->cidpos = 0;
1596                 p->cid_suppress_expire = 0;
1597                 send_callerid(p);
1598         }
1599         return 0;
1600 }
1601
1602 static int my_dsp_reset_and_flush_digits(void *pvt)
1603 {
1604         struct dahdi_pvt *p = pvt;
1605         if (p->dsp)
1606                 ast_dsp_digitreset(p->dsp);
1607
1608         return 0;
1609 }
1610
1611 static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
1612 {
1613         struct dahdi_pvt *p = pvt;
1614
1615         if (p->channel == CHAN_PSEUDO)
1616                 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");
1617
1618         if (mode == ANALOG_DIGITMODE_DTMF) {
1619                 /* If we do hardware dtmf, no need for a DSP */
1620                 if (p->hardwaredtmf) {
1621                         if (p->dsp) {
1622                                 ast_dsp_free(p->dsp);
1623                                 p->dsp = NULL;
1624                         }
1625                         return 0;
1626                 }
1627
1628                 if (!p->dsp) {
1629                         p->dsp = ast_dsp_new();
1630                         if (!p->dsp) {
1631                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1632                                 return -1;
1633                         }
1634                 }
1635
1636                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
1637         } else if (mode == ANALOG_DIGITMODE_MF) {
1638                 if (!p->dsp) {
1639                         p->dsp = ast_dsp_new();
1640                         if (!p->dsp) {
1641                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1642                                 return -1;
1643                         }
1644                 }
1645                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
1646         }
1647         return 0;
1648 }
1649
1650 static int dahdi_wink(struct dahdi_pvt *p, int index);
1651
1652 static int my_wink(void *pvt, enum analog_sub sub)
1653 {
1654         struct dahdi_pvt *p = pvt;
1655         int index = analogsub_to_dahdisub(sub);
1656         if (index != SUB_REAL) {
1657                 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
1658         }
1659         return dahdi_wink(p, index);
1660 }
1661
1662 static void wakeup_sub(struct dahdi_pvt *p, int a);
1663
1664 static int reset_conf(struct dahdi_pvt *p);
1665
1666 static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);
1667
1668 static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
1669 {
1670         struct ast_frame *f = *dest;
1671         struct dahdi_pvt *p = pvt;
1672         int idx = analogsub_to_dahdisub(analog_index);
1673
1674         ast_debug(1, "%s DTMF digit: 0x%02X '%c' on %s\n",
1675                 f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
1676                 (unsigned)f->subclass.integer, f->subclass.integer, ast_channel_name(ast));
1677
1678         if (f->subclass.integer == 'f') {
1679                 if (f->frametype == AST_FRAME_DTMF_END) {
1680                         /* Fax tone -- Handle and return NULL */
1681                         if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
1682                                 /* If faxbuffers are configured, use them for the fax transmission */
1683                                 if (p->usefaxbuffers && !p->bufferoverrideinuse) {
1684                                         struct dahdi_bufferinfo bi = {
1685                                                 .txbufpolicy = p->faxbuf_policy,
1686                                                 .bufsize = p->bufsize,
1687                                                 .numbufs = p->faxbuf_no
1688                                         };
1689                                         int res;
1690
1691                                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
1692                                                 ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast_channel_name(ast), strerror(errno));
1693                                         } else {
1694                                                 p->bufferoverrideinuse = 1;
1695                                         }
1696                                 }
1697                                 p->faxhandled = 1;
1698                                 if (p->dsp) {
1699                                         p->dsp_features &= ~DSP_FEATURE_FAX_DETECT;
1700                                         ast_dsp_set_features(p->dsp, p->dsp_features);
1701                                         ast_debug(1, "Disabling FAX tone detection on %s after tone received\n", ast_channel_name(ast));
1702                                 }
1703                                 if (strcmp(ast_channel_exten(ast), "fax")) {
1704                                         const char *target_context = S_OR(ast_channel_macrocontext(ast), ast_channel_context(ast));
1705
1706                                         /* We need to unlock 'ast' here because ast_exists_extension has the
1707                                          * potential to start autoservice on the channel. Such action is prone
1708                                          * to deadlock.
1709                                          */
1710                                         ast_mutex_unlock(&p->lock);
1711                                         ast_channel_unlock(ast);
1712                                         if (ast_exists_extension(ast, target_context, "fax", 1,
1713                                                 S_COR(ast_channel_caller(ast)->id.number.valid, ast_channel_caller(ast)->id.number.str, NULL))) {
1714                                                 ast_channel_lock(ast);
1715                                                 ast_mutex_lock(&p->lock);
1716                                                 ast_verb(3, "Redirecting %s to fax extension\n", ast_channel_name(ast));
1717                                                 /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
1718                                                 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
1719                                                 if (ast_async_goto(ast, target_context, "fax", 1))
1720                                                         ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(ast), target_context);
1721                                         } else {
1722                                                 ast_channel_lock(ast);
1723                                                 ast_mutex_lock(&p->lock);
1724                                                 ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
1725                                         }
1726                                 } else {
1727                                         ast_debug(1, "Already in a fax extension, not redirecting\n");
1728                                 }
1729                         } else {
1730                                 ast_debug(1, "Fax already handled\n");
1731                         }
1732                         dahdi_confmute(p, 0);
1733                 }
1734                 p->subs[idx].f.frametype = AST_FRAME_NULL;
1735                 p->subs[idx].f.subclass.integer = 0;
1736                 *dest = &p->subs[idx].f;
1737         }
1738 }
1739
1740 static void my_lock_private(void *pvt)
1741 {
1742         struct dahdi_pvt *p = pvt;
1743         ast_mutex_lock(&p->lock);
1744 }
1745
1746 static void my_unlock_private(void *pvt)
1747 {
1748         struct dahdi_pvt *p = pvt;
1749         ast_mutex_unlock(&p->lock);
1750 }
1751
1752 static void my_deadlock_avoidance_private(void *pvt)
1753 {
1754         struct dahdi_pvt *p = pvt;
1755
1756         DEADLOCK_AVOIDANCE(&p->lock);
1757 }
1758
1759 static struct ast_manager_event_blob *dahdichannel_to_ami(struct stasis_message *msg)
1760 {
1761         RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
1762         struct ast_channel_blob *obj = stasis_message_data(msg);
1763         struct ast_json *span, *channel;
1764
1765         channel_string = ast_manager_build_channel_state_string(obj->snapshot);
1766         if (!channel_string) {
1767                 return NULL;
1768         }
1769
1770         span = ast_json_object_get(obj->blob, "span");
1771         channel = ast_json_object_get(obj->blob, "channel");
1772
1773         return ast_manager_event_blob_create(EVENT_FLAG_CALL, "DAHDIChannel",
1774                 "%s"
1775                 "DAHDISpan: %u\r\n"
1776                 "DAHDIChannel: %s\r\n",
1777                 ast_str_buffer(channel_string),
1778                 (unsigned int)ast_json_integer_get(span),
1779                 ast_json_string_get(channel));
1780 }
1781
1782 STASIS_MESSAGE_TYPE_DEFN_LOCAL(dahdichannel_type,
1783         .to_ami = dahdichannel_to_ami,
1784         );
1785
1786 /*! \brief Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages */
1787 static void publish_dahdichannel(struct ast_channel *chan, int span, const char *dahdi_channel)
1788 {
1789         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
1790
1791         ast_assert(dahdi_channel != NULL);
1792
1793         blob = ast_json_pack("{s: i, s: s}",
1794                 "span", span,
1795                 "channel", dahdi_channel);
1796         if (!blob) {
1797                 return;
1798         }
1799
1800         ast_channel_lock(chan);
1801         ast_channel_publish_blob(chan, dahdichannel_type(), blob);
1802         ast_channel_unlock(chan);
1803 }
1804
1805 /*!
1806  * \internal
1807  * \brief Post an AMI DAHDI channel association event.
1808  * \since 1.8
1809  *
1810  * \param p DAHDI private pointer
1811  * \param chan Channel associated with the private pointer
1812  *
1813  * \return Nothing
1814  */
1815 static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
1816 {
1817         char ch_name[20];
1818
1819         if (p->channel < CHAN_PSEUDO) {
1820                 /* No B channel */
1821                 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
1822         } else if (p->channel == CHAN_PSEUDO) {
1823                 /* Pseudo channel */
1824                 strcpy(ch_name, "pseudo");
1825         } else {
1826                 /* Real channel */
1827                 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
1828         }
1829         publish_dahdichannel(chan, p->span, ch_name);
1830 }
1831
1832 #ifdef HAVE_PRI
1833 /*!
1834  * \internal
1835  * \brief Post an AMI DAHDI channel association event.
1836  * \since 1.8
1837  *
1838  * \param pvt DAHDI private pointer
1839  * \param chan Channel associated with the private pointer
1840  *
1841  * \return Nothing
1842  */
1843 static void my_ami_channel_event(void *pvt, struct ast_channel *chan)
1844 {
1845         struct dahdi_pvt *p = pvt;
1846
1847         dahdi_ami_channel_event(p, chan);
1848 }
1849 #endif
1850
1851 /* linear_mode = 0 - turn linear mode off, >0 - turn linear mode on
1852 *       returns the last value of the linear setting
1853 */
1854 static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
1855 {
1856         struct dahdi_pvt *p = pvt;
1857         int oldval;
1858         int idx = analogsub_to_dahdisub(sub);
1859
1860         dahdi_setlinear(p->subs[idx].dfd, linear_mode);
1861         oldval = p->subs[idx].linear;
1862         p->subs[idx].linear = linear_mode ? 1 : 0;
1863         return oldval;
1864 }
1865
1866 static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
1867 {
1868         struct dahdi_pvt *p = pvt;
1869         int idx = analogsub_to_dahdisub(sub);
1870
1871         p->subs[idx].inthreeway = inthreeway;
1872 }
1873
1874 static int get_alarms(struct dahdi_pvt *p);
1875 static void handle_alarms(struct dahdi_pvt *p, int alms);
1876 static void my_get_and_handle_alarms(void *pvt)
1877 {
1878         int res;
1879         struct dahdi_pvt *p = pvt;
1880
1881         res = get_alarms(p);
1882         handle_alarms(p, res);
1883 }
1884
1885 static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
1886 {
1887         RAII_VAR(struct ast_channel *, bridged, ast_channel_bridge_peer(chan), ast_channel_cleanup);
1888
1889         if (bridged && ast_channel_tech(bridged) == &dahdi_tech) {
1890                 struct dahdi_pvt *p = ast_channel_tech_pvt(bridged);
1891
1892                 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
1893                         return p->sig_pvt;
1894                 }
1895         }
1896         return NULL;
1897 }
1898
1899 static int my_get_sub_fd(void *pvt, enum analog_sub sub)
1900 {
1901         struct dahdi_pvt *p = pvt;
1902         int dahdi_sub = analogsub_to_dahdisub(sub);
1903         return p->subs[dahdi_sub].dfd;
1904 }
1905
1906 static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
1907 {
1908         struct dahdi_pvt *p = pvt;
1909
1910         /* Choose proper cadence */
1911         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
1912                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
1913                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast_channel_name(ast), strerror(errno));
1914                 *cid_rings = cidrings[p->distinctivering - 1];
1915         } else {
1916                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
1917                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast_channel_name(ast), strerror(errno));
1918                 *cid_rings = p->sendcalleridafter;
1919         }
1920 }
1921
1922 static void my_set_alarm(void *pvt, int in_alarm)
1923 {
1924         struct dahdi_pvt *p = pvt;
1925
1926         p->inalarm = in_alarm;
1927 }
1928
1929 static void my_set_dialing(void *pvt, int is_dialing)
1930 {
1931         struct dahdi_pvt *p = pvt;
1932
1933         p->dialing = is_dialing;
1934 }
1935
1936 static void my_set_outgoing(void *pvt, int is_outgoing)
1937 {
1938         struct dahdi_pvt *p = pvt;
1939
1940         p->outgoing = is_outgoing;
1941 }
1942
1943 #if defined(HAVE_PRI) || defined(HAVE_SS7)
1944 static void my_set_digital(void *pvt, int is_digital)
1945 {
1946         struct dahdi_pvt *p = pvt;
1947
1948         p->digital = is_digital;
1949 }
1950 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
1951
1952 #if defined(HAVE_SS7)
1953 static void my_set_inservice(void *pvt, int is_inservice)
1954 {
1955         struct dahdi_pvt *p = pvt;
1956
1957         p->inservice = is_inservice;
1958 }
1959 #endif  /* defined(HAVE_SS7) */
1960
1961 #if defined(HAVE_SS7)
1962 static void my_set_locallyblocked(void *pvt, int is_blocked)
1963 {
1964         struct dahdi_pvt *p = pvt;
1965
1966         p->locallyblocked = is_blocked;
1967 }
1968 #endif  /* defined(HAVE_SS7) */
1969
1970 #if defined(HAVE_SS7)
1971 static void my_set_remotelyblocked(void *pvt, int is_blocked)
1972 {
1973         struct dahdi_pvt *p = pvt;
1974
1975         p->remotelyblocked = is_blocked;
1976 }
1977 #endif  /* defined(HAVE_SS7) */
1978
1979 static void my_set_ringtimeout(void *pvt, int ringt)
1980 {
1981         struct dahdi_pvt *p = pvt;
1982         p->ringt = ringt;
1983 }
1984
1985 static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
1986 {
1987         struct dahdi_pvt *p = pvt;
1988
1989         if (p->waitfordialtone && CANPROGRESSDETECT(p) && p->dsp) {
1990                 ast_debug(1, "Defer dialing for %dms or dialtone\n", p->waitfordialtone);
1991                 gettimeofday(&p->waitingfordt, NULL);
1992                 ast_setstate(ast, AST_STATE_OFFHOOK);
1993         }
1994 }
1995
1996 static int my_check_waitingfordt(void *pvt)
1997 {
1998         struct dahdi_pvt *p = pvt;
1999
2000         if (p->waitingfordt.tv_sec) {
2001                 return 1;
2002         }
2003
2004         return 0;
2005 }
2006
2007 static void my_set_confirmanswer(void *pvt, int flag)
2008 {
2009         struct dahdi_pvt *p = pvt;
2010         p->confirmanswer = flag;
2011 }
2012
2013 static int my_check_confirmanswer(void *pvt)
2014 {
2015         struct dahdi_pvt *p = pvt;
2016         if (p->confirmanswer) {
2017                 return 1;
2018         }
2019
2020         return 0;
2021 }
2022
2023 static void my_set_callwaiting(void *pvt, int callwaiting_enable)
2024 {
2025         struct dahdi_pvt *p = pvt;
2026
2027         p->callwaiting = callwaiting_enable;
2028 }
2029
2030 static void my_cancel_cidspill(void *pvt)
2031 {
2032         struct dahdi_pvt *p = pvt;
2033
2034         ast_free(p->cidspill);
2035         p->cidspill = NULL;
2036         restore_conference(p);
2037 }
2038
2039 static int my_confmute(void *pvt, int mute)
2040 {
2041         struct dahdi_pvt *p = pvt;
2042         return dahdi_confmute(p, mute);
2043 }
2044
2045 static void my_set_pulsedial(void *pvt, int flag)
2046 {
2047         struct dahdi_pvt *p = pvt;
2048         p->pulsedial = flag;
2049 }
2050
2051 static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
2052 {
2053         struct dahdi_pvt *p = pvt;
2054
2055         p->owner = new_owner;
2056 }
2057
2058 static const char *my_get_orig_dialstring(void *pvt)
2059 {
2060         struct dahdi_pvt *p = pvt;
2061
2062         return p->dialstring;
2063 }
2064
2065 static void my_increase_ss_count(void)
2066 {
2067         ast_mutex_lock(&ss_thread_lock);
2068         ss_thread_count++;
2069         ast_mutex_unlock(&ss_thread_lock);
2070 }
2071
2072 static void my_decrease_ss_count(void)
2073 {
2074         ast_mutex_lock(&ss_thread_lock);
2075         ss_thread_count--;
2076         ast_cond_signal(&ss_thread_complete);
2077         ast_mutex_unlock(&ss_thread_lock);
2078 }
2079
2080 static void my_all_subchannels_hungup(void *pvt)
2081 {
2082         struct dahdi_pvt *p = pvt;
2083         int res, law;
2084
2085         p->faxhandled = 0;
2086         p->didtdd = 0;
2087
2088         if (p->dsp) {
2089                 ast_dsp_free(p->dsp);
2090                 p->dsp = NULL;
2091         }
2092
2093         p->law = p->law_default;
2094         law = p->law_default;
2095         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
2096         if (res < 0)
2097                 ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
2098
2099         dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
2100
2101 #if 1
2102         {
2103         int i;
2104         p->owner = NULL;
2105         /* Cleanup owners here */
2106         for (i = 0; i < 3; i++) {
2107                 p->subs[i].owner = NULL;
2108         }
2109         }
2110 #endif
2111
2112         reset_conf(p);
2113         if (num_restart_pending == 0) {
2114                 restart_monitor();
2115         }
2116 }
2117
2118 static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);
2119
2120 static int my_conf_del(void *pvt, enum analog_sub sub)
2121 {
2122         struct dahdi_pvt *p = pvt;
2123         int x = analogsub_to_dahdisub(sub);
2124
2125         return conf_del(p, &p->subs[x], x);
2126 }
2127
2128 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);
2129
2130 static int my_conf_add(void *pvt, enum analog_sub sub)
2131 {
2132         struct dahdi_pvt *p = pvt;
2133         int x = analogsub_to_dahdisub(sub);
2134
2135         return conf_add(p, &p->subs[x], x, 0);
2136 }
2137
2138 static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);
2139
2140 static int my_complete_conference_update(void *pvt, int needconference)
2141 {
2142         struct dahdi_pvt *p = pvt;
2143         int needconf = needconference;
2144         int x;
2145         int useslavenative;
2146         struct dahdi_pvt *slave = NULL;
2147
2148         useslavenative = isslavenative(p, &slave);
2149
2150         /* If we have a slave, add him to our conference now. or DAX
2151            if this is slave native */
2152         for (x = 0; x < MAX_SLAVES; x++) {
2153                 if (p->slaves[x]) {
2154                         if (useslavenative)
2155                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
2156                         else {
2157                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
2158                                 needconf++;
2159                         }
2160                 }
2161         }
2162         /* If we're supposed to be in there, do so now */
2163         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
2164                 if (useslavenative)
2165                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
2166                 else {
2167                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
2168                         needconf++;
2169                 }
2170         }
2171         /* If we have a master, add ourselves to his conference */
2172         if (p->master) {
2173                 if (isslavenative(p->master, NULL)) {
2174                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
2175                 } else {
2176                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
2177                 }
2178         }
2179         if (!needconf) {
2180                 /* Nobody is left (or should be left) in our conference.
2181                    Kill it. */
2182                 p->confno = -1;
2183         }
2184
2185         return 0;
2186 }
2187
2188 static int check_for_conference(struct dahdi_pvt *p);
2189
2190 static int my_check_for_conference(void *pvt)
2191 {
2192         struct dahdi_pvt *p = pvt;
2193         return check_for_conference(p);
2194 }
2195
2196 static void my_swap_subchannels(void *pvt, enum analog_sub a, struct ast_channel *ast_a,  enum analog_sub b, struct ast_channel *ast_b)
2197 {
2198         struct dahdi_pvt *p = pvt;
2199         int da, db;
2200         int tchan;
2201         int tinthreeway;
2202
2203         da = analogsub_to_dahdisub(a);
2204         db = analogsub_to_dahdisub(b);
2205
2206         tchan = p->subs[da].chan;
2207         p->subs[da].chan = p->subs[db].chan;
2208         p->subs[db].chan = tchan;
2209
2210         tinthreeway = p->subs[da].inthreeway;
2211         p->subs[da].inthreeway = p->subs[db].inthreeway;
2212         p->subs[db].inthreeway = tinthreeway;
2213
2214         p->subs[da].owner = ast_a;
2215         p->subs[db].owner = ast_b;
2216
2217         if (ast_a)
2218                 ast_channel_set_fd(ast_a, 0, p->subs[da].dfd);
2219         if (ast_b)
2220                 ast_channel_set_fd(ast_b, 0, p->subs[db].dfd);
2221
2222         wakeup_sub(p, a);
2223         wakeup_sub(p, b);
2224
2225         return;
2226 }
2227
2228 /*!
2229  * \internal
2230  * \brief performs duties of dahdi_new, but also removes and possibly unbinds (if callid_created is 1) before returning
2231  * \note this variant of dahdi should only be used in conjunction with ast_callid_threadstorage_auto()
2232  *
2233  * \param callid_created value returned from ast_callid_threadstorage_auto()
2234  */
2235 static struct ast_channel *dahdi_new_callid_clean(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid, int callid_created);
2236
2237 static struct ast_channel *dahdi_new(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid);
2238
2239 static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
2240 {
2241         ast_callid callid = 0;
2242         int callid_created = ast_callid_threadstorage_auto(&callid);
2243         struct dahdi_pvt *p = pvt;
2244         int dsub = analogsub_to_dahdisub(sub);
2245
2246         return dahdi_new_callid_clean(p, state, startpbx, dsub, 0, NULL, requestor, callid, callid_created);
2247 }
2248
2249 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2250 static int dahdi_setlaw(int dfd, int law)
2251 {
2252         int res;
2253         res = ioctl(dfd, DAHDI_SETLAW, &law);
2254         if (res)
2255                 return res;
2256         return 0;
2257 }
2258 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2259
2260 #if defined(HAVE_PRI)
2261 static struct ast_channel *my_new_pri_ast_channel(void *pvt, int state,
2262         enum sig_pri_law law, char *exten, const struct ast_assigned_ids *assignedids,
2263         const struct ast_channel *requestor)
2264 {
2265         struct dahdi_pvt *p = pvt;
2266         int audio;
2267         int newlaw = -1;
2268         ast_callid callid = 0;
2269         int callid_created = ast_callid_threadstorage_auto(&callid);
2270
2271         switch (p->sig) {
2272         case SIG_PRI_LIB_HANDLE_CASES:
2273                 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
2274                         /* PRI nobch pseudo channel.  Does not handle ioctl(DAHDI_AUDIOMODE) */
2275                         break;
2276                 }
2277                 /* Fall through */
2278         default:
2279                 /* Set to audio mode at this point */
2280                 audio = 1;
2281                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1) {
2282                         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
2283                                 p->channel, audio, strerror(errno));
2284                 }
2285                 break;
2286         }
2287
2288         if (law != SIG_PRI_DEFLAW) {
2289                 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
2290         }
2291
2292         ast_copy_string(p->exten, exten, sizeof(p->exten));
2293
2294         switch (law) {
2295                 case SIG_PRI_DEFLAW:
2296                         newlaw = 0;
2297                         break;
2298                 case SIG_PRI_ALAW:
2299                         newlaw = DAHDI_LAW_ALAW;
2300                         break;
2301                 case SIG_PRI_ULAW:
2302                         newlaw = DAHDI_LAW_MULAW;
2303                         break;
2304         }
2305
2306         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
2307 }
2308 #endif  /* defined(HAVE_PRI) */
2309
2310 static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law);
2311
2312 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2313 /*!
2314  * \internal
2315  * \brief Open the PRI/SS7 channel media path.
2316  * \since 1.8
2317  *
2318  * \param p Channel private control structure.
2319  *
2320  * \return Nothing
2321  */
2322 static void my_pri_ss7_open_media(void *p)
2323 {
2324         struct dahdi_pvt *pvt = p;
2325         int res;
2326         int dfd;
2327         int set_val;
2328
2329         dfd = pvt->subs[SUB_REAL].dfd;
2330
2331         /* Open the media path. */
2332         set_val = 1;
2333         res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
2334         if (res < 0) {
2335                 ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n",
2336                         pvt->channel, strerror(errno));
2337         }
2338
2339         /* Set correct companding law for this call. */
2340         res = dahdi_setlaw(dfd, pvt->law);
2341         if (res < 0) {
2342                 ast_log(LOG_WARNING, "Unable to set law on channel %d\n", pvt->channel);
2343         }
2344
2345         /* Set correct gain for this call. */
2346         if (pvt->digital) {
2347                 res = set_actual_gain(dfd, 0, 0, pvt->rxdrc, pvt->txdrc, pvt->law);
2348         } else {
2349                 res = set_actual_gain(dfd, pvt->rxgain, pvt->txgain, pvt->rxdrc, pvt->txdrc,
2350                         pvt->law);
2351         }
2352         if (res < 0) {
2353                 ast_log(LOG_WARNING, "Unable to set gains on channel %d\n", pvt->channel);
2354         }
2355
2356         if (pvt->dsp_features && pvt->dsp) {
2357                 ast_dsp_set_features(pvt->dsp, pvt->dsp_features);
2358                 pvt->dsp_features = 0;
2359         }
2360 }
2361 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2362
2363 #if defined(HAVE_PRI)
2364 /*!
2365  * \internal
2366  * \brief Ask DAHDI to dial the given dial string.
2367  * \since 1.8.11
2368  *
2369  * \param p Channel private control structure.
2370  * \param dial_string String to pass to DAHDI to dial.
2371  *
2372  * \note The channel private lock needs to be held when calling.
2373  *
2374  * \return Nothing
2375  */
2376 static void my_pri_dial_digits(void *p, const char *dial_string)
2377 {
2378         char dial_str[DAHDI_MAX_DTMF_BUF];
2379         struct dahdi_pvt *pvt = p;
2380         int res;
2381
2382         snprintf(dial_str, sizeof(dial_str), "T%s", dial_string);
2383         res = dahdi_dial_str(pvt, DAHDI_DIAL_OP_APPEND, dial_str);
2384         if (!res) {
2385                 pvt->dialing = 1;
2386         }
2387 }
2388 #endif  /* defined(HAVE_PRI) */
2389
2390 static int unalloc_sub(struct dahdi_pvt *p, int x);
2391
2392 static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
2393 {
2394         struct dahdi_pvt *p = pvt;
2395
2396         return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
2397 }
2398
2399 static int alloc_sub(struct dahdi_pvt *p, int x);
2400
2401 static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
2402 {
2403         struct dahdi_pvt *p = pvt;
2404
2405         return alloc_sub(p, analogsub_to_dahdisub(analogsub));
2406 }
2407
2408 static int has_voicemail(struct dahdi_pvt *p);
2409
2410 static int my_has_voicemail(void *pvt)
2411 {
2412         struct dahdi_pvt *p = pvt;
2413
2414         return has_voicemail(p);
2415 }
2416
2417 static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
2418 {
2419         struct dahdi_pvt *p = pvt;
2420         int index;
2421
2422         index = analogsub_to_dahdisub(sub);
2423
2424         return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
2425 }
2426
2427 static enum analog_event dahdievent_to_analogevent(int event)
2428 {
2429         enum analog_event res;
2430
2431         switch (event) {
2432         case DAHDI_EVENT_ONHOOK:
2433                 res = ANALOG_EVENT_ONHOOK;
2434                 break;
2435         case DAHDI_EVENT_RINGOFFHOOK:
2436                 res = ANALOG_EVENT_RINGOFFHOOK;
2437                 break;
2438         case DAHDI_EVENT_WINKFLASH:
2439                 res = ANALOG_EVENT_WINKFLASH;
2440                 break;
2441         case DAHDI_EVENT_ALARM:
2442                 res = ANALOG_EVENT_ALARM;
2443                 break;
2444         case DAHDI_EVENT_NOALARM:
2445                 res = ANALOG_EVENT_NOALARM;
2446                 break;
2447         case DAHDI_EVENT_DIALCOMPLETE:
2448                 res = ANALOG_EVENT_DIALCOMPLETE;
2449                 break;
2450         case DAHDI_EVENT_RINGERON:
2451                 res = ANALOG_EVENT_RINGERON;
2452                 break;
2453         case DAHDI_EVENT_RINGEROFF:
2454                 res = ANALOG_EVENT_RINGEROFF;
2455                 break;
2456         case DAHDI_EVENT_HOOKCOMPLETE:
2457                 res = ANALOG_EVENT_HOOKCOMPLETE;
2458                 break;
2459         case DAHDI_EVENT_PULSE_START:
2460                 res = ANALOG_EVENT_PULSE_START;
2461                 break;
2462         case DAHDI_EVENT_POLARITY:
2463                 res = ANALOG_EVENT_POLARITY;
2464                 break;
2465         case DAHDI_EVENT_RINGBEGIN:
2466                 res = ANALOG_EVENT_RINGBEGIN;
2467                 break;
2468         case DAHDI_EVENT_EC_DISABLED:
2469                 res = ANALOG_EVENT_EC_DISABLED;
2470                 break;
2471         case DAHDI_EVENT_REMOVED:
2472                 res = ANALOG_EVENT_REMOVED;
2473                 break;
2474         case DAHDI_EVENT_NEONMWI_ACTIVE:
2475                 res = ANALOG_EVENT_NEONMWI_ACTIVE;
2476                 break;
2477         case DAHDI_EVENT_NEONMWI_INACTIVE:
2478                 res = ANALOG_EVENT_NEONMWI_INACTIVE;
2479                 break;
2480 #ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2481         case DAHDI_EVENT_TX_CED_DETECTED:
2482                 res = ANALOG_EVENT_TX_CED_DETECTED;
2483                 break;
2484         case DAHDI_EVENT_RX_CED_DETECTED:
2485                 res = ANALOG_EVENT_RX_CED_DETECTED;
2486                 break;
2487         case DAHDI_EVENT_EC_NLP_DISABLED:
2488                 res = ANALOG_EVENT_EC_NLP_DISABLED;
2489                 break;
2490         case DAHDI_EVENT_EC_NLP_ENABLED:
2491                 res = ANALOG_EVENT_EC_NLP_ENABLED;
2492                 break;
2493 #endif
2494         case DAHDI_EVENT_PULSEDIGIT:
2495                 res = ANALOG_EVENT_PULSEDIGIT;
2496                 break;
2497         case DAHDI_EVENT_DTMFDOWN:
2498                 res = ANALOG_EVENT_DTMFDOWN;
2499                 break;
2500         case DAHDI_EVENT_DTMFUP:
2501                 res = ANALOG_EVENT_DTMFUP;
2502                 break;
2503         default:
2504                 switch(event & 0xFFFF0000) {
2505                 case DAHDI_EVENT_PULSEDIGIT:
2506                 case DAHDI_EVENT_DTMFDOWN:
2507                 case DAHDI_EVENT_DTMFUP:
2508                         /* The event includes a digit number in the low word.
2509                          * Converting it to a 'enum analog_event' would remove
2510                          * that information. Thus it is returned as-is.
2511                          */
2512                         return event;
2513                 }
2514
2515                 res = ANALOG_EVENT_ERROR;
2516                 break;
2517         }
2518
2519         return res;
2520 }
2521
2522 static inline int dahdi_wait_event(int fd);
2523
2524 static int my_wait_event(void *pvt)
2525 {
2526         struct dahdi_pvt *p = pvt;
2527
2528         return dahdi_wait_event(p->subs[SUB_REAL].dfd);
2529 }
2530
2531 static int my_get_event(void *pvt)
2532 {
2533         struct dahdi_pvt *p = pvt;
2534         int res;
2535
2536         if (p->fake_event) {
2537                 res = p->fake_event;
2538                 p->fake_event = 0;
2539         } else
2540                 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
2541
2542         return dahdievent_to_analogevent(res);
2543 }
2544
2545 static int my_is_off_hook(void *pvt)
2546 {
2547         struct dahdi_pvt *p = pvt;
2548         int res;
2549         struct dahdi_params par;
2550
2551         memset(&par, 0, sizeof(par));
2552
2553         if (p->subs[SUB_REAL].dfd > -1)
2554                 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
2555         else {
2556                 /* Assume not off hook on CVRS */
2557                 res = 0;
2558                 par.rxisoffhook = 0;
2559         }
2560         if (res) {
2561                 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
2562         }
2563
2564         if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
2565                 /* When "onhook" that means no battery on the line, and thus
2566                 it is out of service..., if it's on a TDM card... If it's a channel
2567                 bank, there is no telling... */
2568                 return (par.rxbits > -1) || par.rxisoffhook;
2569         }
2570
2571         return par.rxisoffhook;
2572 }
2573
2574 static int my_set_echocanceller(void *pvt, int enable)
2575 {
2576         struct dahdi_pvt *p = pvt;
2577
2578         if (enable)
2579                 dahdi_ec_enable(p);
2580         else
2581                 dahdi_ec_disable(p);
2582
2583         return 0;
2584 }
2585
2586 static int dahdi_ring_phone(struct dahdi_pvt *p);
2587
2588 static int my_ring(void *pvt)
2589 {
2590         struct dahdi_pvt *p = pvt;
2591
2592         return dahdi_ring_phone(p);
2593 }
2594
2595 static int my_flash(void *pvt)
2596 {
2597         struct dahdi_pvt *p = pvt;
2598         int func = DAHDI_FLASH;
2599         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
2600 }
2601
2602 static inline int dahdi_set_hook(int fd, int hs);
2603
2604 static int my_off_hook(void *pvt)
2605 {
2606         struct dahdi_pvt *p = pvt;
2607         return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
2608 }
2609
2610 static void my_set_needringing(void *pvt, int value)
2611 {
2612         struct dahdi_pvt *p = pvt;
2613         p->subs[SUB_REAL].needringing = value;
2614 }
2615
2616 static void my_set_polarity(void *pvt, int value)
2617 {
2618         struct dahdi_pvt *p = pvt;
2619
2620         if (p->channel == CHAN_PSEUDO) {
2621                 return;
2622         }
2623         p->polarity = value;
2624         ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETPOLARITY, &value);
2625 }
2626
2627 static void my_start_polarityswitch(void *pvt)
2628 {
2629         struct dahdi_pvt *p = pvt;
2630
2631         if (p->answeronpolarityswitch || p->hanguponpolarityswitch) {
2632                 my_set_polarity(pvt, 0);
2633         }
2634 }
2635
2636 static void my_answer_polarityswitch(void *pvt)
2637 {
2638         struct dahdi_pvt *p = pvt;
2639
2640         if (!p->answeronpolarityswitch) {
2641                 return;
2642         }
2643
2644         my_set_polarity(pvt, 1);
2645 }
2646
2647 static void my_hangup_polarityswitch(void *pvt)
2648 {
2649         struct dahdi_pvt *p = pvt;
2650
2651         if (!p->hanguponpolarityswitch) {
2652                 return;
2653         }
2654
2655         if (p->answeronpolarityswitch) {
2656                 my_set_polarity(pvt, 0);
2657         } else {
2658                 my_set_polarity(pvt, 1);
2659         }
2660 }
2661
2662 static int my_start(void *pvt)
2663 {
2664         struct dahdi_pvt *p = pvt;
2665         int x = DAHDI_START;
2666
2667         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
2668 }
2669
2670 static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
2671 {
2672         struct dahdi_pvt *p = pvt;
2673
2674         if (dop->op != ANALOG_DIAL_OP_REPLACE) {
2675                 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
2676                 return -1;
2677         }
2678
2679         if (sub != ANALOG_SUB_REAL) {
2680                 ast_log(LOG_ERROR, "Trying to dial_digits '%s' on channel %d subchannel %u\n",
2681                         dop->dialstr, p->channel, sub);
2682                 return -1;
2683         }
2684
2685         return dahdi_dial_str(p, DAHDI_DIAL_OP_REPLACE, dop->dialstr);
2686 }
2687
2688 static void dahdi_train_ec(struct dahdi_pvt *p);
2689
2690 static int my_train_echocanceller(void *pvt)
2691 {
2692         struct dahdi_pvt *p = pvt;
2693
2694         dahdi_train_ec(p);
2695
2696         return 0;
2697 }
2698
2699 static int my_is_dialing(void *pvt, enum analog_sub sub)
2700 {
2701         struct dahdi_pvt *p = pvt;
2702         int index;
2703         int x;
2704
2705         index = analogsub_to_dahdisub(sub);
2706
2707         if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
2708                 ast_debug(1, "DAHDI_DIALING ioctl failed!\n");
2709                 return -1;
2710         }
2711
2712         return x;
2713 }
2714
2715 static int my_on_hook(void *pvt)
2716 {
2717         struct dahdi_pvt *p = pvt;
2718         return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
2719 }
2720
2721 #if defined(HAVE_PRI)
2722 static void my_pri_fixup_chans(void *chan_old, void *chan_new)
2723 {
2724         struct dahdi_pvt *old_chan = chan_old;
2725         struct dahdi_pvt *new_chan = chan_new;
2726
2727         new_chan->owner = old_chan->owner;
2728         old_chan->owner = NULL;
2729         if (new_chan->owner) {
2730                 ast_channel_tech_pvt_set(new_chan->owner, new_chan);
2731                 ast_channel_internal_fd_set(new_chan->owner, 0, new_chan->subs[SUB_REAL].dfd);
2732                 new_chan->subs[SUB_REAL].owner = old_chan->subs[SUB_REAL].owner;
2733                 old_chan->subs[SUB_REAL].owner = NULL;
2734         }
2735         /* Copy any DSP that may be present */
2736         new_chan->dsp = old_chan->dsp;
2737         new_chan->dsp_features = old_chan->dsp_features;
2738         old_chan->dsp = NULL;
2739         old_chan->dsp_features = 0;
2740
2741         /* Transfer flags from the old channel. */
2742         new_chan->dialing = old_chan->dialing;
2743         new_chan->digital = old_chan->digital;
2744         new_chan->outgoing = old_chan->outgoing;
2745         old_chan->dialing = 0;
2746         old_chan->digital = 0;
2747         old_chan->outgoing = 0;
2748
2749         /* More stuff to transfer to the new channel. */
2750         new_chan->law = old_chan->law;
2751         strcpy(new_chan->dialstring, old_chan->dialstring);
2752 }
2753 #endif  /* defined(HAVE_PRI) */
2754
2755 #if defined(HAVE_PRI)
2756 static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
2757 {
2758         switch (tone) {
2759         case SIG_PRI_TONE_RINGTONE:
2760                 return DAHDI_TONE_RINGTONE;
2761         case SIG_PRI_TONE_STUTTER:
2762                 return DAHDI_TONE_STUTTER;
2763         case SIG_PRI_TONE_CONGESTION:
2764                 return DAHDI_TONE_CONGESTION;
2765         case SIG_PRI_TONE_DIALTONE:
2766                 return DAHDI_TONE_DIALTONE;
2767         case SIG_PRI_TONE_DIALRECALL:
2768                 return DAHDI_TONE_DIALRECALL;
2769         case SIG_PRI_TONE_INFO:
2770                 return DAHDI_TONE_INFO;
2771         case SIG_PRI_TONE_BUSY:
2772                 return DAHDI_TONE_BUSY;
2773         default:
2774                 return -1;
2775         }
2776 }
2777 #endif  /* defined(HAVE_PRI) */
2778
2779 #if defined(HAVE_PRI)
2780 static void my_handle_dchan_exception(struct sig_pri_span *pri, int index)
2781 {
2782         int x;
2783
2784         ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
2785         switch (x) {
2786         case DAHDI_EVENT_NONE:
2787                 break;
2788         case DAHDI_EVENT_ALARM:
2789         case DAHDI_EVENT_NOALARM:
2790                 if (sig_pri_is_alarm_ignored(pri)) {
2791                         break;
2792                 }
2793                 /* Fall through */
2794         default:
2795                 ast_log(LOG_NOTICE, "Got DAHDI event: %s (%d) on D-channel of span %d\n",
2796                         event2str(x), x, pri->span);
2797                 break;
2798         }
2799         /* Keep track of alarm state */
2800         switch (x) {
2801         case DAHDI_EVENT_ALARM:
2802                 pri_event_alarm(pri, index, 0);
2803                 break;
2804         case DAHDI_EVENT_NOALARM:
2805                 pri_event_noalarm(pri, index, 0);
2806                 break;
2807         case DAHDI_EVENT_REMOVED:
2808                 pri_queue_for_destruction(pri);
2809                 break;
2810         default:
2811                 break;
2812         }
2813 }
2814 #endif  /* defined(HAVE_PRI) */
2815
2816 #if defined(HAVE_PRI)
2817 static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
2818 {
2819         struct dahdi_pvt *p = pvt;
2820
2821         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
2822 }
2823 #endif  /* defined(HAVE_PRI) */
2824
2825 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2826 /*!
2827  * \internal
2828  * \brief Set the caller id information.
2829  * \since 1.8
2830  *
2831  * \param pvt DAHDI private structure
2832  * \param caller Caller-id information to set.
2833  *
2834  * \return Nothing
2835  */
2836 static void my_set_callerid(void *pvt, const struct ast_party_caller *caller)
2837 {
2838         struct dahdi_pvt *p = pvt;
2839
2840         ast_copy_string(p->cid_num,
2841                 S_COR(caller->id.number.valid, caller->id.number.str, ""),
2842                 sizeof(p->cid_num));
2843         ast_copy_string(p->cid_name,
2844                 S_COR(caller->id.name.valid, caller->id.name.str, ""),
2845                 sizeof(p->cid_name));
2846         ast_copy_string(p->cid_subaddr,
2847                 S_COR(caller->id.subaddress.valid, caller->id.subaddress.str, ""),
2848                 sizeof(p->cid_subaddr));
2849         p->cid_ton = caller->id.number.plan;
2850         p->callingpres = ast_party_id_presentation(&caller->id);
2851         if (caller->id.tag) {
2852                 ast_copy_string(p->cid_tag, caller->id.tag, sizeof(p->cid_tag));
2853         }
2854         ast_copy_string(p->cid_ani,
2855                 S_COR(caller->ani.number.valid, caller->ani.number.str, ""),
2856                 sizeof(p->cid_ani));
2857         p->cid_ani2 = caller->ani2;
2858 }
2859 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2860
2861 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2862 /*!
2863  * \internal
2864  * \brief Set the Dialed Number Identifier.
2865  * \since 1.8
2866  *
2867  * \param pvt DAHDI private structure
2868  * \param dnid Dialed Number Identifier string.
2869  *
2870  * \return Nothing
2871  */
2872 static void my_set_dnid(void *pvt, const char *dnid)
2873 {
2874         struct dahdi_pvt *p = pvt;
2875
2876         ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
2877 }
2878 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2879
2880 #if defined(HAVE_PRI)
2881 /*!
2882  * \internal
2883  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
2884  * \since 1.8
2885  *
2886  * \param pvt DAHDI private structure
2887  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
2888  *
2889  * \return Nothing
2890  */
2891 static void my_set_rdnis(void *pvt, const char *rdnis)
2892 {
2893         struct dahdi_pvt *p = pvt;
2894
2895         ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
2896 }
2897 #endif  /* defined(HAVE_PRI) */
2898
2899 #if defined(HAVE_PRI)
2900 /*!
2901  * \internal
2902  * \brief Make a dialstring for native ISDN CC to recall properly.
2903  * \since 1.8
2904  *
2905  * \param priv Channel private control structure.
2906  * \param buf Where to put the modified dialstring.
2907  * \param buf_size Size of modified dialstring buffer.
2908  *
2909  * \details
2910  * original dialstring:
2911  * DAHDI/[i<span>-](g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2912  *
2913  * The modified dialstring will have prefixed the channel-group section
2914  * with the ISDN channel restriction.
2915  *
2916  * buf:
2917  * DAHDI/i<span>-(g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2918  *
2919  * The routine will check to see if the ISDN channel restriction is already
2920  * in the original dialstring.
2921  *
2922  * \return Nothing
2923  */
2924 static void my_pri_make_cc_dialstring(void *priv, char *buf, size_t buf_size)
2925 {
2926         char *dial;
2927         struct dahdi_pvt *pvt;
2928         AST_DECLARE_APP_ARGS(args,
2929                 AST_APP_ARG(tech);      /* channel technology token */
2930                 AST_APP_ARG(group);     /* channel/group token */
2931                 //AST_APP_ARG(ext);     /* extension token */
2932                 //AST_APP_ARG(opts);    /* options token */
2933                 //AST_APP_ARG(other);   /* Any remining unused arguments */
2934         );
2935
2936         pvt = priv;
2937         dial = ast_strdupa(pvt->dialstring);
2938         AST_NONSTANDARD_APP_ARGS(args, dial, '/');
2939         if (!args.tech) {
2940                 ast_copy_string(buf, pvt->dialstring, buf_size);
2941                 return;
2942         }
2943         if (!args.group) {
2944                 /* Append the ISDN span channel restriction to the dialstring. */
2945                 snprintf(buf, buf_size, "%s/i%d-", args.tech, pvt->pri->span);
2946                 return;
2947         }
2948         if (isdigit(args.group[0]) || args.group[0] == 'i' || strchr(args.group, '!')) {
2949                 /* The ISDN span channel restriction is not needed or already
2950                  * in the dialstring. */
2951                 ast_copy_string(buf, pvt->dialstring, buf_size);
2952                 return;
2953         }
2954         /* Insert the ISDN span channel restriction into the dialstring. */
2955         snprintf(buf, buf_size, "%s/i%d-%s", args.tech, pvt->pri->span, args.group);
2956 }
2957 #endif  /* defined(HAVE_PRI) */
2958
2959 #if defined(HAVE_PRI)
2960 /*!
2961  * \internal
2962  * \brief Reevaluate the PRI span device state.
2963  * \since 1.8
2964  *
2965  * \param pri Asterisk D channel control structure.
2966  *
2967  * \return Nothing
2968  *
2969  * \note Assumes the pri->lock is already obtained.
2970  */
2971 static void dahdi_pri_update_span_devstate(struct sig_pri_span *pri)
2972 {
2973         unsigned idx;
2974         unsigned num_b_chans;   /* Number of B channels provisioned on the span. */
2975         unsigned in_use;                /* Number of B channels in use on the span. */
2976         unsigned in_alarm;              /* TRUE if the span is in alarm condition. */
2977         enum ast_device_state new_state;
2978
2979         /* Count the number of B channels and the number of B channels in use. */
2980         num_b_chans = 0;
2981         in_use = 0;
2982         in_alarm = 1;
2983         for (idx = pri->numchans; idx--;) {
2984                 if (pri->pvts[idx] && !pri->pvts[idx]->no_b_channel) {
2985                         /* This is a B channel interface. */
2986                         ++num_b_chans;
2987                         if (!sig_pri_is_chan_available(pri->pvts[idx])) {
2988                                 ++in_use;
2989                         }
2990                         if (!pri->pvts[idx]->inalarm) {
2991                                 /* There is a channel that is not in alarm. */
2992                                 in_alarm = 0;
2993                         }
2994                 }
2995         }
2996
2997         /* Update the span congestion device state and report any change. */
2998         if (in_alarm) {
2999                 new_state = AST_DEVICE_UNAVAILABLE;
3000         } else {
3001                 new_state = num_b_chans == in_use ? AST_DEVICE_BUSY : AST_DEVICE_NOT_INUSE;
3002         }
3003         if (pri->congestion_devstate != new_state) {
3004                 pri->congestion_devstate = new_state;
3005                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/congestion", pri->span);
3006         }
3007 #if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
3008         /* Update the span threshold device state and report any change. */
3009         if (in_alarm) {
3010                 new_state = AST_DEVICE_UNAVAILABLE;
3011         } else if (!in_use) {
3012                 new_state = AST_DEVICE_NOT_INUSE;
3013         } else if (!pri->user_busy_threshold) {
3014                 new_state = in_use < num_b_chans ? AST_DEVICE_INUSE : AST_DEVICE_BUSY;
3015         } else {
3016                 new_state = in_use < pri->user_busy_threshold ? AST_DEVICE_INUSE
3017                         : AST_DEVICE_BUSY;
3018         }
3019         if (pri->threshold_devstate != new_state) {
3020                 pri->threshold_devstate = new_state;
3021                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/threshold", pri->span);
3022         }
3023 #endif  /* defined(THRESHOLD_DEVSTATE_PLACEHOLDER) */
3024 }
3025 #endif  /* defined(HAVE_PRI) */
3026
3027 #if defined(HAVE_PRI)
3028 /*!
3029  * \internal
3030  * \brief Reference this module.
3031  * \since 1.8
3032  *
3033  * \return Nothing
3034  */
3035 static void my_module_ref(void)
3036 {
3037         ast_module_ref(ast_module_info->self);
3038 }
3039 #endif  /* defined(HAVE_PRI) */
3040
3041 #if defined(HAVE_PRI)
3042 /*!
3043  * \internal
3044  * \brief Unreference this module.
3045  * \since 1.8
3046  *
3047  * \return Nothing
3048  */
3049 static void my_module_unref(void)
3050 {
3051         ast_module_unref(ast_module_info->self);
3052 }
3053 #endif  /* defined(HAVE_PRI) */
3054
3055 #if defined(HAVE_PRI)
3056 #if defined(HAVE_PRI_CALL_WAITING)
3057 static void my_pri_init_config(void *priv, struct sig_pri_span *pri);
3058 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
3059 static int dahdi_new_pri_nobch_channel(struct sig_pri_span *pri);
3060
3061 struct sig_pri_callback sig_pri_callbacks =
3062 {
3063         .handle_dchan_exception = my_handle_dchan_exception,
3064         .play_tone = my_pri_play_tone,
3065         .set_echocanceller = my_set_echocanceller,
3066         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
3067         .lock_private = my_lock_private,
3068         .unlock_private = my_unlock_private,
3069         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3070         .new_ast_channel = my_new_pri_ast_channel,
3071         .fixup_chans = my_pri_fixup_chans,
3072         .set_alarm = my_set_alarm,
3073         .set_dialing = my_set_dialing,
3074         .set_outgoing = my_set_outgoing,
3075         .set_digital = my_set_digital,
3076         .set_callerid = my_set_callerid,
3077         .set_dnid = my_set_dnid,
3078         .set_rdnis = my_set_rdnis,
3079         .new_nobch_intf = dahdi_new_pri_nobch_channel,
3080 #if defined(HAVE_PRI_CALL_WAITING)
3081         .init_config = my_pri_init_config,
3082 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
3083         .get_orig_dialstring = my_get_orig_dialstring,
3084         .make_cc_dialstring = my_pri_make_cc_dialstring,
3085         .update_span_devstate = dahdi_pri_update_span_devstate,
3086         .module_ref = my_module_ref,
3087         .module_unref = my_module_unref,
3088         .dial_digits = my_pri_dial_digits,
3089         .open_media = my_pri_ss7_open_media,
3090         .ami_channel_event = my_ami_channel_event,
3091         .destroy_later = pri_queue_for_destruction,
3092 };
3093 #endif  /* defined(HAVE_PRI) */
3094
3095 #if defined(HAVE_SS7)
3096 /*!
3097  * \internal
3098  * \brief Handle the SS7 link exception.
3099  * \since 1.8
3100  *
3101  * \param linkset Controlling linkset for the channel.
3102  * \param which Link index of the signaling channel.
3103  *
3104  * \return Nothing
3105  */
3106 static void my_handle_link_exception(struct sig_ss7_linkset *linkset, int which)
3107 {
3108         int event;
3109
3110         if (ioctl(linkset->fds[which], DAHDI_GETEVENT, &event)) {
3111                 ast_log(LOG_ERROR, "SS7: Error in exception retrieval on span %d/%d!\n",
3112                         linkset->span, which);
3113                 return;
3114         }
3115         switch (event) {
3116         case DAHDI_EVENT_NONE:
3117                 break;
3118         case DAHDI_EVENT_ALARM:
3119                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
3120                         event2str(event), event, linkset->span, which);
3121                 sig_ss7_link_alarm(linkset, which);
3122                 break;
3123         case DAHDI_EVENT_NOALARM:
3124                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
3125                         event2str(event), event, linkset->span, which);
3126                 sig_ss7_link_noalarm(linkset, which);
3127                 break;
3128         default:
3129                 ast_log(LOG_NOTICE, "SS7 got event: %s(%d) on span %d/%d\n",
3130                         event2str(event), event, linkset->span, which);
3131                 break;
3132         }
3133 }
3134 #endif  /* defined(HAVE_SS7) */
3135
3136 #if defined(HAVE_SS7)
3137 static void my_ss7_set_loopback(void *pvt, int enable)
3138 {
3139         struct dahdi_pvt *p = pvt;
3140
3141         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_LOOPBACK, &enable)) {
3142                 ast_log(LOG_WARNING, "Unable to set loopback on channel %d: %s\n", p->channel,
3143                         strerror(errno));
3144         }
3145 }
3146 #endif  /* defined(HAVE_SS7) */
3147
3148 #if defined(HAVE_SS7)
3149 /*!
3150  * \internal
3151  * \brief Find the linkset to which SS7 belongs.
3152  * \since 11.0
3153  *
3154  * \param ss7 structure to match on.
3155  *
3156  * \retval linkset if found.
3157  * \retval NULL if not found.
3158  */
3159 static struct sig_ss7_linkset *my_ss7_find_linkset(struct ss7 *ss7)
3160 {
3161         int idx;
3162
3163         if (!ss7) {
3164                 return NULL;
3165         }
3166
3167         for (idx = 0; idx < NUM_SPANS; ++idx) {
3168                 if (linksets[idx].ss7.ss7 == ss7) {
3169                         return &linksets[idx].ss7;
3170                 }
3171         }
3172         return NULL;
3173 }
3174 #endif  /* defined(HAVE_SS7) */
3175
3176 #if defined(HAVE_SS7)
3177 /*!
3178  * \internal
3179  * \brief Create a new asterisk channel structure for SS7.
3180  * \since 1.8
3181  *
3182  * \param pvt Private channel structure.
3183  * \param state Initial state of new channel.
3184  * \param law Combanding law to use.
3185  * \param exten Dialplan extension for incoming call.
3186  * \param requestor Channel requesting this new channel.
3187  *
3188  * \retval ast_channel on success.
3189  * \retval NULL on error.
3190  */
3191 static struct ast_channel *my_new_ss7_ast_channel(void *pvt, int state, enum sig_ss7_law law, char *exten, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
3192 {
3193         struct dahdi_pvt *p = pvt;
3194         int audio;
3195         int newlaw;
3196         ast_callid callid = 0;
3197         int callid_created = ast_callid_threadstorage_auto(&callid);
3198
3199         /* Set to audio mode at this point */
3200         audio = 1;
3201         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1)
3202                 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
3203                         p->channel, audio, strerror(errno));
3204
3205         if (law != SIG_SS7_DEFLAW) {
3206                 dahdi_setlaw(p->subs[SUB_REAL].dfd,
3207                         (law == SIG_SS7_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
3208         }
3209
3210         ast_copy_string(p->exten, exten, sizeof(p->exten));
3211
3212         newlaw = -1;
3213         switch (law) {
3214         case SIG_SS7_DEFLAW:
3215                 newlaw = 0;
3216                 break;
3217         case SIG_SS7_ALAW:
3218                 newlaw = DAHDI_LAW_ALAW;
3219                 break;
3220         case SIG_SS7_ULAW:
3221                 newlaw = DAHDI_LAW_MULAW;
3222                 break;
3223         }
3224         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
3225 }
3226 #endif  /* defined(HAVE_SS7) */
3227
3228 #if defined(HAVE_SS7)
3229 static int sig_ss7_tone_to_dahditone(enum sig_ss7_tone tone)
3230 {
3231         switch (tone) {
3232         case SIG_SS7_TONE_RINGTONE:
3233                 return DAHDI_TONE_RINGTONE;
3234         case SIG_SS7_TONE_STUTTER:
3235                 return DAHDI_TONE_STUTTER;
3236         case SIG_SS7_TONE_CONGESTION:
3237                 return DAHDI_TONE_CONGESTION;
3238         case SIG_SS7_TONE_DIALTONE:
3239                 return DAHDI_TONE_DIALTONE;
3240         case SIG_SS7_TONE_DIALRECALL:
3241                 return DAHDI_TONE_DIALRECALL;
3242         case SIG_SS7_TONE_INFO:
3243                 return DAHDI_TONE_INFO;
3244         case SIG_SS7_TONE_BUSY:
3245                 return DAHDI_TONE_BUSY;
3246         default:
3247                 return -1;
3248         }
3249 }
3250 #endif  /* defined(HAVE_SS7) */
3251
3252 #if defined(HAVE_SS7)
3253 static int my_ss7_play_tone(void *pvt, enum sig_ss7_tone tone)
3254 {
3255         struct dahdi_pvt *p = pvt;
3256
3257         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_ss7_tone_to_dahditone(tone));
3258 }
3259 #endif  /* defined(HAVE_SS7) */
3260
3261 #if defined(HAVE_SS7)
3262 struct sig_ss7_callback sig_ss7_callbacks =
3263 {
3264         .lock_private = my_lock_private,
3265         .unlock_private = my_unlock_private,
3266         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3267
3268         .set_echocanceller = my_set_echocanceller,
3269         .set_loopback = my_ss7_set_loopback,
3270
3271         .new_ast_channel = my_new_ss7_ast_channel,
3272         .play_tone = my_ss7_play_tone,
3273
3274         .handle_link_exception = my_handle_link_exception,
3275         .set_alarm = my_set_alarm,
3276         .set_dialing = my_set_dialing,
3277         .set_outgoing = my_set_outgoing,
3278         .set_digital = my_set_digital,
3279         .set_inservice = my_set_inservice,
3280         .set_locallyblocked = my_set_locallyblocked,
3281         .set_remotelyblocked = my_set_remotelyblocked,
3282         .set_callerid = my_set_callerid,
3283         .set_dnid = my_set_dnid,
3284         .open_media = my_pri_ss7_open_media,
3285         .find_linkset = my_ss7_find_linkset,
3286 };
3287 #endif  /* defined(HAVE_SS7) */
3288
3289 /*!
3290  * \brief Send MWI state change
3291  *
3292  * \param mailbox This is the mailbox associated with the FXO line that the
3293  *      MWI state has changed on.
3294  * \param thereornot This argument should simply be set to 1 or 0, to indicate
3295  *      whether there are messages waiting or not.
3296  *
3297  *  \return nothing
3298  *
3299  * This function does two things:
3300  *
3301  * 1) It generates an internal Asterisk event notifying any other module that
3302  *    cares about MWI that the state of a mailbox has changed.
3303  *
3304  * 2) It runs the script specified by the mwimonitornotify option to allow
3305  *    some custom handling of the state change.
3306  */
3307 static void notify_message(char *mailbox, int thereornot)
3308 {
3309         char s[sizeof(mwimonitornotify) + 80];
3310
3311         if (ast_strlen_zero(mailbox)) {
3312                 return;
3313         }
3314
3315         ast_publish_mwi_state(mailbox, NULL, thereornot, thereornot);
3316         if (!ast_strlen_zero(mwimonitornotify)) {
3317                 snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot);
3318                 ast_safe_system(s);
3319         }
3320 }
3321
3322 static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
3323 {
3324         struct dahdi_pvt *p = pvt;
3325
3326         if (neon_mwievent > -1 && !p->mwimonitor_neon)
3327                 return;
3328
3329         if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) {
3330                 ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox);
3331                 notify_message(p->mailbox, 1);
3332         } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) {
3333                 ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox);
3334                 notify_message(p->mailbox, 0);
3335         }
3336         /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */
3337         /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */
3338         if (neon_mwievent == -1 && p->mwimonitor_rpas) {
3339                 ast_hangup(chan);
3340                 return;
3341         }
3342 }
3343
3344 static int my_have_progressdetect(void *pvt)
3345 {
3346         struct dahdi_pvt *p = pvt;
3347
3348         if ((p->callprogress & CALLPROGRESS_PROGRESS)
3349                 && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
3350                 return 1;
3351         } else {
3352                 /* Don't have progress detection. */
3353                 return 0;
3354         }
3355 }
3356
3357 struct analog_callback analog_callbacks =
3358 {
3359         .play_tone = my_play_tone,
3360         .get_event = my_get_event,
3361         .wait_event = my_wait_event,
3362         .is_off_hook = my_is_off_hook,
3363         .set_echocanceller = my_set_echocanceller,
3364         .ring = my_ring,
3365         .flash = my_flash,
3366         .off_hook = my_off_hook,
3367         .dial_digits = my_dial_digits,
3368         .train_echocanceller = my_train_echocanceller,
3369         .on_hook = my_on_hook,
3370         .is_dialing = my_is_dialing,
3371         .allocate_sub = my_allocate_sub,
3372         .unallocate_sub = my_unallocate_sub,
3373         .swap_subs = my_swap_subchannels,
3374         .has_voicemail = my_has_voicemail,
3375         .check_for_conference = my_check_for_conference,
3376         .conf_add = my_conf_add,
3377         .conf_del = my_conf_del,
3378         .complete_conference_update = my_complete_conference_update,
3379         .start = my_start,
3380         .all_subchannels_hungup = my_all_subchannels_hungup,
3381         .lock_private = my_lock_private,
3382         .unlock_private = my_unlock_private,
3383         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3384         .handle_dtmf = my_handle_dtmf,
3385         .wink = my_wink,
3386         .new_ast_channel = my_new_analog_ast_channel,
3387         .dsp_set_digitmode = my_dsp_set_digitmode,
3388         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
3389         .send_callerid = my_send_callerid,
3390         .callwait = my_callwait,
3391         .stop_callwait = my_stop_callwait,
3392         .get_callerid = my_get_callerid,
3393         .start_cid_detect = my_start_cid_detect,
3394         .stop_cid_detect = my_stop_cid_detect,
3395         .handle_notify_message = my_handle_notify_message,
3396         .increase_ss_count = my_increase_ss_count,
3397         .decrease_ss_count = my_decrease_ss_count,
3398         .distinctive_ring = my_distinctive_ring,
3399         .set_linear_mode = my_set_linear_mode,
3400         .set_inthreeway = my_set_inthreeway,
3401         .get_and_handle_alarms = my_get_and_handle_alarms,
3402         .get_sigpvt_bridged_channel = my_get_sigpvt_bridged_channel,
3403         .get_sub_fd = my_get_sub_fd,
3404         .set_cadence = my_set_cadence,
3405         .set_alarm = my_set_alarm,
3406         .set_dialing = my_set_dialing,
3407         .set_outgoing = my_set_outgoing,
3408         .set_ringtimeout = my_set_ringtimeout,
3409         .set_waitingfordt = my_set_waitingfordt,
3410         .check_waitingfordt = my_check_waitingfordt,
3411         .set_confirmanswer = my_set_confirmanswer,
3412         .check_confirmanswer = my_check_confirmanswer,
3413         .set_callwaiting = my_set_callwaiting,
3414         .cancel_cidspill = my_cancel_cidspill,
3415         .confmute = my_confmute,
3416         .set_pulsedial = my_set_pulsedial,
3417         .set_new_owner = my_set_new_owner,
3418         .get_orig_dialstring = my_get_orig_dialstring,
3419         .set_needringing = my_set_needringing,
3420         .set_polarity = my_set_polarity,
3421         .start_polarityswitch = my_start_polarityswitch,
3422         .answer_polarityswitch = my_answer_polarityswitch,
3423         .hangup_polarityswitch = my_hangup_polarityswitch,
3424         .have_progressdetect = my_have_progressdetect,
3425 };
3426
3427 /*! Round robin search locations. */
3428 static struct dahdi_pvt *round_robin[32];
3429
3430 int _dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
3431 {
3432         int res;
3433         if (p->subs[SUB_REAL].owner == ast)
3434                 res = 0;
3435         else if (p->subs[SUB_CALLWAIT].owner == ast)
3436                 res = 1;
3437         else if (p->subs[SUB_THREEWAY].owner == ast)
3438                 res = 2;
3439         else {
3440                 res = -1;
3441                 if (!nullok)
3442                         ast_log(LOG_WARNING,
3443                                 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
3444                                 ast ? ast_channel_name(ast) : "", p->channel, fname, line);
3445         }
3446         return res;
3447 }
3448
3449 /*!
3450  * \internal
3451  * \brief Obtain the specified subchannel owner lock if the owner exists.
3452  *
3453  * \param pvt Channel private struct.
3454  * \param sub_idx Subchannel owner to lock.
3455  *
3456  * \note Assumes the pvt->lock is already obtained.
3457  *
3458  * \note
3459  * Because deadlock avoidance may have been necessary, you need to confirm
3460  * the state of things before continuing.
3461  *
3462  * \return Nothing
3463  */
3464 static void dahdi_lock_sub_owner(struct dahdi_pvt *pvt, int sub_idx)
3465 {
3466         for (;;) {
3467                 if (!pvt->subs[sub_idx].owner) {
3468                         /* No subchannel owner pointer */
3469                         break;
3470                 }
3471                 if (!ast_channel_trylock(pvt->subs[sub_idx].owner)) {
3472                         /* Got subchannel owner lock */
3473                         break;
3474                 }
3475                 /* We must unlock the private to avoid the possibility of a deadlock */
3476                 DEADLOCK_AVOIDANCE(&pvt->lock);
3477         }
3478 }
3479
3480 static void wakeup_sub(struct dahdi_pvt *p, int a)
3481 {
3482         dahdi_lock_sub_owner(p, a);
3483         if (p->subs[a].owner) {
3484                 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
3485                 ast_channel_unlock(p->subs[a].owner);
3486         }
3487 }
3488
3489 static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f)
3490 {
3491         for (;;) {
3492                 if (p->owner) {
3493                         if (ast_channel_trylock(p->owner)) {
3494                                 DEADLOCK_AVOIDANCE(&p->lock);
3495                         } else {
3496                                 ast_queue_frame(p->owner, f);
3497                                 ast_channel_unlock(p->owner);
3498                                 break;
3499                         }
3500                 } else
3501                         break;
3502         }
3503 }
3504
3505 static void publish_channel_alarm_clear(int channel)
3506 {
3507         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3508         RAII_VAR(struct ast_str *, dahdi_chan, ast_str_create(32), ast_free);
3509         if (!dahdi_chan) {
3510                 return;
3511         }
3512
3513         ast_str_set(&dahdi_chan, 0, "%d", channel);
3514         ast_log(LOG_NOTICE, "Alarm cleared on channel DAHDI/%d\n", channel);
3515         body = ast_json_pack("{s: s}", "DAHDIChannel", ast_str_buffer(dahdi_chan));
3516         if (!body) {
3517                 return;
3518         }
3519
3520         ast_manager_publish_event("AlarmClear", EVENT_FLAG_SYSTEM, body);
3521 }
3522
3523 static void publish_span_alarm_clear(int span)
3524 {
3525         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3526
3527         ast_log(LOG_NOTICE, "Alarm cleared on span %d\n", span);
3528         body = ast_json_pack("{s: i}", "Span", span);
3529         if (!body) {
3530                 return;
3531         }
3532
3533         ast_manager_publish_event("SpanAlarmClear", EVENT_FLAG_SYSTEM, body);
3534 }
3535
3536 static void handle_clear_alarms(struct dahdi_pvt *p)
3537 {
3538 #if defined(HAVE_PRI)
3539         if (dahdi_sig_pri_lib_handles(p->sig) && sig_pri_is_alarm_ignored(p->pri)) {
3540                 return;
3541         }
3542 #endif  /* defined(HAVE_PRI) */
3543
3544         if (report_alarms & REPORT_CHANNEL_ALARMS) {
3545                 publish_channel_alarm_clear(p->channel);
3546         }
3547         if (report_alarms & REPORT_SPAN_ALARMS && p->manages_span_alarms) {
3548                 publish_span_alarm_clear(p->span);
3549         }
3550 }
3551
3552 #ifdef HAVE_OPENR2
3553
3554 static int dahdi_r2_answer(struct dahdi_pvt *p)
3555 {
3556         int res = 0;
3557         /* openr2 1.1.0 and older does not even define OR2_LIB_INTERFACE
3558         * and does not has support for openr2_chan_answer_call_with_mode
3559         *  */
3560 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
3561         const char *double_answer = pbx_builtin_getvar_helper(p->owner, "MFCR2_DOUBLE_ANSWER");
3562         int wants_double_answer = ast_true(double_answer) ? 1 : 0;
3563         if (!double_answer) {
3564                 /* this still can result in double answer if the channel context
3565                 * was configured that way */
3566                 res = openr2_chan_answer_call(p->r2chan);
3567         } else if (wants_double_answer) {
3568                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
3569         } else {
3570                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
3571         }
3572 #else
3573         res = openr2_chan_answer_call(p->r2chan);
3574 #endif
3575         return res;
3576 }
3577
3578
3579
3580 /* should be called with the ast_channel locked */
3581 static openr2_calling_party_category_t dahdi_r2_get_channel_category(struct ast_channel *c)
3582 {
3583         openr2_calling_party_category_t cat;
3584         const char *catstr = pbx_builtin_getvar_helper(c, "MFCR2_CATEGORY");
3585         struct dahdi_pvt *p = ast_channel_tech_pvt(c);
3586         if (ast_strlen_zero(catstr)) {
3587                 ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
3588                                 ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3589                 return p->mfcr2_category;
3590         }
3591         if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
3592                 ast_log(LOG_WARNING, "Invalid category specified '%s' for chan %s, using default %s\n",
3593                                 catstr, ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3594                 return p->mfcr2_category;
3595         }
3596         ast_debug(1, "Using category %s\n", catstr);
3597         return cat;
3598 }
3599
3600 static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
3601 {
3602         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3603         ast_mutex_lock(&p->lock);
3604         if (p->mfcr2call) {
3605                 ast_mutex_unlock(&p->lock);
3606                 /* TODO: This can happen when some other thread just finished dahdi_request requesting this very same
3607                    interface but has not yet seized the line (dahdi_call), and the far end wins and seize the line,
3608                    can we avoid this somehow?, at this point when dahdi_call send the seize, it is likely that since
3609                    the other end will see our seize as a forced release and drop the call, we will see an invalid
3610                    pattern that will be seen and treated as protocol error. */
3611                 ast_log(LOG_ERROR, "Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
3612                 return;
3613         }
3614         p->mfcr2call = 1;
3615         /* better safe than sorry ... */
3616         p->cid_name[0] = '\0';
3617         p->cid_num[0] = '\0';
3618         p->cid_subaddr[0] = '\0';
3619         p->rdnis[0] = '\0';
3620         p->exten[0] = '\0';
3621         p->mfcr2_ani_index = '\0';
3622         p->mfcr2_dnis_index = '\0';
3623         p->mfcr2_dnis_matched = 0;
3624         p->mfcr2_answer_pending = 0;
3625         p->mfcr2_call_accepted = 0;
3626         ast_mutex_unlock(&p->lock);
3627         ast_verbose("New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
3628 }
3629
3630 static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm)
3631 {
3632         int res;
3633         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3634         ast_mutex_lock(&p->lock);
3635         p->inalarm = alarm ? 1 : 0;
3636         if (p->inalarm) {
3637                 res = get_alarms(p);
3638                 handle_alarms(p, res);
3639         } else {
3640                 handle_clear_alarms(p);
3641         }
3642         ast_mutex_unlock(&p->lock);
3643 }
3644
3645 static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
3646 {
3647         ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
3648 }
3649
3650 static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
3651 {
3652         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3653         ast_log(LOG_ERROR, "MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
3654         if (p->owner) {
3655                 ast_channel_hangupcause_set(p->owner, AST_CAUSE_PROTOCOL_ERROR);
3656                 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
3657         }
3658         ast_mutex_lock(&p->lock);
3659         p->mfcr2call = 0;
3660         ast_mutex_unlock(&p->lock);
3661 }
3662
3663 static void dahdi_r2_disconnect_call(struct dahdi_pvt *p, openr2_call_disconnect_cause_t cause)
3664 {
3665         if (openr2_chan_disconnect_call(p->r2chan, cause)) {
3666                 ast_log(LOG_NOTICE, "Bad! failed to disconnect call on channel %d with reason %s, hope for the best!\n",
3667                    p->channel, openr2_proto_get_disconnect_string(cause));
3668                 /* force the chan to idle and release the call flag now since we will not see a clean on_call_end */
3669                 openr2_chan_set_idle(p->r2chan);
3670                 ast_mutex_lock(&p->lock);
3671                 p->mfcr2call = 0;
3672                 ast_mutex_unlock(&p->lock);
3673         }
3674 }
3675
3676 static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category)
3677 {
3678         struct dahdi_pvt *p;
3679         struct ast_channel *c;
3680         ast_callid callid = 0;
3681         int callid_created = ast_callid_threadstorage_auto(&callid);
3682         ast_verbose("MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
3683                         openr2_chan_get_number(r2chan), ani ? ani : "(restricted)", dnis,
3684                         openr2_proto_get_category_string(category));
3685         p = openr2_chan_get_client_data(r2chan);
3686         /* if collect calls are not allowed and this is a collect call, reject it! */
3687         if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
3688                 ast_log(LOG_NOTICE, "Rejecting MFC/R2 collect call\n");
3689                 dahdi_r2_disconnect_call(p, OR2_CAUSE_COLLECT_CALL_REJECTED);
3690                 goto dahdi_r2_on_call_offered_cleanup;
3691         }
3692         ast_mutex_lock(&p->lock);
3693         p->mfcr2_recvd_category = category;
3694         /* if we're not supposed to use CID, clear whatever we have */
3695         if (!p->use_callerid) {
3696                 ast_debug(1, "No CID allowed in configuration, CID is being cleared!\n");
3697                 p->cid_num[0] = 0;
3698                 p->cid_name[0] = 0;
3699         }
3700         /* if we're supposed to answer immediately, clear DNIS and set 's' exten */
3701         if (p->immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
3702                 ast_debug(1, "Setting exten => s because of immediate or 0 DNIS configured\n");
3703                 p->exten[0] = 's';
3704                 p->exten[1] = 0;
3705         }
3706         ast_mutex_unlock(&p->lock);
3707         if (!ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
3708                 ast_log(LOG_NOTICE, "MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
3709                                 p->channel, p->exten, p->context);
3710                 dahdi_r2_disconnect_call(p, OR2_CAUSE_UNALLOCATED_NUMBER);
3711                 goto dahdi_r2_on_call_offered_cleanup;
3712         }
3713         if (!p->mfcr2_accept_on_offer) {
3714                 /* The user wants us to start the PBX thread right away without accepting the call first */
3715                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, NULL, callid);
3716                 if (c) {
3717                         /* Done here, don't disable reading now since we still need to generate MF tones to accept
3718                            the call or reject it and detect the tone off condition of the other end, all of this
3719                            will be done in the PBX thread now */
3720                         goto dahdi_r2_on_call_offered_cleanup;
3721                 }
3722                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3723                 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
3724         } else if (p->mfcr2_charge_calls) {
3725                 ast_debug(1, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
3726                 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
3727         } else {
3728                 ast_debug(1, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
3729                 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
3730         }
3731
3732 dahdi_r2_on_call_offered_cleanup:
3733         ast_callid_threadstorage_auto_clean(callid, callid_created);
3734 }
3735
3736 static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
3737 {
3738         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3739         ast_verbose("MFC/R2 call end on channel %d\n", p->channel);
3740         ast_mutex_lock(&p->lock);
3741         p->mfcr2call = 0;
3742         ast_mutex_unlock(&p->lock);
3743 }
3744
3745 static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
3746 {
3747         struct dahdi_pvt *p = NULL;
3748         struct ast_channel *c = NULL;
3749         ast_callid callid = 0;
3750         int callid_created = ast_callid_threadstorage_auto(&callid);
3751         p = openr2_chan_get_client_data(r2chan);
3752         dahdi_ec_enable(p);
3753         p->mfcr2_call_accepted = 1;
3754         /* if it's an incoming call ... */
3755         if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
3756                 ast_verbose("MFC/R2 call has been accepted on backward channel %d\n", openr2_chan_get_number(r2chan));
3757                 /* If accept on offer is not set, it means at this point the PBX thread is already
3758                    launched (was launched in the 'on call offered' handler) and therefore this callback
3759                 &nbs