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