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