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