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