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