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