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