81242533eaae2b94e5a6962eab2bc96aca4ac003
[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/astobj.h"
124 #include "asterisk/devicestate.h"
125 #include "asterisk/paths.h"
126 #include "asterisk/ccss.h"
127 #include "asterisk/data.h"
128 #include "asterisk/features_config.h"
129 #include "asterisk/bridge.h"
130 #include "asterisk/stasis_channels.h"
131 #include "asterisk/parking.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 my_stop_cid_detect(void *pvt)
1305 {
1306         struct dahdi_pvt *p = pvt;
1307         int index = SUB_REAL;
1308         if (p->cs)
1309                 callerid_free(p->cs);
1310         dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
1311         return 0;
1312 }
1313
1314 static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
1315 {
1316         struct dahdi_pvt *p = pvt;
1317         struct analog_pvt *analog_p = p->sig_pvt;
1318         struct pollfd poller;
1319         char *name, *num;
1320         int index = SUB_REAL;
1321         int res;
1322         unsigned char buf[256];
1323         int flags;
1324         struct ast_format tmpfmt;
1325
1326         poller.fd = p->subs[SUB_REAL].dfd;
1327         poller.events = POLLPRI | POLLIN;
1328         poller.revents = 0;
1329
1330         res = poll(&poller, 1, timeout);
1331
1332         if (poller.revents & POLLPRI) {
1333                 *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd));
1334                 return 1;
1335         }
1336
1337         if (poller.revents & POLLIN) {
1338                 /*** NOTES ***/
1339                 /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function
1340                  * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until
1341                  * either a timeout occurs or CID is detected (returns 0). returning 1 should be event received, and -1 should be
1342                  * a failure and die, and returning 2 means no event was received. */
1343                 res = read(p->subs[index].dfd, buf, sizeof(buf));
1344                 if (res < 0) {
1345                         ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1346                         return -1;
1347                 }
1348
1349                 if (analog_p->ringt > 0) {
1350                         if (!(--analog_p->ringt)) {
1351                                 /* only return if we timeout from a ring event */
1352                                 return -1;
1353                         }
1354                 }
1355
1356                 if (p->cid_signalling == CID_SIG_V23_JP) {
1357                         res = callerid_feed_jp(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1358                 } else {
1359                         res = callerid_feed(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1360                 }
1361                 if (res < 0) {
1362                         /*
1363                          * The previous diagnostic message output likely
1364                          * explains why it failed.
1365                          */
1366                         ast_log(LOG_WARNING, "Failed to decode CallerID\n");
1367                         return -1;
1368                 }
1369
1370                 if (res == 1) {
1371                         callerid_get(p->cs, &name, &num, &flags);
1372                         if (name)
1373                                 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
1374                         if (num)
1375                                 ast_copy_string(numbuf, num, ANALOG_MAX_CID);
1376
1377                         ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
1378                         return 0;
1379                 }
1380         }
1381
1382         *ev = ANALOG_EVENT_NONE;
1383         return 2;
1384 }
1385
1386 static const char *event2str(int event);
1387 static int restore_gains(struct dahdi_pvt *p);
1388
1389 static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
1390 {
1391         unsigned char buf[256];
1392         int distMatches;
1393         int curRingData[RING_PATTERNS];
1394         int receivedRingT;
1395         int counter1;
1396         int counter;
1397         int i;
1398         int res;
1399         int checkaftercid = 0;
1400
1401         struct dahdi_pvt *p = pvt;
1402         struct analog_pvt *analog_p = p->sig_pvt;
1403
1404         if (ringdata == NULL) {
1405                 ringdata = curRingData;
1406         } else {
1407                 checkaftercid = 1;
1408         }
1409
1410         /* We must have a ring by now, so, if configured, lets try to listen for
1411          * distinctive ringing */
1412         if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
1413                 /* Clear the current ring data array so we don't have old data in it. */
1414                 for (receivedRingT = 0; receivedRingT < RING_PATTERNS; receivedRingT++)
1415                         ringdata[receivedRingT] = 0;
1416                 receivedRingT = 0;
1417                 if (checkaftercid && distinctiveringaftercid)
1418                         ast_verb(3, "Detecting post-CID distinctive ring\n");
1419                 /* Check to see if context is what it should be, if not set to be. */
1420                 else if (strcmp(p->context,p->defcontext) != 0) {
1421                         ast_copy_string(p->context, p->defcontext, sizeof(p->context));
1422                         ast_channel_context_set(chan, p->defcontext);
1423                 }
1424
1425                 for (;;) {
1426                         i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1427                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
1428                                 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
1429                                 ast_hangup(chan);
1430                                 return 1;
1431                         }
1432                         if (i & DAHDI_IOMUX_SIGEVENT) {
1433                                 res = dahdi_get_event(p->subs[idx].dfd);
1434                                 if (res == DAHDI_EVENT_NOALARM) {
1435                                         p->inalarm = 0;
1436                                         analog_p->inalarm = 0;
1437                                 }
1438                                 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
1439                                 res = 0;
1440                                 /* Let us detect distinctive ring */
1441
1442                                 ringdata[receivedRingT] = analog_p->ringt;
1443
1444                                 if (analog_p->ringt < analog_p->ringt_base/2)
1445                                         break;
1446                                 /* Increment the ringT counter so we can match it against
1447                                    values in chan_dahdi.conf for distinctive ring */
1448                                 if (++receivedRingT == RING_PATTERNS)
1449                                         break;
1450                         } else if (i & DAHDI_IOMUX_READ) {
1451                                 res = read(p->subs[idx].dfd, buf, sizeof(buf));
1452                                 if (res < 0) {
1453                                         if (errno != ELAST) {
1454                                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1455                                                 ast_hangup(chan);
1456                                                 return 1;
1457                                         }
1458                                         break;
1459                                 }
1460                                 if (analog_p->ringt > 0) {
1461                                         if (!(--analog_p->ringt)) {
1462                                                 res = -1;
1463                                                 break;
1464                                         }
1465                                 }
1466                         }
1467                 }
1468         }
1469         if ((checkaftercid && usedistinctiveringdetection) || !checkaftercid) {
1470                 /* this only shows up if you have n of the dring patterns filled in */
1471                 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",ringdata[0],ringdata[1],ringdata[2]);
1472                 for (counter = 0; counter < 3; counter++) {
1473                 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
1474                         distMatches = 0;
1475                         /* this only shows up if you have n of the dring patterns filled in */
1476                         ast_verb(3, "Checking %d,%d,%d\n",
1477                                         p->drings.ringnum[counter].ring[0],
1478                                         p->drings.ringnum[counter].ring[1],
1479                                         p->drings.ringnum[counter].ring[2]);
1480                         for (counter1 = 0; counter1 < 3; counter1++) {
1481                                 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
1482                                 if (p->drings.ringnum[counter].ring[counter1] == -1) {
1483                                         ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1484                                         ringdata[counter1]);
1485                                         distMatches++;
1486                                 } else if (ringdata[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
1487                                                                                 ringdata[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
1488                                         ast_verb(3, "Ring pattern matched in range: %d to %d\n",
1489                                         (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
1490                                         (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
1491                                         distMatches++;
1492                                 }
1493                         }
1494
1495                         if (distMatches == 3) {
1496                                 /* The ring matches, set the context to whatever is for distinctive ring.. */
1497                                 ast_copy_string(p->context, S_OR(p->drings.ringContext[counter].contextData, p->defcontext), sizeof(p->context));
1498                                 ast_channel_context_set(chan, S_OR(p->drings.ringContext[counter].contextData, p->defcontext));
1499                                 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
1500                                 break;
1501                         }
1502                 }
1503         }
1504         /* Restore linear mode (if appropriate) for Caller*ID processing */
1505         dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
1506         restore_gains(p);
1507
1508         return 0;
1509 }
1510
1511 static int my_stop_callwait(void *pvt)
1512 {
1513         struct dahdi_pvt *p = pvt;
1514         p->callwaitingrepeat = 0;
1515         p->cidcwexpire = 0;
1516         p->cid_suppress_expire = 0;
1517
1518         return 0;
1519 }
1520
1521 static int send_callerid(struct dahdi_pvt *p);
1522 static int save_conference(struct dahdi_pvt *p);
1523 static int restore_conference(struct dahdi_pvt *p);
1524
1525 static int my_callwait(void *pvt)
1526 {
1527         struct dahdi_pvt *p = pvt;
1528         struct ast_format tmpfmt;
1529         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1530         if (p->cidspill) {
1531                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1532                 ast_free(p->cidspill);
1533         }
1534
1535         /*
1536          * SAS: Subscriber Alert Signal, 440Hz for 300ms
1537          * CAS: CPE Alert Signal, 2130Hz * 2750Hz sine waves
1538          */
1539         if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1540                 return -1;
1541         save_conference(p);
1542         /* Silence */
1543         memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1544         if (!p->callwaitrings && p->callwaitingcallerid) {
1545                 ast_gen_cas(p->cidspill, 1, 2400 + 680, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1546                 p->callwaitcas = 1;
1547                 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1548         } else {
1549                 ast_gen_cas(p->cidspill, 1, 2400, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1550                 p->callwaitcas = 0;
1551                 p->cidlen = 2400 + READ_SIZE * 4;
1552         }
1553         p->cidpos = 0;
1554         send_callerid(p);
1555
1556         return 0;
1557 }
1558
1559 static int my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
1560 {
1561         struct dahdi_pvt *p = pvt;
1562         struct ast_format tmpfmt;
1563
1564         ast_debug(2, "Starting cid spill\n");
1565
1566         if (p->cidspill) {
1567                 ast_log(LOG_WARNING, "cidspill already exists??\n");
1568                 ast_free(p->cidspill);
1569         }
1570
1571         if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1572                 if (cwcid == 0) {
1573                         p->cidlen = ast_callerid_generate(p->cidspill,
1574                                 caller->id.name.str,
1575                                 caller->id.number.str,
1576                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1577                 } else {
1578                         ast_verb(3, "CPE supports Call Waiting Caller*ID.  Sending '%s/%s'\n",
1579                                 caller->id.name.str, caller->id.number.str);
1580                         p->callwaitcas = 0;
1581                         p->cidcwexpire = 0;
1582                         p->cidlen = ast_callerid_callwaiting_generate(p->cidspill,
1583                                 caller->id.name.str,
1584                                 caller->id.number.str,
1585                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1586                         p->cidlen += READ_SIZE * 4;
1587                 }
1588                 p->cidpos = 0;
1589                 p->cid_suppress_expire = 0;
1590                 send_callerid(p);
1591         }
1592         return 0;
1593 }
1594
1595 static int my_dsp_reset_and_flush_digits(void *pvt)
1596 {
1597         struct dahdi_pvt *p = pvt;
1598         if (p->dsp)
1599                 ast_dsp_digitreset(p->dsp);
1600
1601         return 0;
1602 }
1603
1604 static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
1605 {
1606         struct dahdi_pvt *p = pvt;
1607
1608         if (p->channel == CHAN_PSEUDO)
1609                 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");
1610
1611         if (mode == ANALOG_DIGITMODE_DTMF) {
1612                 /* If we do hardware dtmf, no need for a DSP */
1613                 if (p->hardwaredtmf) {
1614                         if (p->dsp) {
1615                                 ast_dsp_free(p->dsp);
1616                                 p->dsp = NULL;
1617                         }
1618                         return 0;
1619                 }
1620
1621                 if (!p->dsp) {
1622                         p->dsp = ast_dsp_new();
1623                         if (!p->dsp) {
1624                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1625                                 return -1;
1626                         }
1627                 }
1628
1629                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
1630         } else if (mode == ANALOG_DIGITMODE_MF) {
1631                 if (!p->dsp) {
1632                         p->dsp = ast_dsp_new();
1633                         if (!p->dsp) {
1634                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1635                                 return -1;
1636                         }
1637                 }
1638                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
1639         }
1640         return 0;
1641 }
1642
1643 static int dahdi_wink(struct dahdi_pvt *p, int index);
1644
1645 static int my_wink(void *pvt, enum analog_sub sub)
1646 {
1647         struct dahdi_pvt *p = pvt;
1648         int index = analogsub_to_dahdisub(sub);
1649         if (index != SUB_REAL) {
1650                 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
1651         }
1652         return dahdi_wink(p, index);
1653 }
1654
1655 static void wakeup_sub(struct dahdi_pvt *p, int a);
1656
1657 static int reset_conf(struct dahdi_pvt *p);
1658
1659 static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);
1660
1661 static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
1662 {
1663         struct ast_frame *f = *dest;
1664         struct dahdi_pvt *p = pvt;
1665         int idx = analogsub_to_dahdisub(analog_index);
1666
1667         ast_debug(1, "%s DTMF digit: 0x%02X '%c' on %s\n",
1668                 f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
1669                 (unsigned)f->subclass.integer, f->subclass.integer, ast_channel_name(ast));
1670
1671         if (f->subclass.integer == 'f') {
1672                 if (f->frametype == AST_FRAME_DTMF_END) {
1673                         /* Fax tone -- Handle and return NULL */
1674                         if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
1675                                 /* If faxbuffers are configured, use them for the fax transmission */
1676                                 if (p->usefaxbuffers && !p->bufferoverrideinuse) {
1677                                         struct dahdi_bufferinfo bi = {
1678                                                 .txbufpolicy = p->faxbuf_policy,
1679                                                 .bufsize = p->bufsize,
1680                                                 .numbufs = p->faxbuf_no
1681                                         };
1682                                         int res;
1683
1684                                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
1685                                                 ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast_channel_name(ast), strerror(errno));
1686                                         } else {
1687                                                 p->bufferoverrideinuse = 1;
1688                                         }
1689                                 }
1690                                 p->faxhandled = 1;
1691                                 if (p->dsp) {
1692                                         p->dsp_features &= ~DSP_FEATURE_FAX_DETECT;
1693                                         ast_dsp_set_features(p->dsp, p->dsp_features);
1694                                         ast_debug(1, "Disabling FAX tone detection on %s after tone received\n", ast_channel_name(ast));
1695                                 }
1696                                 if (strcmp(ast_channel_exten(ast), "fax")) {
1697                                         const char *target_context = S_OR(ast_channel_macrocontext(ast), ast_channel_context(ast));
1698
1699                                         /* We need to unlock 'ast' here because ast_exists_extension has the
1700                                          * potential to start autoservice on the channel. Such action is prone
1701                                          * to deadlock.
1702                                          */
1703                                         ast_mutex_unlock(&p->lock);
1704                                         ast_channel_unlock(ast);
1705                                         if (ast_exists_extension(ast, target_context, "fax", 1,
1706                                                 S_COR(ast_channel_caller(ast)->id.number.valid, ast_channel_caller(ast)->id.number.str, NULL))) {
1707                                                 ast_channel_lock(ast);
1708                                                 ast_mutex_lock(&p->lock);
1709                                                 ast_verb(3, "Redirecting %s to fax extension\n", ast_channel_name(ast));
1710                                                 /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
1711                                                 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
1712                                                 if (ast_async_goto(ast, target_context, "fax", 1))
1713                                                         ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(ast), target_context);
1714                                         } else {
1715                                                 ast_channel_lock(ast);
1716                                                 ast_mutex_lock(&p->lock);
1717                                                 ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
1718                                         }
1719                                 } else {
1720                                         ast_debug(1, "Already in a fax extension, not redirecting\n");
1721                                 }
1722                         } else {
1723                                 ast_debug(1, "Fax already handled\n");
1724                         }
1725                         dahdi_confmute(p, 0);
1726                 }
1727                 p->subs[idx].f.frametype = AST_FRAME_NULL;
1728                 p->subs[idx].f.subclass.integer = 0;
1729                 *dest = &p->subs[idx].f;
1730         }
1731 }
1732
1733 static void my_lock_private(void *pvt)
1734 {
1735         struct dahdi_pvt *p = pvt;
1736         ast_mutex_lock(&p->lock);
1737 }
1738
1739 static void my_unlock_private(void *pvt)
1740 {
1741         struct dahdi_pvt *p = pvt;
1742         ast_mutex_unlock(&p->lock);
1743 }
1744
1745 static void my_deadlock_avoidance_private(void *pvt)
1746 {
1747         struct dahdi_pvt *p = pvt;
1748
1749         DEADLOCK_AVOIDANCE(&p->lock);
1750 }
1751
1752 static struct ast_manager_event_blob *dahdichannel_to_ami(struct stasis_message *msg)
1753 {
1754         RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
1755         struct ast_channel_blob *obj = stasis_message_data(msg);
1756         struct ast_json *span, *channel;
1757
1758         channel_string = ast_manager_build_channel_state_string(obj->snapshot);
1759         if (!channel_string) {
1760                 return NULL;
1761         }
1762
1763         span = ast_json_object_get(obj->blob, "span");
1764         channel = ast_json_object_get(obj->blob, "channel");
1765
1766         return ast_manager_event_blob_create(EVENT_FLAG_CALL, "DAHDIChannel",
1767                 "%s"
1768                 "DAHDISpan: %u\r\n"
1769                 "DAHDIChannel: %s\r\n",
1770                 ast_str_buffer(channel_string),
1771                 (unsigned int)ast_json_integer_get(span),
1772                 ast_json_string_get(channel));
1773 }
1774
1775 STASIS_MESSAGE_TYPE_DEFN_LOCAL(dahdichannel_type,
1776         .to_ami = dahdichannel_to_ami,
1777         );
1778
1779 /*! \brief Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages */
1780 static void publish_dahdichannel(struct ast_channel *chan, int span, const char *dahdi_channel)
1781 {
1782         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
1783
1784         ast_assert(dahdi_channel != NULL);
1785
1786         blob = ast_json_pack("{s: i, s: s}",
1787                 "span", span,
1788                 "channel", dahdi_channel);
1789         if (!blob) {
1790                 return;
1791         }
1792
1793         ast_channel_lock(chan);
1794         ast_channel_publish_blob(chan, dahdichannel_type(), blob);
1795         ast_channel_unlock(chan);
1796 }
1797
1798 /*!
1799  * \internal
1800  * \brief Post an AMI DAHDI channel association event.
1801  * \since 1.8
1802  *
1803  * \param p DAHDI private pointer
1804  * \param chan Channel associated with the private pointer
1805  *
1806  * \return Nothing
1807  */
1808 static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
1809 {
1810         char ch_name[20];
1811
1812         if (p->channel < CHAN_PSEUDO) {
1813                 /* No B channel */
1814                 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
1815         } else if (p->channel == CHAN_PSEUDO) {
1816                 /* Pseudo channel */
1817                 strcpy(ch_name, "pseudo");
1818         } else {
1819                 /* Real channel */
1820                 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
1821         }
1822         publish_dahdichannel(chan, p->span, ch_name);
1823 }
1824
1825 #ifdef HAVE_PRI
1826 /*!
1827  * \internal
1828  * \brief Post an AMI DAHDI channel association event.
1829  * \since 1.8
1830  *
1831  * \param pvt DAHDI private pointer
1832  * \param chan Channel associated with the private pointer
1833  *
1834  * \return Nothing
1835  */
1836 static void my_ami_channel_event(void *pvt, struct ast_channel *chan)
1837 {
1838         struct dahdi_pvt *p = pvt;
1839
1840         dahdi_ami_channel_event(p, chan);
1841 }
1842 #endif
1843
1844 /* linear_mode = 0 - turn linear mode off, >0 - turn linear mode on
1845 *       returns the last value of the linear setting
1846 */
1847 static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
1848 {
1849         struct dahdi_pvt *p = pvt;
1850         int oldval;
1851         int idx = analogsub_to_dahdisub(sub);
1852
1853         dahdi_setlinear(p->subs[idx].dfd, linear_mode);
1854         oldval = p->subs[idx].linear;
1855         p->subs[idx].linear = linear_mode ? 1 : 0;
1856         return oldval;
1857 }
1858
1859 static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
1860 {
1861         struct dahdi_pvt *p = pvt;
1862         int idx = analogsub_to_dahdisub(sub);
1863
1864         p->subs[idx].inthreeway = inthreeway;
1865 }
1866
1867 static int get_alarms(struct dahdi_pvt *p);
1868 static void handle_alarms(struct dahdi_pvt *p, int alms);
1869 static void my_get_and_handle_alarms(void *pvt)
1870 {
1871         int res;
1872         struct dahdi_pvt *p = pvt;
1873
1874         res = get_alarms(p);
1875         handle_alarms(p, res);
1876 }
1877
1878 static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
1879 {
1880         RAII_VAR(struct ast_channel *, bridged, ast_channel_bridge_peer(chan), ast_channel_cleanup);
1881
1882         if (bridged && ast_channel_tech(bridged) == &dahdi_tech) {
1883                 struct dahdi_pvt *p = ast_channel_tech_pvt(bridged);
1884
1885                 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
1886                         return p->sig_pvt;
1887                 }
1888         }
1889         return NULL;
1890 }
1891
1892 static int my_get_sub_fd(void *pvt, enum analog_sub sub)
1893 {
1894         struct dahdi_pvt *p = pvt;
1895         int dahdi_sub = analogsub_to_dahdisub(sub);
1896         return p->subs[dahdi_sub].dfd;
1897 }
1898
1899 static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
1900 {
1901         struct dahdi_pvt *p = pvt;
1902
1903         /* Choose proper cadence */
1904         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
1905                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
1906                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast_channel_name(ast), strerror(errno));
1907                 *cid_rings = cidrings[p->distinctivering - 1];
1908         } else {
1909                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
1910                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast_channel_name(ast), strerror(errno));
1911                 *cid_rings = p->sendcalleridafter;
1912         }
1913 }
1914
1915 static void my_set_alarm(void *pvt, int in_alarm)
1916 {
1917         struct dahdi_pvt *p = pvt;
1918
1919         p->inalarm = in_alarm;
1920 }
1921
1922 static void my_set_dialing(void *pvt, int is_dialing)
1923 {
1924         struct dahdi_pvt *p = pvt;
1925
1926         p->dialing = is_dialing;
1927 }
1928
1929 static void my_set_outgoing(void *pvt, int is_outgoing)
1930 {
1931         struct dahdi_pvt *p = pvt;
1932
1933         p->outgoing = is_outgoing;
1934 }
1935
1936 #if defined(HAVE_PRI) || defined(HAVE_SS7)
1937 static void my_set_digital(void *pvt, int is_digital)
1938 {
1939         struct dahdi_pvt *p = pvt;
1940
1941         p->digital = is_digital;
1942 }
1943 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
1944
1945 #if defined(HAVE_SS7)
1946 static void my_set_inservice(void *pvt, int is_inservice)
1947 {
1948         struct dahdi_pvt *p = pvt;
1949
1950         p->inservice = is_inservice;
1951 }
1952 #endif  /* defined(HAVE_SS7) */
1953
1954 #if defined(HAVE_SS7)
1955 static void my_set_locallyblocked(void *pvt, int is_blocked)
1956 {
1957         struct dahdi_pvt *p = pvt;
1958
1959         p->locallyblocked = is_blocked;
1960 }
1961 #endif  /* defined(HAVE_SS7) */
1962
1963 #if defined(HAVE_SS7)
1964 static void my_set_remotelyblocked(void *pvt, int is_blocked)
1965 {
1966         struct dahdi_pvt *p = pvt;
1967
1968         p->remotelyblocked = is_blocked;
1969 }
1970 #endif  /* defined(HAVE_SS7) */
1971
1972 static void my_set_ringtimeout(void *pvt, int ringt)
1973 {
1974         struct dahdi_pvt *p = pvt;
1975         p->ringt = ringt;
1976 }
1977
1978 static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
1979 {
1980         struct dahdi_pvt *p = pvt;
1981
1982         if (p->waitfordialtone && CANPROGRESSDETECT(p) && p->dsp) {
1983                 ast_debug(1, "Defer dialing for %dms or dialtone\n", p->waitfordialtone);
1984                 gettimeofday(&p->waitingfordt, NULL);
1985                 ast_setstate(ast, AST_STATE_OFFHOOK);
1986         }
1987 }
1988
1989 static int my_check_waitingfordt(void *pvt)
1990 {
1991         struct dahdi_pvt *p = pvt;
1992
1993         if (p->waitingfordt.tv_sec) {
1994                 return 1;
1995         }
1996
1997         return 0;
1998 }
1999
2000 static void my_set_confirmanswer(void *pvt, int flag)
2001 {
2002         struct dahdi_pvt *p = pvt;
2003         p->confirmanswer = flag;
2004 }
2005
2006 static int my_check_confirmanswer(void *pvt)
2007 {
2008         struct dahdi_pvt *p = pvt;
2009         if (p->confirmanswer) {
2010                 return 1;
2011         }
2012
2013         return 0;
2014 }
2015
2016 static void my_set_callwaiting(void *pvt, int callwaiting_enable)
2017 {
2018         struct dahdi_pvt *p = pvt;
2019
2020         p->callwaiting = callwaiting_enable;
2021 }
2022
2023 static void my_cancel_cidspill(void *pvt)
2024 {
2025         struct dahdi_pvt *p = pvt;
2026
2027         ast_free(p->cidspill);
2028         p->cidspill = NULL;
2029         restore_conference(p);
2030 }
2031
2032 static int my_confmute(void *pvt, int mute)
2033 {
2034         struct dahdi_pvt *p = pvt;
2035         return dahdi_confmute(p, mute);
2036 }
2037
2038 static void my_set_pulsedial(void *pvt, int flag)
2039 {
2040         struct dahdi_pvt *p = pvt;
2041         p->pulsedial = flag;
2042 }
2043
2044 static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
2045 {
2046         struct dahdi_pvt *p = pvt;
2047
2048         p->owner = new_owner;
2049 }
2050
2051 static const char *my_get_orig_dialstring(void *pvt)
2052 {
2053         struct dahdi_pvt *p = pvt;
2054
2055         return p->dialstring;
2056 }
2057
2058 static void my_increase_ss_count(void)
2059 {
2060         ast_mutex_lock(&ss_thread_lock);
2061         ss_thread_count++;
2062         ast_mutex_unlock(&ss_thread_lock);
2063 }
2064
2065 static void my_decrease_ss_count(void)
2066 {
2067         ast_mutex_lock(&ss_thread_lock);
2068         ss_thread_count--;
2069         ast_cond_signal(&ss_thread_complete);
2070         ast_mutex_unlock(&ss_thread_lock);
2071 }
2072
2073 static void my_all_subchannels_hungup(void *pvt)
2074 {
2075         struct dahdi_pvt *p = pvt;
2076         int res, law;
2077
2078         p->faxhandled = 0;
2079         p->didtdd = 0;
2080
2081         if (p->dsp) {
2082                 ast_dsp_free(p->dsp);
2083                 p->dsp = NULL;
2084         }
2085
2086         p->law = p->law_default;
2087         law = p->law_default;
2088         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
2089         if (res < 0)
2090                 ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
2091
2092         dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
2093
2094 #if 1
2095         {
2096         int i;
2097         p->owner = NULL;
2098         /* Cleanup owners here */
2099         for (i = 0; i < 3; i++) {
2100                 p->subs[i].owner = NULL;
2101         }
2102         }
2103 #endif
2104
2105         reset_conf(p);
2106         if (num_restart_pending == 0) {
2107                 restart_monitor();
2108         }
2109 }
2110
2111 static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);
2112
2113 static int my_conf_del(void *pvt, enum analog_sub sub)
2114 {
2115         struct dahdi_pvt *p = pvt;
2116         int x = analogsub_to_dahdisub(sub);
2117
2118         return conf_del(p, &p->subs[x], x);
2119 }
2120
2121 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);
2122
2123 static int my_conf_add(void *pvt, enum analog_sub sub)
2124 {
2125         struct dahdi_pvt *p = pvt;
2126         int x = analogsub_to_dahdisub(sub);
2127
2128         return conf_add(p, &p->subs[x], x, 0);
2129 }
2130
2131 static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);
2132
2133 static int my_complete_conference_update(void *pvt, int needconference)
2134 {
2135         struct dahdi_pvt *p = pvt;
2136         int needconf = needconference;
2137         int x;
2138         int useslavenative;
2139         struct dahdi_pvt *slave = NULL;
2140
2141         useslavenative = isslavenative(p, &slave);
2142
2143         /* If we have a slave, add him to our conference now. or DAX
2144            if this is slave native */
2145         for (x = 0; x < MAX_SLAVES; x++) {
2146                 if (p->slaves[x]) {
2147                         if (useslavenative)
2148                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
2149                         else {
2150                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
2151                                 needconf++;
2152                         }
2153                 }
2154         }
2155         /* If we're supposed to be in there, do so now */
2156         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
2157                 if (useslavenative)
2158                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
2159                 else {
2160                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
2161                         needconf++;
2162                 }
2163         }
2164         /* If we have a master, add ourselves to his conference */
2165         if (p->master) {
2166                 if (isslavenative(p->master, NULL)) {
2167                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
2168                 } else {
2169                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
2170                 }
2171         }
2172         if (!needconf) {
2173                 /* Nobody is left (or should be left) in our conference.
2174                    Kill it. */
2175                 p->confno = -1;
2176         }
2177
2178         return 0;
2179 }
2180
2181 static int check_for_conference(struct dahdi_pvt *p);
2182
2183 static int my_check_for_conference(void *pvt)
2184 {
2185         struct dahdi_pvt *p = pvt;
2186         return check_for_conference(p);
2187 }
2188
2189 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)
2190 {
2191         struct dahdi_pvt *p = pvt;
2192         int da, db;
2193         int tchan;
2194         int tinthreeway;
2195
2196         da = analogsub_to_dahdisub(a);
2197         db = analogsub_to_dahdisub(b);
2198
2199         tchan = p->subs[da].chan;
2200         p->subs[da].chan = p->subs[db].chan;
2201         p->subs[db].chan = tchan;
2202
2203         tinthreeway = p->subs[da].inthreeway;
2204         p->subs[da].inthreeway = p->subs[db].inthreeway;
2205         p->subs[db].inthreeway = tinthreeway;
2206
2207         p->subs[da].owner = ast_a;
2208         p->subs[db].owner = ast_b;
2209
2210         if (ast_a)
2211                 ast_channel_set_fd(ast_a, 0, p->subs[da].dfd);
2212         if (ast_b)
2213                 ast_channel_set_fd(ast_b, 0, p->subs[db].dfd);
2214
2215         wakeup_sub(p, a);
2216         wakeup_sub(p, b);
2217
2218         return;
2219 }
2220
2221 /*!
2222  * \internal
2223  * \brief performs duties of dahdi_new, but also removes and possibly unbinds (if callid_created is 1) before returning
2224  * \note this variant of dahdi should only be used in conjunction with ast_callid_threadstorage_auto()
2225  *
2226  * \param callid_created value returned from ast_callid_threadstorage_auto()
2227  */
2228 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, struct ast_callid *callid, int callid_created);
2229
2230 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, struct ast_callid *callid);
2231
2232 static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
2233 {
2234         struct ast_callid *callid = NULL;
2235         int callid_created = ast_callid_threadstorage_auto(&callid);
2236         struct dahdi_pvt *p = pvt;
2237         int dsub = analogsub_to_dahdisub(sub);
2238
2239         return dahdi_new_callid_clean(p, state, startpbx, dsub, 0, NULL, requestor, callid, callid_created);
2240 }
2241
2242 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2243 static int dahdi_setlaw(int dfd, int law)
2244 {
2245         int res;
2246         res = ioctl(dfd, DAHDI_SETLAW, &law);
2247         if (res)
2248                 return res;
2249         return 0;
2250 }
2251 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2252
2253 #if defined(HAVE_PRI)
2254 static struct ast_channel *my_new_pri_ast_channel(void *pvt, int state,
2255         enum sig_pri_law law, char *exten, const struct ast_assigned_ids *assignedids,
2256         const struct ast_channel *requestor)
2257 {
2258         struct dahdi_pvt *p = pvt;
2259         int audio;
2260         int newlaw = -1;
2261         struct ast_callid *callid = NULL;
2262         int callid_created = ast_callid_threadstorage_auto(&callid);
2263
2264         switch (p->sig) {
2265         case SIG_PRI_LIB_HANDLE_CASES:
2266                 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
2267                         /* PRI nobch pseudo channel.  Does not handle ioctl(DAHDI_AUDIOMODE) */
2268                         break;
2269                 }
2270                 /* Fall through */
2271         default:
2272                 /* Set to audio mode at this point */
2273                 audio = 1;
2274                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1) {
2275                         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
2276                                 p->channel, audio, strerror(errno));
2277                 }
2278                 break;
2279         }
2280
2281         if (law != SIG_PRI_DEFLAW) {
2282                 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
2283         }
2284
2285         ast_copy_string(p->exten, exten, sizeof(p->exten));
2286
2287         switch (law) {
2288                 case SIG_PRI_DEFLAW:
2289                         newlaw = 0;
2290                         break;
2291                 case SIG_PRI_ALAW:
2292                         newlaw = DAHDI_LAW_ALAW;
2293                         break;
2294                 case SIG_PRI_ULAW:
2295                         newlaw = DAHDI_LAW_MULAW;
2296                         break;
2297         }
2298
2299         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
2300 }
2301 #endif  /* defined(HAVE_PRI) */
2302
2303 static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law);
2304
2305 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2306 /*!
2307  * \internal
2308  * \brief Open the PRI/SS7 channel media path.
2309  * \since 1.8
2310  *
2311  * \param p Channel private control structure.
2312  *
2313  * \return Nothing
2314  */
2315 static void my_pri_ss7_open_media(void *p)
2316 {
2317         struct dahdi_pvt *pvt = p;
2318         int res;
2319         int dfd;
2320         int set_val;
2321
2322         dfd = pvt->subs[SUB_REAL].dfd;
2323
2324         /* Open the media path. */
2325         set_val = 1;
2326         res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
2327         if (res < 0) {
2328                 ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n",
2329                         pvt->channel, strerror(errno));
2330         }
2331
2332         /* Set correct companding law for this call. */
2333         res = dahdi_setlaw(dfd, pvt->law);
2334         if (res < 0) {
2335                 ast_log(LOG_WARNING, "Unable to set law on channel %d\n", pvt->channel);
2336         }
2337
2338         /* Set correct gain for this call. */
2339         if (pvt->digital) {
2340                 res = set_actual_gain(dfd, 0, 0, pvt->rxdrc, pvt->txdrc, pvt->law);
2341         } else {
2342                 res = set_actual_gain(dfd, pvt->rxgain, pvt->txgain, pvt->rxdrc, pvt->txdrc,
2343                         pvt->law);
2344         }
2345         if (res < 0) {
2346                 ast_log(LOG_WARNING, "Unable to set gains on channel %d\n", pvt->channel);
2347         }
2348
2349         if (pvt->dsp_features && pvt->dsp) {
2350                 ast_dsp_set_features(pvt->dsp, pvt->dsp_features);
2351                 pvt->dsp_features = 0;
2352         }
2353 }
2354 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2355
2356 #if defined(HAVE_PRI)
2357 /*!
2358  * \internal
2359  * \brief Ask DAHDI to dial the given dial string.
2360  * \since 1.8.11
2361  *
2362  * \param p Channel private control structure.
2363  * \param dial_string String to pass to DAHDI to dial.
2364  *
2365  * \note The channel private lock needs to be held when calling.
2366  *
2367  * \return Nothing
2368  */
2369 static void my_pri_dial_digits(void *p, const char *dial_string)
2370 {
2371         char dial_str[DAHDI_MAX_DTMF_BUF];
2372         struct dahdi_pvt *pvt = p;
2373         int res;
2374
2375         snprintf(dial_str, sizeof(dial_str), "T%s", dial_string);
2376         res = dahdi_dial_str(pvt, DAHDI_DIAL_OP_APPEND, dial_str);
2377         if (!res) {
2378                 pvt->dialing = 1;
2379         }
2380 }
2381 #endif  /* defined(HAVE_PRI) */
2382
2383 static int unalloc_sub(struct dahdi_pvt *p, int x);
2384
2385 static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
2386 {
2387         struct dahdi_pvt *p = pvt;
2388
2389         return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
2390 }
2391
2392 static int alloc_sub(struct dahdi_pvt *p, int x);
2393
2394 static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
2395 {
2396         struct dahdi_pvt *p = pvt;
2397
2398         return alloc_sub(p, analogsub_to_dahdisub(analogsub));
2399 }
2400
2401 static int has_voicemail(struct dahdi_pvt *p);
2402
2403 static int my_has_voicemail(void *pvt)
2404 {
2405         struct dahdi_pvt *p = pvt;
2406
2407         return has_voicemail(p);
2408 }
2409
2410 static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
2411 {
2412         struct dahdi_pvt *p = pvt;
2413         int index;
2414
2415         index = analogsub_to_dahdisub(sub);
2416
2417         return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
2418 }
2419
2420 static enum analog_event dahdievent_to_analogevent(int event)
2421 {
2422         enum analog_event res;
2423
2424         switch (event) {
2425         case DAHDI_EVENT_ONHOOK:
2426                 res = ANALOG_EVENT_ONHOOK;
2427                 break;
2428         case DAHDI_EVENT_RINGOFFHOOK:
2429                 res = ANALOG_EVENT_RINGOFFHOOK;
2430                 break;
2431         case DAHDI_EVENT_WINKFLASH:
2432                 res = ANALOG_EVENT_WINKFLASH;
2433                 break;
2434         case DAHDI_EVENT_ALARM:
2435                 res = ANALOG_EVENT_ALARM;
2436                 break;
2437         case DAHDI_EVENT_NOALARM:
2438                 res = ANALOG_EVENT_NOALARM;
2439                 break;
2440         case DAHDI_EVENT_DIALCOMPLETE:
2441                 res = ANALOG_EVENT_DIALCOMPLETE;
2442                 break;
2443         case DAHDI_EVENT_RINGERON:
2444                 res = ANALOG_EVENT_RINGERON;
2445                 break;
2446         case DAHDI_EVENT_RINGEROFF:
2447                 res = ANALOG_EVENT_RINGEROFF;
2448                 break;
2449         case DAHDI_EVENT_HOOKCOMPLETE:
2450                 res = ANALOG_EVENT_HOOKCOMPLETE;
2451                 break;
2452         case DAHDI_EVENT_PULSE_START:
2453                 res = ANALOG_EVENT_PULSE_START;
2454                 break;
2455         case DAHDI_EVENT_POLARITY:
2456                 res = ANALOG_EVENT_POLARITY;
2457                 break;
2458         case DAHDI_EVENT_RINGBEGIN:
2459                 res = ANALOG_EVENT_RINGBEGIN;
2460                 break;
2461         case DAHDI_EVENT_EC_DISABLED:
2462                 res = ANALOG_EVENT_EC_DISABLED;
2463                 break;
2464         case DAHDI_EVENT_REMOVED:
2465                 res = ANALOG_EVENT_REMOVED;
2466                 break;
2467         case DAHDI_EVENT_NEONMWI_ACTIVE:
2468                 res = ANALOG_EVENT_NEONMWI_ACTIVE;
2469                 break;
2470         case DAHDI_EVENT_NEONMWI_INACTIVE:
2471                 res = ANALOG_EVENT_NEONMWI_INACTIVE;
2472                 break;
2473 #ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2474         case DAHDI_EVENT_TX_CED_DETECTED:
2475                 res = ANALOG_EVENT_TX_CED_DETECTED;
2476                 break;
2477         case DAHDI_EVENT_RX_CED_DETECTED:
2478                 res = ANALOG_EVENT_RX_CED_DETECTED;
2479                 break;
2480         case DAHDI_EVENT_EC_NLP_DISABLED:
2481                 res = ANALOG_EVENT_EC_NLP_DISABLED;
2482                 break;
2483         case DAHDI_EVENT_EC_NLP_ENABLED:
2484                 res = ANALOG_EVENT_EC_NLP_ENABLED;
2485                 break;
2486 #endif
2487         case DAHDI_EVENT_PULSEDIGIT:
2488                 res = ANALOG_EVENT_PULSEDIGIT;
2489                 break;
2490         case DAHDI_EVENT_DTMFDOWN:
2491                 res = ANALOG_EVENT_DTMFDOWN;
2492                 break;
2493         case DAHDI_EVENT_DTMFUP:
2494                 res = ANALOG_EVENT_DTMFUP;
2495                 break;
2496         default:
2497                 switch(event & 0xFFFF0000) {
2498                 case DAHDI_EVENT_PULSEDIGIT:
2499                 case DAHDI_EVENT_DTMFDOWN:
2500                 case DAHDI_EVENT_DTMFUP:
2501                         /* The event includes a digit number in the low word.
2502                          * Converting it to a 'enum analog_event' would remove
2503                          * that information. Thus it is returned as-is.
2504                          */
2505                         return event;
2506                 }
2507
2508                 res = ANALOG_EVENT_ERROR;
2509                 break;
2510         }
2511
2512         return res;
2513 }
2514
2515 static inline int dahdi_wait_event(int fd);
2516
2517 static int my_wait_event(void *pvt)
2518 {
2519         struct dahdi_pvt *p = pvt;
2520
2521         return dahdi_wait_event(p->subs[SUB_REAL].dfd);
2522 }
2523
2524 static int my_get_event(void *pvt)
2525 {
2526         struct dahdi_pvt *p = pvt;
2527         int res;
2528
2529         if (p->fake_event) {
2530                 res = p->fake_event;
2531                 p->fake_event = 0;
2532         } else
2533                 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
2534
2535         return dahdievent_to_analogevent(res);
2536 }
2537
2538 static int my_is_off_hook(void *pvt)
2539 {
2540         struct dahdi_pvt *p = pvt;
2541         int res;
2542         struct dahdi_params par;
2543
2544         memset(&par, 0, sizeof(par));
2545
2546         if (p->subs[SUB_REAL].dfd > -1)
2547                 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
2548         else {
2549                 /* Assume not off hook on CVRS */
2550                 res = 0;
2551                 par.rxisoffhook = 0;
2552         }
2553         if (res) {
2554                 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
2555         }
2556
2557         if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
2558                 /* When "onhook" that means no battery on the line, and thus
2559                 it is out of service..., if it's on a TDM card... If it's a channel
2560                 bank, there is no telling... */
2561                 return (par.rxbits > -1) || par.rxisoffhook;
2562         }
2563
2564         return par.rxisoffhook;
2565 }
2566
2567 static int my_set_echocanceller(void *pvt, int enable)
2568 {
2569         struct dahdi_pvt *p = pvt;
2570
2571         if (enable)
2572                 dahdi_ec_enable(p);
2573         else
2574                 dahdi_ec_disable(p);
2575
2576         return 0;
2577 }
2578
2579 static int dahdi_ring_phone(struct dahdi_pvt *p);
2580
2581 static int my_ring(void *pvt)
2582 {
2583         struct dahdi_pvt *p = pvt;
2584
2585         return dahdi_ring_phone(p);
2586 }
2587
2588 static int my_flash(void *pvt)
2589 {
2590         struct dahdi_pvt *p = pvt;
2591         int func = DAHDI_FLASH;
2592         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
2593 }
2594
2595 static inline int dahdi_set_hook(int fd, int hs);
2596
2597 static int my_off_hook(void *pvt)
2598 {
2599         struct dahdi_pvt *p = pvt;
2600         return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
2601 }
2602
2603 static void my_set_needringing(void *pvt, int value)
2604 {
2605         struct dahdi_pvt *p = pvt;
2606         p->subs[SUB_REAL].needringing = value;
2607 }
2608
2609 static void my_set_polarity(void *pvt, int value)
2610 {
2611         struct dahdi_pvt *p = pvt;
2612
2613         if (p->channel == CHAN_PSEUDO) {
2614                 return;
2615         }
2616         p->polarity = value;
2617         ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETPOLARITY, &value);
2618 }
2619
2620 static void my_start_polarityswitch(void *pvt)
2621 {
2622         struct dahdi_pvt *p = pvt;
2623
2624         if (p->answeronpolarityswitch || p->hanguponpolarityswitch) {
2625                 my_set_polarity(pvt, 0);
2626         }
2627 }
2628
2629 static void my_answer_polarityswitch(void *pvt)
2630 {
2631         struct dahdi_pvt *p = pvt;
2632
2633         if (!p->answeronpolarityswitch) {
2634                 return;
2635         }
2636
2637         my_set_polarity(pvt, 1);
2638 }
2639
2640 static void my_hangup_polarityswitch(void *pvt)
2641 {
2642         struct dahdi_pvt *p = pvt;
2643
2644         if (!p->hanguponpolarityswitch) {
2645                 return;
2646         }
2647
2648         if (p->answeronpolarityswitch) {
2649                 my_set_polarity(pvt, 0);
2650         } else {
2651                 my_set_polarity(pvt, 1);
2652         }
2653 }
2654
2655 static int my_start(void *pvt)
2656 {
2657         struct dahdi_pvt *p = pvt;
2658         int x = DAHDI_START;
2659
2660         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
2661 }
2662
2663 static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
2664 {
2665         struct dahdi_pvt *p = pvt;
2666
2667         if (dop->op != ANALOG_DIAL_OP_REPLACE) {
2668                 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
2669                 return -1;
2670         }
2671
2672         if (sub != ANALOG_SUB_REAL) {
2673                 ast_log(LOG_ERROR, "Trying to dial_digits '%s' on channel %d subchannel %u\n",
2674                         dop->dialstr, p->channel, sub);
2675                 return -1;
2676         }
2677
2678         return dahdi_dial_str(p, DAHDI_DIAL_OP_REPLACE, dop->dialstr);
2679 }
2680
2681 static void dahdi_train_ec(struct dahdi_pvt *p);
2682
2683 static int my_train_echocanceller(void *pvt)
2684 {
2685         struct dahdi_pvt *p = pvt;
2686
2687         dahdi_train_ec(p);
2688
2689         return 0;
2690 }
2691
2692 static int my_is_dialing(void *pvt, enum analog_sub sub)
2693 {
2694         struct dahdi_pvt *p = pvt;
2695         int index;
2696         int x;
2697
2698         index = analogsub_to_dahdisub(sub);
2699
2700         if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
2701                 ast_debug(1, "DAHDI_DIALING ioctl failed!\n");
2702                 return -1;
2703         }
2704
2705         return x;
2706 }
2707
2708 static int my_on_hook(void *pvt)
2709 {
2710         struct dahdi_pvt *p = pvt;
2711         return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
2712 }
2713
2714 #if defined(HAVE_PRI)
2715 static void my_pri_fixup_chans(void *chan_old, void *chan_new)
2716 {
2717         struct dahdi_pvt *old_chan = chan_old;
2718         struct dahdi_pvt *new_chan = chan_new;
2719
2720         new_chan->owner = old_chan->owner;
2721         old_chan->owner = NULL;
2722         if (new_chan->owner) {
2723                 ast_channel_tech_pvt_set(new_chan->owner, new_chan);
2724                 ast_channel_internal_fd_set(new_chan->owner, 0, new_chan->subs[SUB_REAL].dfd);
2725                 new_chan->subs[SUB_REAL].owner = old_chan->subs[SUB_REAL].owner;
2726                 old_chan->subs[SUB_REAL].owner = NULL;
2727         }
2728         /* Copy any DSP that may be present */
2729         new_chan->dsp = old_chan->dsp;
2730         new_chan->dsp_features = old_chan->dsp_features;
2731         old_chan->dsp = NULL;
2732         old_chan->dsp_features = 0;
2733
2734         /* Transfer flags from the old channel. */
2735         new_chan->dialing = old_chan->dialing;
2736         new_chan->digital = old_chan->digital;
2737         new_chan->outgoing = old_chan->outgoing;
2738         old_chan->dialing = 0;
2739         old_chan->digital = 0;
2740         old_chan->outgoing = 0;
2741
2742         /* More stuff to transfer to the new channel. */
2743         new_chan->law = old_chan->law;
2744         strcpy(new_chan->dialstring, old_chan->dialstring);
2745 }
2746 #endif  /* defined(HAVE_PRI) */
2747
2748 #if defined(HAVE_PRI)
2749 static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
2750 {
2751         switch (tone) {
2752         case SIG_PRI_TONE_RINGTONE:
2753                 return DAHDI_TONE_RINGTONE;
2754         case SIG_PRI_TONE_STUTTER:
2755                 return DAHDI_TONE_STUTTER;
2756         case SIG_PRI_TONE_CONGESTION:
2757                 return DAHDI_TONE_CONGESTION;
2758         case SIG_PRI_TONE_DIALTONE:
2759                 return DAHDI_TONE_DIALTONE;
2760         case SIG_PRI_TONE_DIALRECALL:
2761                 return DAHDI_TONE_DIALRECALL;
2762         case SIG_PRI_TONE_INFO:
2763                 return DAHDI_TONE_INFO;
2764         case SIG_PRI_TONE_BUSY:
2765                 return DAHDI_TONE_BUSY;
2766         default:
2767                 return -1;
2768         }
2769 }
2770 #endif  /* defined(HAVE_PRI) */
2771
2772 #if defined(HAVE_PRI)
2773 static void my_handle_dchan_exception(struct sig_pri_span *pri, int index)
2774 {
2775         int x;
2776
2777         ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
2778         switch (x) {
2779         case DAHDI_EVENT_NONE:
2780                 break;
2781         case DAHDI_EVENT_ALARM:
2782         case DAHDI_EVENT_NOALARM:
2783                 if (sig_pri_is_alarm_ignored(pri)) {
2784                         break;
2785                 }
2786                 /* Fall through */
2787         default:
2788                 ast_log(LOG_NOTICE, "Got DAHDI event: %s (%d) on D-channel of span %d\n",
2789                         event2str(x), x, pri->span);
2790                 break;
2791         }
2792         /* Keep track of alarm state */
2793         switch (x) {
2794         case DAHDI_EVENT_ALARM:
2795                 pri_event_alarm(pri, index, 0);
2796                 break;
2797         case DAHDI_EVENT_NOALARM:
2798                 pri_event_noalarm(pri, index, 0);
2799                 break;
2800         case DAHDI_EVENT_REMOVED:
2801                 pri_queue_for_destruction(pri);
2802                 break;
2803         default:
2804                 break;
2805         }
2806 }
2807 #endif  /* defined(HAVE_PRI) */
2808
2809 #if defined(HAVE_PRI)
2810 static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
2811 {
2812         struct dahdi_pvt *p = pvt;
2813
2814         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
2815 }
2816 #endif  /* defined(HAVE_PRI) */
2817
2818 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2819 /*!
2820  * \internal
2821  * \brief Set the caller id information.
2822  * \since 1.8
2823  *
2824  * \param pvt DAHDI private structure
2825  * \param caller Caller-id information to set.
2826  *
2827  * \return Nothing
2828  */
2829 static void my_set_callerid(void *pvt, const struct ast_party_caller *caller)
2830 {
2831         struct dahdi_pvt *p = pvt;
2832
2833         ast_copy_string(p->cid_num,
2834                 S_COR(caller->id.number.valid, caller->id.number.str, ""),
2835                 sizeof(p->cid_num));
2836         ast_copy_string(p->cid_name,
2837                 S_COR(caller->id.name.valid, caller->id.name.str, ""),
2838                 sizeof(p->cid_name));
2839         ast_copy_string(p->cid_subaddr,
2840                 S_COR(caller->id.subaddress.valid, caller->id.subaddress.str, ""),
2841                 sizeof(p->cid_subaddr));
2842         p->cid_ton = caller->id.number.plan;
2843         p->callingpres = ast_party_id_presentation(&caller->id);
2844         if (caller->id.tag) {
2845                 ast_copy_string(p->cid_tag, caller->id.tag, sizeof(p->cid_tag));
2846         }
2847         ast_copy_string(p->cid_ani,
2848                 S_COR(caller->ani.number.valid, caller->ani.number.str, ""),
2849                 sizeof(p->cid_ani));
2850         p->cid_ani2 = caller->ani2;
2851 }
2852 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2853
2854 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2855 /*!
2856  * \internal
2857  * \brief Set the Dialed Number Identifier.
2858  * \since 1.8
2859  *
2860  * \param pvt DAHDI private structure
2861  * \param dnid Dialed Number Identifier string.
2862  *
2863  * \return Nothing
2864  */
2865 static void my_set_dnid(void *pvt, const char *dnid)
2866 {
2867         struct dahdi_pvt *p = pvt;
2868
2869         ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
2870 }
2871 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2872
2873 #if defined(HAVE_PRI)
2874 /*!
2875  * \internal
2876  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
2877  * \since 1.8
2878  *
2879  * \param pvt DAHDI private structure
2880  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
2881  *
2882  * \return Nothing
2883  */
2884 static void my_set_rdnis(void *pvt, const char *rdnis)
2885 {
2886         struct dahdi_pvt *p = pvt;
2887
2888         ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
2889 }
2890 #endif  /* defined(HAVE_PRI) */
2891
2892 #if defined(HAVE_PRI)
2893 /*!
2894  * \internal
2895  * \brief Make a dialstring for native ISDN CC to recall properly.
2896  * \since 1.8
2897  *
2898  * \param priv Channel private control structure.
2899  * \param buf Where to put the modified dialstring.
2900  * \param buf_size Size of modified dialstring buffer.
2901  *
2902  * \details
2903  * original dialstring:
2904  * DAHDI/[i<span>-](g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2905  *
2906  * The modified dialstring will have prefixed the channel-group section
2907  * with the ISDN channel restriction.
2908  *
2909  * buf:
2910  * DAHDI/i<span>-(g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2911  *
2912  * The routine will check to see if the ISDN channel restriction is already
2913  * in the original dialstring.
2914  *
2915  * \return Nothing
2916  */
2917 static void my_pri_make_cc_dialstring(void *priv, char *buf, size_t buf_size)
2918 {
2919         char *dial;
2920         struct dahdi_pvt *pvt;
2921         AST_DECLARE_APP_ARGS(args,
2922                 AST_APP_ARG(tech);      /* channel technology token */
2923                 AST_APP_ARG(group);     /* channel/group token */
2924                 //AST_APP_ARG(ext);     /* extension token */
2925                 //AST_APP_ARG(opts);    /* options token */
2926                 //AST_APP_ARG(other);   /* Any remining unused arguments */
2927         );
2928
2929         pvt = priv;
2930         dial = ast_strdupa(pvt->dialstring);
2931         AST_NONSTANDARD_APP_ARGS(args, dial, '/');
2932         if (!args.tech) {
2933                 ast_copy_string(buf, pvt->dialstring, buf_size);
2934                 return;
2935         }
2936         if (!args.group) {
2937                 /* Append the ISDN span channel restriction to the dialstring. */
2938                 snprintf(buf, buf_size, "%s/i%d-", args.tech, pvt->pri->span);
2939                 return;
2940         }
2941         if (isdigit(args.group[0]) || args.group[0] == 'i' || strchr(args.group, '!')) {
2942                 /* The ISDN span channel restriction is not needed or already
2943                  * in the dialstring. */
2944                 ast_copy_string(buf, pvt->dialstring, buf_size);
2945                 return;
2946         }
2947         /* Insert the ISDN span channel restriction into the dialstring. */
2948         snprintf(buf, buf_size, "%s/i%d-%s", args.tech, pvt->pri->span, args.group);
2949 }
2950 #endif  /* defined(HAVE_PRI) */
2951
2952 #if defined(HAVE_PRI)
2953 /*!
2954  * \internal
2955  * \brief Reevaluate the PRI span device state.
2956  * \since 1.8
2957  *
2958  * \param pri Asterisk D channel control structure.
2959  *
2960  * \return Nothing
2961  *
2962  * \note Assumes the pri->lock is already obtained.
2963  */
2964 static void dahdi_pri_update_span_devstate(struct sig_pri_span *pri)
2965 {
2966         unsigned idx;
2967         unsigned num_b_chans;   /* Number of B channels provisioned on the span. */
2968         unsigned in_use;                /* Number of B channels in use on the span. */
2969         unsigned in_alarm;              /* TRUE if the span is in alarm condition. */
2970         enum ast_device_state new_state;
2971
2972         /* Count the number of B channels and the number of B channels in use. */
2973         num_b_chans = 0;
2974         in_use = 0;
2975         in_alarm = 1;
2976         for (idx = pri->numchans; idx--;) {
2977                 if (pri->pvts[idx] && !pri->pvts[idx]->no_b_channel) {
2978                         /* This is a B channel interface. */
2979                         ++num_b_chans;
2980                         if (!sig_pri_is_chan_available(pri->pvts[idx])) {
2981                                 ++in_use;
2982                         }
2983                         if (!pri->pvts[idx]->inalarm) {
2984                                 /* There is a channel that is not in alarm. */
2985                                 in_alarm = 0;
2986                         }
2987                 }
2988         }
2989
2990         /* Update the span congestion device state and report any change. */
2991         if (in_alarm) {
2992                 new_state = AST_DEVICE_UNAVAILABLE;
2993         } else {
2994                 new_state = num_b_chans == in_use ? AST_DEVICE_BUSY : AST_DEVICE_NOT_INUSE;
2995         }
2996         if (pri->congestion_devstate != new_state) {
2997                 pri->congestion_devstate = new_state;
2998                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/congestion", pri->span);
2999         }
3000 #if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
3001         /* Update the span threshold device state and report any change. */
3002         if (in_alarm) {
3003                 new_state = AST_DEVICE_UNAVAILABLE;
3004         } else if (!in_use) {
3005                 new_state = AST_DEVICE_NOT_INUSE;
3006         } else if (!pri->user_busy_threshold) {
3007                 new_state = in_use < num_b_chans ? AST_DEVICE_INUSE : AST_DEVICE_BUSY;
3008         } else {
3009                 new_state = in_use < pri->user_busy_threshold ? AST_DEVICE_INUSE
3010                         : AST_DEVICE_BUSY;
3011         }
3012         if (pri->threshold_devstate != new_state) {
3013                 pri->threshold_devstate = new_state;
3014                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/threshold", pri->span);
3015         }
3016 #endif  /* defined(THRESHOLD_DEVSTATE_PLACEHOLDER) */
3017 }
3018 #endif  /* defined(HAVE_PRI) */
3019
3020 #if defined(HAVE_PRI)
3021 /*!
3022  * \internal
3023  * \brief Reference this module.
3024  * \since 1.8
3025  *
3026  * \return Nothing
3027  */
3028 static void my_module_ref(void)
3029 {
3030         ast_module_ref(ast_module_info->self);
3031 }
3032 #endif  /* defined(HAVE_PRI) */
3033
3034 #if defined(HAVE_PRI)
3035 /*!
3036  * \internal
3037  * \brief Unreference this module.
3038  * \since 1.8
3039  *
3040  * \return Nothing
3041  */
3042 static void my_module_unref(void)
3043 {
3044         ast_module_unref(ast_module_info->self);
3045 }
3046 #endif  /* defined(HAVE_PRI) */
3047
3048 #if defined(HAVE_PRI)
3049 #if defined(HAVE_PRI_CALL_WAITING)
3050 static void my_pri_init_config(void *priv, struct sig_pri_span *pri);
3051 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
3052 static int dahdi_new_pri_nobch_channel(struct sig_pri_span *pri);
3053
3054 struct sig_pri_callback sig_pri_callbacks =
3055 {
3056         .handle_dchan_exception = my_handle_dchan_exception,
3057         .play_tone = my_pri_play_tone,
3058         .set_echocanceller = my_set_echocanceller,
3059         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
3060         .lock_private = my_lock_private,
3061         .unlock_private = my_unlock_private,
3062         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3063         .new_ast_channel = my_new_pri_ast_channel,
3064         .fixup_chans = my_pri_fixup_chans,
3065         .set_alarm = my_set_alarm,
3066         .set_dialing = my_set_dialing,
3067         .set_outgoing = my_set_outgoing,
3068         .set_digital = my_set_digital,
3069         .set_callerid = my_set_callerid,
3070         .set_dnid = my_set_dnid,
3071         .set_rdnis = my_set_rdnis,
3072         .new_nobch_intf = dahdi_new_pri_nobch_channel,
3073 #if defined(HAVE_PRI_CALL_WAITING)
3074         .init_config = my_pri_init_config,
3075 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
3076         .get_orig_dialstring = my_get_orig_dialstring,
3077         .make_cc_dialstring = my_pri_make_cc_dialstring,
3078         .update_span_devstate = dahdi_pri_update_span_devstate,
3079         .module_ref = my_module_ref,
3080         .module_unref = my_module_unref,
3081         .dial_digits = my_pri_dial_digits,
3082         .open_media = my_pri_ss7_open_media,
3083         .ami_channel_event = my_ami_channel_event,
3084         .destroy_later = pri_queue_for_destruction,
3085 };
3086 #endif  /* defined(HAVE_PRI) */
3087
3088 #if defined(HAVE_SS7)
3089 /*!
3090  * \internal
3091  * \brief Handle the SS7 link exception.
3092  * \since 1.8
3093  *
3094  * \param linkset Controlling linkset for the channel.
3095  * \param which Link index of the signaling channel.
3096  *
3097  * \return Nothing
3098  */
3099 static void my_handle_link_exception(struct sig_ss7_linkset *linkset, int which)
3100 {
3101         int event;
3102
3103         if (ioctl(linkset->fds[which], DAHDI_GETEVENT, &event)) {
3104                 ast_log(LOG_ERROR, "SS7: Error in exception retrieval on span %d/%d!\n",
3105                         linkset->span, which);
3106                 return;
3107         }
3108         switch (event) {
3109         case DAHDI_EVENT_NONE:
3110                 break;
3111         case DAHDI_EVENT_ALARM:
3112                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
3113                         event2str(event), event, linkset->span, which);
3114                 sig_ss7_link_alarm(linkset, which);
3115                 break;
3116         case DAHDI_EVENT_NOALARM:
3117                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
3118                         event2str(event), event, linkset->span, which);
3119                 sig_ss7_link_noalarm(linkset, which);
3120                 break;
3121         default:
3122                 ast_log(LOG_NOTICE, "SS7 got event: %s(%d) on span %d/%d\n",
3123                         event2str(event), event, linkset->span, which);
3124                 break;
3125         }
3126 }
3127 #endif  /* defined(HAVE_SS7) */
3128
3129 #if defined(HAVE_SS7)
3130 static void my_ss7_set_loopback(void *pvt, int enable)
3131 {
3132         struct dahdi_pvt *p = pvt;
3133
3134         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_LOOPBACK, &enable)) {
3135                 ast_log(LOG_WARNING, "Unable to set loopback on channel %d: %s\n", p->channel,
3136                         strerror(errno));
3137         }
3138 }
3139 #endif  /* defined(HAVE_SS7) */
3140
3141 #if defined(HAVE_SS7)
3142 /*!
3143  * \internal
3144  * \brief Find the linkset to which SS7 belongs.
3145  * \since 11.0
3146  *
3147  * \param ss7 structure to match on.
3148  *
3149  * \retval linkset if found.
3150  * \retval NULL if not found.
3151  */
3152 static struct sig_ss7_linkset *my_ss7_find_linkset(struct ss7 *ss7)
3153 {
3154         int idx;
3155
3156         if (!ss7) {
3157                 return NULL;
3158         }
3159
3160         for (idx = 0; idx < NUM_SPANS; ++idx) {
3161                 if (linksets[idx].ss7.ss7 == ss7) {
3162                         return &linksets[idx].ss7;
3163                 }
3164         }
3165         return NULL;
3166 }
3167 #endif  /* defined(HAVE_SS7) */
3168
3169 #if defined(HAVE_SS7)
3170 /*!
3171  * \internal
3172  * \brief Create a new asterisk channel structure for SS7.
3173  * \since 1.8
3174  *
3175  * \param pvt Private channel structure.
3176  * \param state Initial state of new channel.
3177  * \param law Combanding law to use.
3178  * \param exten Dialplan extension for incoming call.
3179  * \param requestor Channel requesting this new channel.
3180  *
3181  * \retval ast_channel on success.
3182  * \retval NULL on error.
3183  */
3184 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)
3185 {
3186         struct dahdi_pvt *p = pvt;
3187         int audio;
3188         int newlaw;
3189         struct ast_callid *callid = NULL;
3190         int callid_created = ast_callid_threadstorage_auto(&callid);
3191
3192         /* Set to audio mode at this point */
3193         audio = 1;
3194         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1)
3195                 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
3196                         p->channel, audio, strerror(errno));
3197
3198         if (law != SIG_SS7_DEFLAW) {
3199                 dahdi_setlaw(p->subs[SUB_REAL].dfd,
3200                         (law == SIG_SS7_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
3201         }
3202
3203         ast_copy_string(p->exten, exten, sizeof(p->exten));
3204
3205         newlaw = -1;
3206         switch (law) {
3207         case SIG_SS7_DEFLAW:
3208                 newlaw = 0;
3209                 break;
3210         case SIG_SS7_ALAW:
3211                 newlaw = DAHDI_LAW_ALAW;
3212                 break;
3213         case SIG_SS7_ULAW:
3214                 newlaw = DAHDI_LAW_MULAW;
3215                 break;
3216         }
3217         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
3218 }
3219 #endif  /* defined(HAVE_SS7) */
3220
3221 #if defined(HAVE_SS7)
3222 static int sig_ss7_tone_to_dahditone(enum sig_ss7_tone tone)
3223 {
3224         switch (tone) {
3225         case SIG_SS7_TONE_RINGTONE:
3226                 return DAHDI_TONE_RINGTONE;
3227         case SIG_SS7_TONE_STUTTER:
3228                 return DAHDI_TONE_STUTTER;
3229         case SIG_SS7_TONE_CONGESTION:
3230                 return DAHDI_TONE_CONGESTION;
3231         case SIG_SS7_TONE_DIALTONE:
3232                 return DAHDI_TONE_DIALTONE;
3233         case SIG_SS7_TONE_DIALRECALL:
3234                 return DAHDI_TONE_DIALRECALL;
3235         case SIG_SS7_TONE_INFO:
3236                 return DAHDI_TONE_INFO;
3237         case SIG_SS7_TONE_BUSY:
3238                 return DAHDI_TONE_BUSY;
3239         default:
3240                 return -1;
3241         }
3242 }
3243 #endif  /* defined(HAVE_SS7) */
3244
3245 #if defined(HAVE_SS7)
3246 static int my_ss7_play_tone(void *pvt, enum sig_ss7_tone tone)
3247 {
3248         struct dahdi_pvt *p = pvt;
3249
3250         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_ss7_tone_to_dahditone(tone));
3251 }
3252 #endif  /* defined(HAVE_SS7) */
3253
3254 #if defined(HAVE_SS7)
3255 struct sig_ss7_callback sig_ss7_callbacks =
3256 {
3257         .lock_private = my_lock_private,
3258         .unlock_private = my_unlock_private,
3259         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3260
3261         .set_echocanceller = my_set_echocanceller,
3262         .set_loopback = my_ss7_set_loopback,
3263
3264         .new_ast_channel = my_new_ss7_ast_channel,
3265         .play_tone = my_ss7_play_tone,
3266
3267         .handle_link_exception = my_handle_link_exception,
3268         .set_alarm = my_set_alarm,
3269         .set_dialing = my_set_dialing,
3270         .set_outgoing = my_set_outgoing,
3271         .set_digital = my_set_digital,
3272         .set_inservice = my_set_inservice,
3273         .set_locallyblocked = my_set_locallyblocked,
3274         .set_remotelyblocked = my_set_remotelyblocked,
3275         .set_callerid = my_set_callerid,
3276         .set_dnid = my_set_dnid,
3277         .open_media = my_pri_ss7_open_media,
3278         .find_linkset = my_ss7_find_linkset,
3279 };
3280 #endif  /* defined(HAVE_SS7) */
3281
3282 /*!
3283  * \brief Send MWI state change
3284  *
3285  * \param mailbox This is the mailbox associated with the FXO line that the
3286  *      MWI state has changed on.
3287  * \param thereornot This argument should simply be set to 1 or 0, to indicate
3288  *      whether there are messages waiting or not.
3289  *
3290  *  \return nothing
3291  *
3292  * This function does two things:
3293  *
3294  * 1) It generates an internal Asterisk event notifying any other module that
3295  *    cares about MWI that the state of a mailbox has changed.
3296  *
3297  * 2) It runs the script specified by the mwimonitornotify option to allow
3298  *    some custom handling of the state change.
3299  */
3300 static void notify_message(char *mailbox, int thereornot)
3301 {
3302         char s[sizeof(mwimonitornotify) + 80];
3303
3304         if (ast_strlen_zero(mailbox)) {
3305                 return;
3306         }
3307
3308         ast_publish_mwi_state(mailbox, NULL, thereornot, thereornot);
3309         if (!ast_strlen_zero(mwimonitornotify)) {
3310                 snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot);
3311                 ast_safe_system(s);
3312         }
3313 }
3314
3315 static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
3316 {
3317         struct dahdi_pvt *p = pvt;
3318
3319         if (neon_mwievent > -1 && !p->mwimonitor_neon)
3320                 return;
3321
3322         if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) {
3323                 ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox);
3324                 notify_message(p->mailbox, 1);
3325         } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) {
3326                 ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox);
3327                 notify_message(p->mailbox, 0);
3328         }
3329         /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */
3330         /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */
3331         if (neon_mwievent == -1 && p->mwimonitor_rpas) {
3332                 ast_hangup(chan);
3333                 return;
3334         }
3335 }
3336
3337 static int my_have_progressdetect(void *pvt)
3338 {
3339         struct dahdi_pvt *p = pvt;
3340
3341         if ((p->callprogress & CALLPROGRESS_PROGRESS)
3342                 && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
3343                 return 1;
3344         } else {
3345                 /* Don't have progress detection. */
3346                 return 0;
3347         }
3348 }
3349
3350 struct analog_callback analog_callbacks =
3351 {
3352         .play_tone = my_play_tone,
3353         .get_event = my_get_event,
3354         .wait_event = my_wait_event,
3355         .is_off_hook = my_is_off_hook,
3356         .set_echocanceller = my_set_echocanceller,
3357         .ring = my_ring,
3358         .flash = my_flash,
3359         .off_hook = my_off_hook,
3360         .dial_digits = my_dial_digits,
3361         .train_echocanceller = my_train_echocanceller,
3362         .on_hook = my_on_hook,
3363         .is_dialing = my_is_dialing,
3364         .allocate_sub = my_allocate_sub,
3365         .unallocate_sub = my_unallocate_sub,
3366         .swap_subs = my_swap_subchannels,
3367         .has_voicemail = my_has_voicemail,
3368         .check_for_conference = my_check_for_conference,
3369         .conf_add = my_conf_add,
3370         .conf_del = my_conf_del,
3371         .complete_conference_update = my_complete_conference_update,
3372         .start = my_start,
3373         .all_subchannels_hungup = my_all_subchannels_hungup,
3374         .lock_private = my_lock_private,
3375         .unlock_private = my_unlock_private,
3376         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3377         .handle_dtmf = my_handle_dtmf,
3378         .wink = my_wink,
3379         .new_ast_channel = my_new_analog_ast_channel,
3380         .dsp_set_digitmode = my_dsp_set_digitmode,
3381         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
3382         .send_callerid = my_send_callerid,
3383         .callwait = my_callwait,
3384         .stop_callwait = my_stop_callwait,
3385         .get_callerid = my_get_callerid,
3386         .start_cid_detect = my_start_cid_detect,
3387         .stop_cid_detect = my_stop_cid_detect,
3388         .handle_notify_message = my_handle_notify_message,
3389         .increase_ss_count = my_increase_ss_count,
3390         .decrease_ss_count = my_decrease_ss_count,
3391         .distinctive_ring = my_distinctive_ring,
3392         .set_linear_mode = my_set_linear_mode,
3393         .set_inthreeway = my_set_inthreeway,
3394         .get_and_handle_alarms = my_get_and_handle_alarms,
3395         .get_sigpvt_bridged_channel = my_get_sigpvt_bridged_channel,
3396         .get_sub_fd = my_get_sub_fd,
3397         .set_cadence = my_set_cadence,
3398         .set_alarm = my_set_alarm,
3399         .set_dialing = my_set_dialing,
3400         .set_outgoing = my_set_outgoing,
3401         .set_ringtimeout = my_set_ringtimeout,
3402         .set_waitingfordt = my_set_waitingfordt,
3403         .check_waitingfordt = my_check_waitingfordt,
3404         .set_confirmanswer = my_set_confirmanswer,
3405         .check_confirmanswer = my_check_confirmanswer,
3406         .set_callwaiting = my_set_callwaiting,
3407         .cancel_cidspill = my_cancel_cidspill,
3408         .confmute = my_confmute,
3409         .set_pulsedial = my_set_pulsedial,
3410         .set_new_owner = my_set_new_owner,
3411         .get_orig_dialstring = my_get_orig_dialstring,
3412         .set_needringing = my_set_needringing,
3413         .set_polarity = my_set_polarity,
3414         .start_polarityswitch = my_start_polarityswitch,
3415         .answer_polarityswitch = my_answer_polarityswitch,
3416         .hangup_polarityswitch = my_hangup_polarityswitch,
3417         .have_progressdetect = my_have_progressdetect,
3418 };
3419
3420 /*! Round robin search locations. */
3421 static struct dahdi_pvt *round_robin[32];
3422
3423 int _dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
3424 {
3425         int res;
3426         if (p->subs[SUB_REAL].owner == ast)
3427                 res = 0;
3428         else if (p->subs[SUB_CALLWAIT].owner == ast)
3429                 res = 1;
3430         else if (p->subs[SUB_THREEWAY].owner == ast)
3431                 res = 2;
3432         else {
3433                 res = -1;
3434                 if (!nullok)
3435                         ast_log(LOG_WARNING,
3436                                 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
3437                                 ast ? ast_channel_name(ast) : "", p->channel, fname, line);
3438         }
3439         return res;
3440 }
3441
3442 /*!
3443  * \internal
3444  * \brief Obtain the specified subchannel owner lock if the owner exists.
3445  *
3446  * \param pvt Channel private struct.
3447  * \param sub_idx Subchannel owner to lock.
3448  *
3449  * \note Assumes the pvt->lock is already obtained.
3450  *
3451  * \note
3452  * Because deadlock avoidance may have been necessary, you need to confirm
3453  * the state of things before continuing.
3454  *
3455  * \return Nothing
3456  */
3457 static void dahdi_lock_sub_owner(struct dahdi_pvt *pvt, int sub_idx)
3458 {
3459         for (;;) {
3460                 if (!pvt->subs[sub_idx].owner) {
3461                         /* No subchannel owner pointer */
3462                         break;
3463                 }
3464                 if (!ast_channel_trylock(pvt->subs[sub_idx].owner)) {
3465                         /* Got subchannel owner lock */
3466                         break;
3467                 }
3468                 /* We must unlock the private to avoid the possibility of a deadlock */
3469                 DEADLOCK_AVOIDANCE(&pvt->lock);
3470         }
3471 }
3472
3473 static void wakeup_sub(struct dahdi_pvt *p, int a)
3474 {
3475         dahdi_lock_sub_owner(p, a);
3476         if (p->subs[a].owner) {
3477                 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
3478                 ast_channel_unlock(p->subs[a].owner);
3479         }
3480 }
3481
3482 static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f)
3483 {
3484         for (;;) {
3485                 if (p->owner) {
3486                         if (ast_channel_trylock(p->owner)) {
3487                                 DEADLOCK_AVOIDANCE(&p->lock);
3488                         } else {
3489                                 ast_queue_frame(p->owner, f);
3490                                 ast_channel_unlock(p->owner);
3491                                 break;
3492                         }
3493                 } else
3494                         break;
3495         }
3496 }
3497
3498 static void publish_channel_alarm_clear(int channel)
3499 {
3500         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3501         RAII_VAR(struct ast_str *, dahdi_chan, ast_str_create(32), ast_free);
3502         if (!dahdi_chan) {
3503                 return;
3504         }
3505
3506         ast_str_set(&dahdi_chan, 0, "%d", channel);
3507         ast_log(LOG_NOTICE, "Alarm cleared on channel DAHDI/%d\n", channel);
3508         body = ast_json_pack("{s: s}", "DAHDIChannel", ast_str_buffer(dahdi_chan));
3509         if (!body) {
3510                 return;
3511         }
3512
3513         ast_manager_publish_event("AlarmClear", EVENT_FLAG_SYSTEM, body);
3514 }
3515
3516 static void publish_span_alarm_clear(int span)
3517 {
3518         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3519
3520         ast_log(LOG_NOTICE, "Alarm cleared on span %d\n", span);
3521         body = ast_json_pack("{s: i}", "Span", span);
3522         if (!body) {
3523                 return;
3524         }
3525
3526         ast_manager_publish_event("SpanAlarmClear", EVENT_FLAG_SYSTEM, body);
3527 }
3528
3529 static void handle_clear_alarms(struct dahdi_pvt *p)
3530 {
3531 #if defined(HAVE_PRI)
3532         if (dahdi_sig_pri_lib_handles(p->sig) && sig_pri_is_alarm_ignored(p->pri)) {
3533                 return;
3534         }
3535 #endif  /* defined(HAVE_PRI) */
3536
3537         if (report_alarms & REPORT_CHANNEL_ALARMS) {
3538                 publish_channel_alarm_clear(p->channel);
3539         }
3540         if (report_alarms & REPORT_SPAN_ALARMS && p->manages_span_alarms) {
3541                 publish_span_alarm_clear(p->span);
3542         }
3543 }
3544
3545 #ifdef HAVE_OPENR2
3546
3547 static int dahdi_r2_answer(struct dahdi_pvt *p)
3548 {
3549         int res = 0;
3550         /* openr2 1.1.0 and older does not even define OR2_LIB_INTERFACE
3551         * and does not has support for openr2_chan_answer_call_with_mode
3552         *  */
3553 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
3554         const char *double_answer = pbx_builtin_getvar_helper(p->owner, "MFCR2_DOUBLE_ANSWER");
3555         int wants_double_answer = ast_true(double_answer) ? 1 : 0;
3556         if (!double_answer) {
3557                 /* this still can result in double answer if the channel context
3558                 * was configured that way */
3559                 res = openr2_chan_answer_call(p->r2chan);
3560         } else if (wants_double_answer) {
3561                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
3562         } else {
3563                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
3564         }
3565 #else
3566         res = openr2_chan_answer_call(p->r2chan);
3567 #endif
3568         return res;
3569 }
3570
3571
3572
3573 /* should be called with the ast_channel locked */
3574 static openr2_calling_party_category_t dahdi_r2_get_channel_category(struct ast_channel *c)
3575 {
3576         openr2_calling_party_category_t cat;
3577         const char *catstr = pbx_builtin_getvar_helper(c, "MFCR2_CATEGORY");
3578         struct dahdi_pvt *p = ast_channel_tech_pvt(c);
3579         if (ast_strlen_zero(catstr)) {
3580                 ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
3581                                 ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3582                 return p->mfcr2_category;
3583         }
3584         if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
3585                 ast_log(LOG_WARNING, "Invalid category specified '%s' for chan %s, using default %s\n",
3586                                 catstr, ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3587                 return p->mfcr2_category;
3588         }
3589         ast_debug(1, "Using category %s\n", catstr);
3590         return cat;
3591 }
3592
3593 static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
3594 {
3595         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3596         ast_mutex_lock(&p->lock);
3597         if (p->mfcr2call) {
3598                 ast_mutex_unlock(&p->lock);
3599                 /* TODO: This can happen when some other thread just finished dahdi_request requesting this very same
3600                    interface but has not yet seized the line (dahdi_call), and the far end wins and seize the line,
3601                    can we avoid this somehow?, at this point when dahdi_call send the seize, it is likely that since
3602                    the other end will see our seize as a forced release and drop the call, we will see an invalid
3603                    pattern that will be seen and treated as protocol error. */
3604                 ast_log(LOG_ERROR, "Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
3605                 return;
3606         }
3607         p->mfcr2call = 1;
3608         /* better safe than sorry ... */
3609         p->cid_name[0] = '\0';
3610         p->cid_num[0] = '\0';
3611         p->cid_subaddr[0] = '\0';
3612         p->rdnis[0] = '\0';
3613         p->exten[0] = '\0';
3614         p->mfcr2_ani_index = '\0';
3615         p->mfcr2_dnis_index = '\0';
3616         p->mfcr2_dnis_matched = 0;
3617         p->mfcr2_answer_pending = 0;
3618         p->mfcr2_call_accepted = 0;
3619         ast_mutex_unlock(&p->lock);
3620         ast_verbose("New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
3621 }
3622
3623 static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm)
3624 {
3625         int res;
3626         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3627         ast_mutex_lock(&p->lock);
3628         p->inalarm = alarm ? 1 : 0;
3629         if (p->inalarm) {
3630                 res = get_alarms(p);
3631                 handle_alarms(p, res);
3632         } else {
3633                 handle_clear_alarms(p);
3634         }
3635         ast_mutex_unlock(&p->lock);
3636 }
3637
3638 static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
3639 {
3640         ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
3641 }
3642
3643 static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
3644 {
3645         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3646         ast_log(LOG_ERROR, "MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
3647         if (p->owner) {
3648                 ast_channel_hangupcause_set(p->owner, AST_CAUSE_PROTOCOL_ERROR);
3649                 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
3650         }
3651         ast_mutex_lock(&p->lock);
3652         p->mfcr2call = 0;
3653         ast_mutex_unlock(&p->lock);
3654 }
3655
3656 static void dahdi_r2_disconnect_call(struct dahdi_pvt *p, openr2_call_disconnect_cause_t cause)
3657 {
3658         if (openr2_chan_disconnect_call(p->r2chan, cause)) {
3659                 ast_log(LOG_NOTICE, "Bad! failed to disconnect call on channel %d with reason %s, hope for the best!\n",
3660                    p->channel, openr2_proto_get_disconnect_string(cause));
3661                 /* force the chan to idle and release the call flag now since we will not see a clean on_call_end */
3662                 openr2_chan_set_idle(p->r2chan);
3663                 ast_mutex_lock(&p->lock);
3664                 p->mfcr2call = 0;
3665                 ast_mutex_unlock(&p->lock);
3666         }
3667 }
3668
3669 static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category)
3670 {
3671         struct dahdi_pvt *p;
3672         struct ast_channel *c;
3673         struct ast_callid *callid = NULL;
3674         int callid_created = ast_callid_threadstorage_auto(&callid);
3675         ast_verbose("MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
3676                         openr2_chan_get_number(r2chan), ani ? ani : "(restricted)", dnis,
3677                         openr2_proto_get_category_string(category));
3678         p = openr2_chan_get_client_data(r2chan);
3679         /* if collect calls are not allowed and this is a collect call, reject it! */
3680         if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
3681                 ast_log(LOG_NOTICE, "Rejecting MFC/R2 collect call\n");
3682                 dahdi_r2_disconnect_call(p, OR2_CAUSE_COLLECT_CALL_REJECTED);
3683                 goto dahdi_r2_on_call_offered_cleanup;
3684         }
3685         ast_mutex_lock(&p->lock);
3686         p->mfcr2_recvd_category = category;
3687         /* if we're not supposed to use CID, clear whatever we have */
3688         if (!p->use_callerid) {
3689                 ast_debug(1, "No CID allowed in configuration, CID is being cleared!\n");
3690                 p->cid_num[0] = 0;
3691                 p->cid_name[0] = 0;
3692         }
3693         /* if we're supposed to answer immediately, clear DNIS and set 's' exten */
3694         if (p->immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
3695                 ast_debug(1, "Setting exten => s because of immediate or 0 DNIS configured\n");
3696                 p->exten[0] = 's';
3697                 p->exten[1] = 0;
3698         }
3699         ast_mutex_unlock(&p->lock);
3700         if (!ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
3701                 ast_log(LOG_NOTICE, "MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
3702                                 p->channel, p->exten, p->context);
3703                 dahdi_r2_disconnect_call(p, OR2_CAUSE_UNALLOCATED_NUMBER);
3704                 goto dahdi_r2_on_call_offered_cleanup;
3705         }
3706         if (!p->mfcr2_accept_on_offer) {
3707                 /* The user wants us to start the PBX thread right away without accepting the call first */
3708                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, NULL, callid);
3709                 if (c) {
3710                         /* Done here, don't disable reading now since we still need to generate MF tones to accept
3711                            the call or reject it and detect the tone off condition of the other end, all of this
3712                            will be done in the PBX thread now */
3713                         goto dahdi_r2_on_call_offered_cleanup;
3714                 }
3715                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3716                 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
3717         } else if (p->mfcr2_charge_calls) {
3718                 ast_debug(1, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
3719                 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
3720         } else {
3721                 ast_debug(1, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
3722                 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
3723         }
3724
3725 dahdi_r2_on_call_offered_cleanup:
3726         ast_callid_threadstorage_auto_clean(callid, callid_created);
3727 }
3728
3729 static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
3730 {
3731         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3732         ast_verbose("MFC/R2 call end on channel %d\n", p->channel);
3733         ast_mutex_lock(&p->lock);
3734         p->mfcr2call = 0;
3735         ast_mutex_unlock(&p->lock);
3736 }
3737
3738 static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
3739 {
3740         struct dahdi_pvt *p = NULL;
3741         struct ast_channel *c = NULL;
3742         struct ast_callid *callid = NULL;
3743         int callid_created = ast_callid_threadstorage_auto(&callid);
3744         p = openr2_chan_get_client_data(r2chan);
3745         dahdi_ec_enable(p);
3746         p->mfcr2_call_accepted = 1;
3747         /* if it's an incoming call ... */
3748         if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
3749                 ast_verbose("MFC/R2 call has been accepted on backward channel %d\n", openr2_chan_