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