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