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