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