c207fa5584032d922de30c7fec0f65a3d5b14b9d
[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 needanswer:1;
666         unsigned int needflash:1;
667         unsigned int needhold:1;
668         unsigned int needunhold:1;
669         unsigned int linear:1;
670         unsigned int inthreeway:1;
671         struct dahdi_confinfo curconf;
672 };
673
674 #define CONF_USER_REAL          (1 << 0)
675 #define CONF_USER_THIRDCALL     (1 << 1)
676
677 #define MAX_SLAVES      4
678
679 /* States for sending MWI message
680  * First three states are required for send Ring Pulse Alert Signal
681  */
682 typedef enum {
683         MWI_SEND_NULL = 0,
684         MWI_SEND_SA,
685         MWI_SEND_SA_WAIT,
686         MWI_SEND_PAUSE,
687         MWI_SEND_SPILL,
688         MWI_SEND_CLEANUP,
689         MWI_SEND_DONE,
690 } mwisend_states;
691
692 struct mwisend_info {
693         struct  timeval pause;
694         mwisend_states  mwisend_current;
695 };
696
697 static struct dahdi_pvt {
698         ast_mutex_t lock;
699         struct callerid_state *cs;
700         struct ast_channel *owner;                      /*!< Our current active owner (if applicable) */
701                                                         /*!< Up to three channels can be associated with this call */
702
703         struct dahdi_subchannel sub_unused;             /*!< Just a safety precaution */
704         struct dahdi_subchannel subs[3];                        /*!< Sub-channels */
705         struct dahdi_confinfo saveconf;                 /*!< Saved conference info */
706
707         struct dahdi_pvt *slaves[MAX_SLAVES];           /*!< Slave to us (follows our conferencing) */
708         struct dahdi_pvt *master;                               /*!< Master to us (we follow their conferencing) */
709         int inconference;                               /*!< If our real should be in the conference */
710
711         int bufsize;                /*!< Size of the buffers */
712         int buf_no;                                     /*!< Number of buffers */
713         int buf_policy;                         /*!< Buffer policy */
714         int faxbuf_no;              /*!< Number of Fax buffers */
715         int faxbuf_policy;          /*!< Fax buffer policy */
716         int sig;                                        /*!< Signalling style */
717         /*!
718          * \brief Nonzero if the signaling type is sent over a radio.
719          * \note Set to a couple of nonzero values but it is only tested like a boolean.
720          */
721         int radio;
722         int outsigmod;                                  /*!< Outbound Signalling style (modifier) */
723         int oprmode;                                    /*!< "Operator Services" mode */
724         struct dahdi_pvt *oprpeer;                              /*!< "Operator Services" peer tech_pvt ptr */
725         /*! \brief Amount of gain to increase during caller id */
726         float cid_rxgain;
727         /*! \brief Rx gain set by chan_dahdi.conf */
728         float rxgain;
729         /*! \brief Tx gain set by chan_dahdi.conf */
730         float txgain;
731         int tonezone;                                   /*!< tone zone for this chan, or -1 for default */
732         struct dahdi_pvt *next;                         /*!< Next channel in list */
733         struct dahdi_pvt *prev;                         /*!< Prev channel in list */
734
735         /* flags */
736
737         /*!
738          * \brief TRUE if ADSI (Analog Display Services Interface) available
739          * \note Set from the "adsi" value read in from chan_dahdi.conf
740          */
741         unsigned int adsi:1;
742         /*!
743          * \brief TRUE if we can use a polarity reversal to mark when an outgoing
744          * call is answered by the remote party.
745          * \note Set from the "answeronpolarityswitch" value read in from chan_dahdi.conf
746          */
747         unsigned int answeronpolarityswitch:1;
748         /*!
749          * \brief TRUE if busy detection is enabled.
750          * (Listens for the beep-beep busy pattern.)
751          * \note Set from the "busydetect" value read in from chan_dahdi.conf
752          */
753         unsigned int busydetect:1;
754         /*!
755          * \brief TRUE if call return is enabled.
756          * (*69, if your dialplan doesn't catch this first)
757          * \note Set from the "callreturn" value read in from chan_dahdi.conf
758          */
759         unsigned int callreturn:1;
760         /*!
761          * \brief TRUE if busy extensions will hear the call-waiting tone
762          * and can use hook-flash to switch between callers.
763          * \note Can be disabled by dialing *70.
764          * \note Initialized with the "callwaiting" value read in from chan_dahdi.conf
765          */
766         unsigned int callwaiting:1;
767         /*!
768          * \brief TRUE if send caller ID for Call Waiting
769          * \note Set from the "callwaitingcallerid" value read in from chan_dahdi.conf
770          */
771         unsigned int callwaitingcallerid:1;
772         /*!
773          * \brief TRUE if support for call forwarding enabled.
774          * Dial *72 to enable call forwarding.
775          * Dial *73 to disable call forwarding.
776          * \note Set from the "cancallforward" value read in from chan_dahdi.conf
777          */
778         unsigned int cancallforward:1;
779         /*!
780          * \brief TRUE if support for call parking is enabled.
781          * \note Set from the "canpark" value read in from chan_dahdi.conf
782          */
783         unsigned int canpark:1;
784         /*! \brief TRUE if to wait for a DTMF digit to confirm answer */
785         unsigned int confirmanswer:1;
786         /*!
787          * \brief TRUE if the channel is to be destroyed on hangup.
788          * (Used by pseudo channels.)
789          */
790         unsigned int destroy:1;
791         unsigned int didtdd:1;                          /*!< flag to say its done it once */
792         /*! \brief TRUE if analog type line dialed no digits in Dial() */
793         unsigned int dialednone:1;
794         /*! \brief TRUE if in the process of dialing digits or sending something. */
795         unsigned int dialing:1;
796         /*! \brief TRUE if the transfer capability of the call is digital. */
797         unsigned int digital:1;
798         /*! \brief TRUE if Do-Not-Disturb is enabled. */
799         unsigned int dnd:1;
800         /*! \brief XXX BOOLEAN Purpose??? */
801         unsigned int echobreak:1;
802         /*!
803          * \brief TRUE if echo cancellation enabled when bridged.
804          * \note Initialized with the "echocancelwhenbridged" value read in from chan_dahdi.conf
805          * \note Disabled if the echo canceller is not setup.
806          */
807         unsigned int echocanbridged:1;
808         /*! \brief TRUE if echo cancellation is turned on. */
809         unsigned int echocanon:1;
810         /*! \brief TRUE if a fax tone has already been handled. */
811         unsigned int faxhandled:1;
812         /*! TRUE if dynamic faxbuffers are configured for use, default is OFF */
813         unsigned int usefaxbuffers:1;
814         /*! TRUE while buffer configuration override is in use */
815         unsigned int bufferoverrideinuse:1;
816         /*! \brief TRUE if over a radio and dahdi_read() has been called. */
817         unsigned int firstradio:1;
818         /*!
819          * \brief TRUE if the call will be considered "hung up" on a polarity reversal.
820          * \note Set from the "hanguponpolarityswitch" value read in from chan_dahdi.conf
821          */
822         unsigned int hanguponpolarityswitch:1;
823         /*! \brief TRUE if DTMF detection needs to be done by hardware. */
824         unsigned int hardwaredtmf:1;
825         /*!
826          * \brief TRUE if the outgoing caller ID is blocked/hidden.
827          * \note Caller ID can be disabled by dialing *67.
828          * \note Caller ID can be enabled by dialing *82.
829          * \note Initialized with the "hidecallerid" value read in from chan_dahdi.conf
830          */
831         unsigned int hidecallerid:1;
832         /*!
833          * \brief TRUE if hide just the name not the number for legacy PBX use.
834          * \note Only applies to PRI channels.
835          * \note Set from the "hidecalleridname" value read in from chan_dahdi.conf
836          */
837         unsigned int hidecalleridname:1;
838         /*! \brief TRUE if DTMF detection is disabled. */
839         unsigned int ignoredtmf:1;
840         /*!
841          * \brief TRUE if the channel should be answered immediately
842          * without attempting to gather any digits.
843          * \note Set from the "immediate" value read in from chan_dahdi.conf
844          */
845         unsigned int immediate:1;
846         /*! \brief TRUE if in an alarm condition. */
847         unsigned int inalarm:1;
848         /*! \brief TRUE if TDD in MATE mode */
849         unsigned int mate:1;
850         /*! \brief TRUE if we originated the call leg. */
851         unsigned int outgoing:1;
852         /* unsigned int overlapdial:1;                  unused and potentially confusing */
853         /*!
854          * \brief TRUE if busy extensions will hear the call-waiting tone
855          * and can use hook-flash to switch between callers.
856          * \note Set from the "callwaiting" value read in from chan_dahdi.conf
857          */
858         unsigned int permcallwaiting:1;
859         /*!
860          * \brief TRUE if the outgoing caller ID is blocked/restricted/hidden.
861          * \note Set from the "hidecallerid" value read in from chan_dahdi.conf
862          */
863         unsigned int permhidecallerid:1;
864         /*!
865          * \brief TRUE if PRI congestion/busy indications are sent out-of-band.
866          * \note Set from the "priindication" value read in from chan_dahdi.conf
867          */
868         unsigned int priindication_oob:1;
869         /*!
870          * \brief TRUE if PRI B channels are always exclusively selected.
871          * \note Set from the "priexclusive" value read in from chan_dahdi.conf
872          */
873         unsigned int priexclusive:1;
874         /*!
875          * \brief TRUE if we will pulse dial.
876          * \note Set from the "pulsedial" value read in from chan_dahdi.conf
877          */
878         unsigned int pulse:1;
879         /*! \brief TRUE if a pulsed digit was detected. (Pulse dial phone detected) */
880         unsigned int pulsedial:1;
881         unsigned int restartpending:1;          /*!< flag to ensure counted only once for restart */
882         /*!
883          * \brief TRUE if caller ID is restricted.
884          * \note Set but not used.  Should be deleted.  Redundant with permhidecallerid.
885          * \note Set from the "restrictcid" value read in from chan_dahdi.conf
886          */
887         unsigned int restrictcid:1;
888         /*!
889          * \brief TRUE if three way calling is enabled
890          * \note Set from the "threewaycalling" value read in from chan_dahdi.conf
891          */
892         unsigned int threewaycalling:1;
893         /*!
894          * \brief TRUE if call transfer is enabled
895          * \note For FXS ports (either direct analog or over T1/E1):
896          *   Support flash-hook call transfer
897          * \note For digital ports using ISDN PRI protocols:
898          *   Support switch-side transfer (called 2BCT, RLT or other names)
899          * \note Set from the "transfer" value read in from chan_dahdi.conf
900          */
901         unsigned int transfer:1;
902         /*!
903          * \brief TRUE if caller ID is used on this channel.
904          * \note PRI and SS7 spans will save caller ID from the networking peer.
905          * \note FXS ports will generate the caller ID spill.
906          * \note FXO ports will listen for the caller ID spill.
907          * \note Set from the "usecallerid" value read in from chan_dahdi.conf
908          */
909         unsigned int use_callerid:1;
910         /*!
911          * \brief TRUE if we will use the calling presentation setting
912          * from the Asterisk channel for outgoing calls.
913          * \note Only applies to PRI and SS7 channels.
914          * \note Set from the "usecallingpres" value read in from chan_dahdi.conf
915          */
916         unsigned int use_callingpres:1;
917         /*!
918          * \brief TRUE if distinctive rings are to be detected.
919          * \note For FXO lines
920          * \note Set indirectly from the "usedistinctiveringdetection" value read in from chan_dahdi.conf
921          */
922         unsigned int usedistinctiveringdetection:1;
923         /*!
924          * \brief TRUE if we should use the callerid from incoming call on dahdi transfer.
925          * \note Set from the "useincomingcalleridondahditransfer" value read in from chan_dahdi.conf
926          */
927         unsigned int dahditrcallerid:1;
928         /*!
929          * \brief TRUE if allowed to flash-transfer to busy channels.
930          * \note Set from the "transfertobusy" value read in from chan_dahdi.conf
931          */
932         unsigned int transfertobusy:1;
933         /*!
934          * \brief TRUE if the FXO port monitors for neon type MWI indications from the other end.
935          * \note Set if the "mwimonitor" value read in contains "neon" from chan_dahdi.conf
936          */
937         unsigned int mwimonitor_neon:1;
938         /*!
939          * \brief TRUE if the FXO port monitors for fsk type MWI indications from the other end.
940          * \note Set if the "mwimonitor" value read in contains "fsk" from chan_dahdi.conf
941          */
942         unsigned int mwimonitor_fsk:1;
943         /*!
944          * \brief TRUE if the FXO port monitors for rpas precursor to fsk MWI indications from the other end.
945          * \note RPAS - Ring Pulse Alert Signal
946          * \note Set if the "mwimonitor" value read in contains "rpas" from chan_dahdi.conf
947          */
948         unsigned int mwimonitor_rpas:1;
949         /*! \brief TRUE if an MWI monitor thread is currently active */
950         unsigned int mwimonitoractive:1;
951         /*! \brief TRUE if a MWI message sending thread is active */
952         unsigned int mwisendactive:1;
953         /*!
954          * \brief TRUE if channel is out of reset and ready
955          * \note Set but not used.
956          */
957         unsigned int inservice:1;
958         /*!
959          * \brief TRUE if the channel is locally blocked.
960          * \note Applies to SS7 channels.
961          */
962         unsigned int locallyblocked:1;
963         /*!
964          * \brief TRUE if the channel is remotely blocked.
965          * \note Applies to SS7 channels.
966          */
967         unsigned int remotelyblocked:1;
968 #if defined(HAVE_PRI)
969         struct sig_pri_pri *pri;
970         int prioffset;
971         int logicalspan;
972 #endif
973 #if defined(HAVE_PRI) || defined(HAVE_SS7)
974         /*!
975          * \brief XXX BOOLEAN Purpose???
976          * \note Applies to SS7 channels.
977          */
978         unsigned int rlt:1;
979         /*! \brief TRUE if channel is alerting/ringing */
980         unsigned int alerting:1;
981         /*! \brief TRUE if the call has already gone/hungup */
982         unsigned int alreadyhungup:1;
983         /*!
984          * \brief TRUE if this is an idle call
985          * \note Applies to PRI channels.
986          */
987         unsigned int isidlecall:1;
988         /*!
989          * \brief TRUE if call is in a proceeding state.
990          * The call has started working its way through the network.
991          */
992         unsigned int proceeding:1;
993         /*! \brief TRUE if the call has seen progress through the network. */
994         unsigned int progress:1;
995         /*!
996          * \brief TRUE if this channel is being reset/restarted
997          * \note Applies to PRI channels.
998          */
999         unsigned int resetting:1;
1000         /*!
1001          * \brief TRUE if this channel has received a SETUP_ACKNOWLEDGE
1002          * \note Applies to PRI channels.
1003          */
1004         unsigned int setup_ack:1;
1005 #endif
1006         /*!
1007          * \brief TRUE if SMDI (Simplified Message Desk Interface) is enabled
1008          * \note Set from the "usesmdi" value read in from chan_dahdi.conf
1009          */
1010         unsigned int use_smdi:1;
1011         struct mwisend_info mwisend_data;
1012         /*! \brief The serial port to listen for SMDI data on */
1013         struct ast_smdi_interface *smdi_iface;
1014
1015         /*! \brief Distinctive Ring data */
1016         struct dahdi_distRings drings;
1017
1018         /*!
1019          * \brief The configured context for incoming calls.
1020          * \note The "context" string read in from chan_dahdi.conf
1021          */
1022         char context[AST_MAX_CONTEXT];
1023         /*!
1024          * \brief Saved context string.
1025          */
1026         char defcontext[AST_MAX_CONTEXT];
1027         /*! \brief Extension to use in the dialplan. */
1028         char exten[AST_MAX_EXTENSION];
1029         /*!
1030          * \brief Language configured for calls.
1031          * \note The "language" string read in from chan_dahdi.conf
1032          */
1033         char language[MAX_LANGUAGE];
1034         /*!
1035          * \brief The configured music-on-hold class to use for calls.
1036          * \note The "musicclass" or "mohinterpret" or "musiconhold" string read in from chan_dahdi.conf
1037          */
1038         char mohinterpret[MAX_MUSICCLASS];
1039         /*!
1040          * \brief Suggested music-on-hold class for peer channel to use for calls.
1041          * \note The "mohsuggest" string read in from chan_dahdi.conf
1042          */
1043         char mohsuggest[MAX_MUSICCLASS];
1044         char parkinglot[AST_MAX_EXTENSION]; /*!< Parking lot for this channel */
1045 #if defined(PRI_ANI) || defined(HAVE_SS7)
1046         /*! \brief Automatic Number Identification number (Alternate PRI caller ID number) */
1047         char cid_ani[AST_MAX_EXTENSION];
1048 #endif
1049         /*! \brief Automatic Number Identification code from PRI */
1050         int cid_ani2;
1051         /*! \brief Caller ID number from an incoming call. */
1052         char cid_num[AST_MAX_EXTENSION];
1053         /*! \brief Caller ID Q.931 TON/NPI field values.  Set by PRI. Zero otherwise. */
1054         int cid_ton;
1055         /*! \brief Caller ID name from an incoming call. */
1056         char cid_name[AST_MAX_EXTENSION];
1057         char *origcid_num;                              /*!< malloced original callerid */
1058         char *origcid_name;                             /*!< malloced original callerid */
1059         /*! \brief Call waiting number. */
1060         char callwait_num[AST_MAX_EXTENSION];
1061         /*! \brief Call waiting name. */
1062         char callwait_name[AST_MAX_EXTENSION];
1063         /*! \brief Redirecting Directory Number Information Service (RDNIS) number */
1064         char rdnis[AST_MAX_EXTENSION];
1065         /*! \brief Dialed Number Identifier */
1066         char dnid[AST_MAX_EXTENSION];
1067         /*!
1068          * \brief Bitmapped groups this belongs to.
1069          * \note The "group" bitmapped group string read in from chan_dahdi.conf
1070          */
1071         ast_group_t group;
1072         /*! \brief Active PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW */
1073         int law;
1074         int confno;                                     /*!< Our conference */
1075         int confusers;                                  /*!< Who is using our conference */
1076         int propconfno;                                 /*!< Propagated conference number */
1077         /*!
1078          * \brief Bitmapped call groups this belongs to.
1079          * \note The "callgroup" bitmapped group string read in from chan_dahdi.conf
1080          */
1081         ast_group_t callgroup;
1082         /*!
1083          * \brief Bitmapped pickup groups this belongs to.
1084          * \note The "pickupgroup" bitmapped group string read in from chan_dahdi.conf
1085          */
1086         ast_group_t pickupgroup;
1087         /*!
1088          * \brief Channel variable list with associated values to set when a channel is created.
1089          * \note The "setvar" strings read in from chan_dahdi.conf
1090          */
1091         struct ast_variable *vars;
1092         int channel;                                    /*!< Channel Number */
1093         int span;                                       /*!< Span number */
1094         time_t guardtime;                               /*!< Must wait this much time before using for new call */
1095         int cid_signalling;                             /*!< CID signalling type bell202 or v23 */
1096         int cid_start;                                  /*!< CID start indicator, polarity or ring */
1097         int callingpres;                                /*!< The value of calling presentation that we're going to use when placing a PRI call */
1098         int callwaitingrepeat;                          /*!< How many samples to wait before repeating call waiting */
1099         int cidcwexpire;                                /*!< When to expire our muting for CID/CW */
1100         /*! \brief Analog caller ID waveform sample buffer */
1101         unsigned char *cidspill;
1102         /*! \brief Position in the cidspill buffer to send out next. */
1103         int cidpos;
1104         /*! \brief Length of the cidspill buffer containing samples. */
1105         int cidlen;
1106         /*! \brief Ring timeout timer?? */
1107         int ringt;
1108         /*!
1109          * \brief Ring timeout base.
1110          * \note Value computed indirectly from "ringtimeout" read in from chan_dahdi.conf
1111          */
1112         int ringt_base;
1113         /*!
1114          * \brief Number of most significant digits/characters to strip from the dialed number.
1115          * \note Feature is deprecated.  Use dialplan logic.
1116          * \note The characters are stripped before the PRI TON/NPI prefix
1117          * characters are processed.
1118          */
1119         int stripmsd;
1120         /*! \brief BOOLEAN. XXX Meaning what?? */
1121         int callwaitcas;
1122         /*! \brief Number of call waiting rings. */
1123         int callwaitrings;
1124         /*! \brief Echo cancel parameters. */
1125         struct {
1126                 struct dahdi_echocanparams head;
1127                 struct dahdi_echocanparam params[DAHDI_MAX_ECHOCANPARAMS];
1128         } echocancel;
1129         /*!
1130          * \brief Echo training time. 0 = disabled
1131          * \note Set from the "echotraining" value read in from chan_dahdi.conf
1132          */
1133         int echotraining;
1134         /*! \brief Filled with 'w'.  XXX Purpose?? */
1135         char echorest[20];
1136         /*!
1137          * \brief Number of times to see "busy" tone before hanging up.
1138          * \note Set from the "busycount" value read in from chan_dahdi.conf
1139          */
1140         int busycount;
1141         /*!
1142          * \brief Length of "busy" tone on time.
1143          * \note Set from the "busypattern" value read in from chan_dahdi.conf
1144          */
1145         int busy_tonelength;
1146         /*!
1147          * \brief Length of "busy" tone off time.
1148          * \note Set from the "busypattern" value read in from chan_dahdi.conf
1149          */
1150         int busy_quietlength;
1151         /*!
1152          * \brief Bitmapped call progress detection flags. CALLPROGRESS_xxx values.
1153          * \note Bits set from the "callprogress" and "faxdetect" values read in from chan_dahdi.conf
1154          */
1155         int callprogress;
1156         /*!
1157          * \brief Number of milliseconds to wait for dialtone.
1158          * \note Set from the "waitfordialtone" value read in from chan_dahdi.conf
1159          */
1160         int waitfordialtone;
1161         struct timeval waitingfordt;                    /*!< Time we started waiting for dialtone */
1162         struct timeval flashtime;                       /*!< Last flash-hook time */
1163         /*! \brief Opaque DSP configuration structure. */
1164         struct ast_dsp *dsp;
1165         /*! \brief DAHDI dial operation command struct for ioctl() call. */
1166         struct dahdi_dialoperation dop;
1167         int whichwink;                                  /*!< SIG_FEATDMF_TA Which wink are we on? */
1168         /*! \brief Second part of SIG_FEATDMF_TA wink operation. */
1169         char finaldial[64];
1170         char accountcode[AST_MAX_ACCOUNT_CODE];         /*!< Account code */
1171         int amaflags;                                   /*!< AMA Flags */
1172         struct tdd_state *tdd;                          /*!< TDD flag */
1173         /*! \brief Accumulated call forwarding number. */
1174         char call_forward[AST_MAX_EXTENSION];
1175         /*!
1176          * \brief Voice mailbox location.
1177          * \note Set from the "mailbox" string read in from chan_dahdi.conf
1178          */
1179         char mailbox[AST_MAX_EXTENSION];
1180         /*! \brief Opaque event subscription parameters for message waiting indication support. */
1181         struct ast_event_sub *mwi_event_sub;
1182         /*! \brief Delayed dialing for E911.  Overlap digits for ISDN. */
1183         char dialdest[256];
1184 #ifdef HAVE_DAHDI_LINEREVERSE_VMWI
1185         struct dahdi_vmwi_info mwisend_setting;                         /*!< Which VMWI methods to use */
1186         unsigned int mwisend_fsk: 1;            /*! Variable for enabling FSK MWI handling in chan_dahdi */
1187         unsigned int mwisend_rpas:1;            /*! Variable for enabling Ring Pulse Alert before MWI FSK Spill */
1188 #endif
1189         int distinctivering;                            /*!< Which distinctivering to use */
1190         int dtmfrelax;                                  /*!< whether to run in relaxed DTMF mode */
1191         /*! \brief Holding place for event injected from outside normal operation. */
1192         int fake_event;
1193         /*!
1194          * \brief Minimal time period (ms) between the answer polarity
1195          * switch and hangup polarity switch.
1196          */
1197         int polarityonanswerdelay;
1198         /*! \brief Start delay time if polarityonanswerdelay is nonzero. */
1199         struct timeval polaritydelaytv;
1200         /*!
1201          * \brief Send caller ID on FXS after this many rings. Set to 1 for US.
1202          * \note Set from the "sendcalleridafter" value read in from chan_dahdi.conf
1203          */
1204         int sendcalleridafter;
1205         /*! \brief Current line interface polarity. POLARITY_IDLE, POLARITY_REV */
1206         int polarity;
1207         /*! \brief DSP feature flags: DSP_FEATURE_xxx */
1208         int dsp_features;
1209 #ifdef HAVE_SS7
1210         /*! \brief SS7 control parameters */
1211         struct dahdi_ss7 *ss7;
1212         /*! \brief Opaque libss7 call control structure */
1213         struct isup_call *ss7call;
1214         char charge_number[50];
1215         char gen_add_number[50];
1216         char gen_dig_number[50];
1217         char orig_called_num[50];
1218         char redirecting_num[50];
1219         char generic_name[50];
1220         unsigned char gen_add_num_plan;
1221         unsigned char gen_add_nai;
1222         unsigned char gen_add_pres_ind;
1223         unsigned char gen_add_type;
1224         unsigned char gen_dig_type;
1225         unsigned char gen_dig_scheme;
1226         char jip_number[50];
1227         unsigned char lspi_type;
1228         unsigned char lspi_scheme;
1229         unsigned char lspi_context;
1230         char lspi_ident[50];
1231         unsigned int call_ref_ident;
1232         unsigned int call_ref_pc;
1233         unsigned char calling_party_cat;
1234         int transcap;
1235         int cic;                                                        /*!< CIC associated with channel */
1236         unsigned int dpc;                                               /*!< CIC's DPC */
1237         unsigned int loopedback:1;
1238 #endif
1239 #ifdef HAVE_OPENR2
1240         struct dahdi_mfcr2 *mfcr2;
1241         openr2_chan_t *r2chan;
1242         openr2_calling_party_category_t mfcr2_recvd_category;
1243         openr2_calling_party_category_t mfcr2_category;
1244         int mfcr2_dnis_index;
1245         int mfcr2_ani_index;
1246         int mfcr2call:1;
1247         int mfcr2_answer_pending:1;
1248         int mfcr2_charge_calls:1;
1249         int mfcr2_allow_collect_calls:1;
1250         int mfcr2_forced_release:1;
1251         int mfcr2_dnis_matched:1;
1252         int mfcr2_call_accepted:1;
1253         int mfcr2_accept_on_offer:1;
1254 #endif
1255         /*! \brief DTMF digit in progress.  0 when no digit in progress. */
1256         char begindigit;
1257         /*! \brief TRUE if confrence is muted. */
1258         int muting;
1259         void *sig_pvt;
1260 } *iflist = NULL, *ifend = NULL;
1261
1262 /*! \brief Channel configuration from chan_dahdi.conf .
1263  * This struct is used for parsing the [channels] section of chan_dahdi.conf.
1264  * Generally there is a field here for every possible configuration item.
1265  *
1266  * The state of fields is saved along the parsing and whenever a 'channel'
1267  * statement is reached, the current dahdi_chan_conf is used to configure the
1268  * channel (struct dahdi_pvt)
1269  *
1270  * \see dahdi_chan_init for the default values.
1271  */
1272 struct dahdi_chan_conf {
1273         struct dahdi_pvt chan;
1274 #ifdef HAVE_PRI
1275         struct dahdi_pri pri;
1276 #endif
1277
1278 #ifdef HAVE_SS7
1279         struct dahdi_ss7 ss7;
1280 #endif
1281
1282 #ifdef HAVE_OPENR2
1283         struct dahdi_mfcr2_conf mfcr2;
1284 #endif
1285         struct dahdi_params timing;
1286         int is_sig_auto; /*!< Use channel signalling from DAHDI? */
1287
1288         /*!
1289          * \brief The serial port to listen for SMDI data on
1290          * \note Set from the "smdiport" string read in from chan_dahdi.conf
1291          */
1292         char smdi_port[SMDI_MAX_FILENAME_LEN];
1293 };
1294
1295 /*! returns a new dahdi_chan_conf with default values (by-value) */
1296 static struct dahdi_chan_conf dahdi_chan_conf_default(void)
1297 {
1298         /* recall that if a field is not included here it is initialized
1299          * to 0 or equivalent
1300          */
1301         struct dahdi_chan_conf conf = {
1302 #ifdef HAVE_PRI
1303                 .pri.pri = {
1304                         .nsf = PRI_NSF_NONE,
1305                         .switchtype = PRI_SWITCH_NI2,
1306                         .dialplan = PRI_UNKNOWN + 1,
1307                         .localdialplan = PRI_NATIONAL_ISDN + 1,
1308                         .nodetype = PRI_CPE,
1309                         .qsigchannelmapping = DAHDI_CHAN_MAPPING_PHYSICAL,
1310
1311                         .minunused = 2,
1312                         .idleext = "",
1313                         .idledial = "",
1314                         .internationalprefix = "",
1315                         .nationalprefix = "",
1316                         .localprefix = "",
1317                         .privateprefix = "",
1318                         .unknownprefix = "",
1319                         .resetinterval = -1,
1320                 },
1321 #endif
1322 #ifdef HAVE_SS7
1323                 .ss7 = {
1324                         .called_nai = SS7_NAI_NATIONAL,
1325                         .calling_nai = SS7_NAI_NATIONAL,
1326                         .internationalprefix = "",
1327                         .nationalprefix = "",
1328                         .subscriberprefix = "",
1329                         .unknownprefix = ""
1330                 },
1331 #endif
1332 #ifdef HAVE_OPENR2
1333                 .mfcr2 = {
1334                         .variant = OR2_VAR_ITU,
1335                         .mfback_timeout = -1,
1336                         .metering_pulse_timeout = -1,
1337                         .max_ani = 10,
1338                         .max_dnis = 4,
1339                         .get_ani_first = -1,
1340 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
1341                         .skip_category_request = -1,
1342 #endif
1343                         .call_files = 0,
1344                         .allow_collect_calls = 0,
1345                         .charge_calls = 1,
1346                         .accept_on_offer = 1,
1347                         .forced_release = 0,
1348                         .double_answer = 0,
1349                         .immediate_accept = -1,
1350                         .logdir = "",
1351                         .r2proto_file = "",
1352                         .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING,
1353                         .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER
1354                 },
1355 #endif
1356                 .chan = {
1357                         .context = "default",
1358                         .cid_num = "",
1359                         .cid_name = "",
1360                         .mohinterpret = "default",
1361                         .mohsuggest = "",
1362                         .parkinglot = "",
1363                         .transfertobusy = 1,
1364
1365                         .cid_signalling = CID_SIG_BELL,
1366                         .cid_start = CID_START_RING,
1367                         .dahditrcallerid = 0,
1368                         .use_callerid = 1,
1369                         .sig = -1,
1370                         .outsigmod = -1,
1371
1372                         .cid_rxgain = +5.0,
1373
1374                         .tonezone = -1,
1375
1376                         .echocancel.head.tap_length = 1,
1377
1378                         .busycount = 3,
1379
1380                         .accountcode = "",
1381
1382                         .mailbox = "",
1383
1384 #ifdef HAVE_DAHDI_LINEREVERSE_VMWI
1385                         .mwisend_fsk = 1,
1386 #endif
1387                         .polarityonanswerdelay = 600,
1388
1389                         .sendcalleridafter = DEFAULT_CIDRINGS,
1390
1391                         .buf_policy = DAHDI_POLICY_IMMEDIATE,
1392                         .buf_no = numbufs,
1393                         .usefaxbuffers = 0,
1394                 },
1395                 .timing = {
1396                         .prewinktime = -1,
1397                         .preflashtime = -1,
1398                         .winktime = -1,
1399                         .flashtime = -1,
1400                         .starttime = -1,
1401                         .rxwinktime = -1,
1402                         .rxflashtime = -1,
1403                         .debouncetime = -1
1404                 },
1405                 .is_sig_auto = 1,
1406                 .smdi_port = "/dev/ttyS0",
1407         };
1408
1409         return conf;
1410 }
1411
1412
1413 static struct ast_channel *dahdi_request(const char *type, int format, const struct ast_channel *requestor, void *data, int *cause);
1414 static int dahdi_digit_begin(struct ast_channel *ast, char digit);
1415 static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
1416 static int dahdi_sendtext(struct ast_channel *c, const char *text);
1417 static int dahdi_call(struct ast_channel *ast, char *rdest, int timeout);
1418 static int dahdi_hangup(struct ast_channel *ast);
1419 static int dahdi_answer(struct ast_channel *ast);
1420 static struct ast_frame *dahdi_read(struct ast_channel *ast);
1421 static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame);
1422 static struct ast_frame *dahdi_exception(struct ast_channel *ast);
1423 static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
1424 static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1425 static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen);
1426 static int dahdi_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
1427 static int dahdi_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len);
1428 static int handle_init_event(struct dahdi_pvt *i, int event);
1429 static int dahdi_func_write(struct ast_channel *chan, const char *function, char *data, const char *value);
1430
1431 static const struct ast_channel_tech dahdi_tech = {
1432         .type = "DAHDI",
1433         .description = tdesc,
1434         .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
1435         .requester = dahdi_request,
1436         .send_digit_begin = dahdi_digit_begin,
1437         .send_digit_end = dahdi_digit_end,
1438         .send_text = dahdi_sendtext,
1439         .call = dahdi_call,
1440         .hangup = dahdi_hangup,
1441         .answer = dahdi_answer,
1442         .read = dahdi_read,
1443         .write = dahdi_write,
1444         .bridge = dahdi_bridge,
1445         .exception = dahdi_exception,
1446         .indicate = dahdi_indicate,
1447         .fixup = dahdi_fixup,
1448         .setoption = dahdi_setoption,
1449         .queryoption = dahdi_queryoption,
1450         .func_channel_read = dahdi_func_read,
1451         .func_channel_write = dahdi_func_write,
1452 };
1453
1454 #define GET_CHANNEL(p) ((p)->channel)
1455
1456 static enum analog_sigtype dahdisig_to_analogsig(int sig)
1457 {
1458         switch (sig) {
1459         case SIG_FXOLS:
1460                 return ANALOG_SIG_FXOLS;
1461         case SIG_FXOGS:
1462                 return ANALOG_SIG_FXOGS;
1463         case SIG_FXOKS:
1464                 return ANALOG_SIG_FXOKS;
1465         case SIG_FXSLS:
1466                 return ANALOG_SIG_FXSLS;
1467         case SIG_FXSGS:
1468                 return ANALOG_SIG_FXSGS;
1469         case SIG_FXSKS:
1470                 return ANALOG_SIG_FXSKS;
1471         case SIG_EMWINK:
1472                 return ANALOG_SIG_EMWINK;
1473         case SIG_EM:
1474                 return ANALOG_SIG_EM;
1475         case SIG_EM_E1:
1476                 return ANALOG_SIG_EM_E1;
1477         case SIG_FEATD:
1478                 return ANALOG_SIG_FEATD;
1479         case SIG_FEATDMF:
1480                 return ANALOG_SIG_FEATDMF;
1481         case SIG_E911:
1482                 return SIG_E911;
1483         case SIG_FGC_CAMA:
1484                 return ANALOG_SIG_FGC_CAMA;
1485         case SIG_FGC_CAMAMF:
1486                 return ANALOG_SIG_FGC_CAMAMF;
1487         case SIG_FEATB:
1488                 return ANALOG_SIG_FEATB;
1489         case SIG_SFWINK:
1490                 return ANALOG_SIG_SFWINK;
1491         case SIG_SF:
1492                 return ANALOG_SIG_SF;
1493         case SIG_SF_FEATD:
1494                 return ANALOG_SIG_SF_FEATD;
1495         case SIG_SF_FEATDMF:
1496                 return ANALOG_SIG_SF_FEATDMF;
1497         case SIG_FEATDMF_TA:
1498                 return ANALOG_SIG_FEATDMF_TA;
1499         case SIG_SF_FEATB:
1500                 return ANALOG_SIG_FEATB;
1501         default:
1502                 return -1;
1503         }
1504 }
1505
1506
1507 static int analog_tone_to_dahditone(enum analog_tone tone)
1508 {
1509         switch (tone) {
1510         case ANALOG_TONE_RINGTONE:
1511                 return DAHDI_TONE_RINGTONE;
1512         case ANALOG_TONE_STUTTER:
1513                 return DAHDI_TONE_STUTTER;
1514         case ANALOG_TONE_CONGESTION:
1515                 return DAHDI_TONE_CONGESTION;
1516         case ANALOG_TONE_DIALTONE:
1517                 return DAHDI_TONE_DIALTONE;
1518         case ANALOG_TONE_DIALRECALL:
1519                 return DAHDI_TONE_DIALRECALL;
1520         case ANALOG_TONE_INFO:
1521                 return DAHDI_TONE_INFO;
1522         default:
1523                 return -1;
1524         }
1525 }
1526
1527 static int analogsub_to_dahdisub(enum analog_sub analogsub)
1528 {
1529         int index;
1530
1531         switch (analogsub) {
1532         case ANALOG_SUB_REAL:
1533                 index = SUB_REAL;
1534                 break;
1535         case ANALOG_SUB_CALLWAIT:
1536                 index = SUB_CALLWAIT;
1537                 break;
1538         case ANALOG_SUB_THREEWAY:
1539                 index = SUB_THREEWAY;
1540                 break;
1541         default:
1542                 ast_log(LOG_ERROR, "Unidentified sub!\n");
1543                 index = SUB_REAL;
1544         }
1545
1546         return index;
1547 }
1548
1549 static enum analog_event dahdievent_to_analogevent(int event);
1550 static int bump_gains(struct dahdi_pvt *p);
1551 static int dahdi_setlinear(int dfd, int linear);
1552
1553 static int my_start_cid_detect(void *pvt, int cid_signalling)
1554 {
1555         struct dahdi_pvt *p = pvt;
1556         int index = SUB_REAL;
1557         p->cs = callerid_new(cid_signalling);
1558         if (!p->cs) {
1559                 ast_log(LOG_ERROR, "Unable to alloc callerid\n");
1560                 return -1;
1561         }
1562         bump_gains(p);
1563         dahdi_setlinear(p->subs[index].dfd, 0);
1564
1565         return 0;
1566 }
1567
1568 static int my_stop_cid_detect(void *pvt)
1569 {
1570         struct dahdi_pvt *p = pvt;
1571         int index = SUB_REAL;
1572         if (p->cs)
1573                 callerid_free(p->cs);
1574         dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
1575         return 0;
1576 }
1577
1578 static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
1579 {
1580         struct dahdi_pvt *p = pvt;
1581         struct analog_pvt *analog_p = p->sig_pvt;
1582         struct pollfd poller;
1583         char *name, *num;
1584         int index = SUB_REAL;
1585         int res;
1586         unsigned char buf[256];
1587         int flags;
1588
1589         poller.fd = p->subs[SUB_REAL].dfd;
1590         poller.events = POLLPRI | POLLIN;
1591         poller.revents = 0;
1592
1593         res = poll(&poller, 1, timeout);
1594
1595         if (poller.revents & POLLPRI) {
1596                 *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd));
1597                 return 1;
1598         }
1599
1600         if (poller.revents & POLLIN) {
1601                 /*** NOTES ***/
1602                 /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function
1603                  * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until
1604                  * either a timeout occurs or CID is detected (returns 0). returning 1 should be event received, and -1 should be
1605                  * a failure and die, and returning 2 means no event was received. */
1606                 res = read(p->subs[index].dfd, buf, sizeof(buf));
1607                 if (res < 0) {
1608                         if (errno != ELAST) {
1609                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1610                                 callerid_free(p->cs);
1611                                 return -1;
1612                         }
1613                 }
1614
1615                 if (analog_p->ringt) {
1616                         analog_p->ringt--;
1617                 }
1618                 if (analog_p->ringt == 1) {
1619                         return -1;
1620                 }
1621
1622                 if (p->cid_signalling == CID_SIG_V23_JP) {
1623                         res = callerid_feed_jp(p->cs, buf, res, AST_LAW(p));
1624                 } else {
1625                         res = callerid_feed(p->cs, buf, res, AST_LAW(p));
1626                 }
1627
1628                 if (res < 0) {
1629                         ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno));
1630                         return -1;
1631                 }
1632
1633                 if (res == 1) {
1634                         callerid_get(p->cs, &name, &num, &flags);
1635                         if (name)
1636                                 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
1637                         if (num)
1638                                 ast_copy_string(numbuf, num, ANALOG_MAX_CID);
1639
1640                         ast_log(LOG_DEBUG, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
1641                         return 0;
1642                 }
1643         }
1644
1645         *ev = ANALOG_EVENT_NONE;
1646         return 2;
1647 }
1648
1649 static const char *event2str(int event);
1650 static int restore_gains(struct dahdi_pvt *p);
1651
1652 static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
1653 {
1654         unsigned char buf[256];
1655         int distMatches;
1656         int curRingData[3];
1657         int receivedRingT;
1658         int counter1;
1659         int counter;
1660         int i;
1661         int res;
1662         int checkaftercid = 0;
1663
1664         struct dahdi_pvt *p = pvt;
1665         struct analog_pvt *analog_p = p->sig_pvt;
1666
1667         if (ringdata == NULL) {
1668                 ringdata = curRingData;
1669         } else {
1670                 checkaftercid = 1;
1671         }
1672
1673         /* We must have a ring by now, so, if configured, lets try to listen for
1674          * distinctive ringing */
1675         if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
1676                 /* Clear the current ring data array so we dont have old data in it. */
1677                 for (receivedRingT = 0; receivedRingT < ARRAY_LEN(ringdata); receivedRingT++)
1678                         ringdata[receivedRingT] = 0;
1679                 receivedRingT = 0;
1680                 if (checkaftercid && distinctiveringaftercid)
1681                         ast_verb(3, "Detecting post-CID distinctive ring\n");
1682                 /* Check to see if context is what it should be, if not set to be. */
1683                 else if (strcmp(p->context,p->defcontext) != 0) {
1684                         ast_copy_string(p->context, p->defcontext, sizeof(p->context));
1685                         ast_copy_string(chan->context,p->defcontext,sizeof(chan->context));
1686                 }
1687
1688                 for (;;) {
1689                         i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1690                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
1691                                 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
1692                                 ast_hangup(chan);
1693                                 return 1;
1694                         }
1695                         if (i & DAHDI_IOMUX_SIGEVENT) {
1696                                 res = dahdi_get_event(p->subs[idx].dfd);
1697                                 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
1698                                 res = 0;
1699                                 /* Let us detect distinctive ring */
1700
1701                                 ringdata[receivedRingT] = analog_p->ringt;
1702
1703                                 if (analog_p->ringt < analog_p->ringt_base/2)
1704                                         break;
1705                                 /* Increment the ringT counter so we can match it against
1706                                    values in chan_dahdi.conf for distinctive ring */
1707                                 if (++receivedRingT == ARRAY_LEN(ringdata))
1708                                         break;
1709                         } else if (i & DAHDI_IOMUX_READ) {
1710                                 res = read(p->subs[idx].dfd, buf, sizeof(buf));
1711                                 if (res < 0) {
1712                                         if (errno != ELAST) {
1713                                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1714                                                 ast_hangup(chan);
1715                                                 return 1;
1716                                         }
1717                                         break;
1718                                 }
1719                                 if (analog_p->ringt)
1720                                         analog_p->ringt--;
1721                                 if (analog_p->ringt == 1) {
1722                                         res = -1;
1723                                         break;
1724                                 }
1725                         }
1726                 }
1727         }
1728         if ((checkaftercid && usedistinctiveringdetection) || !checkaftercid) {
1729                 /* this only shows up if you have n of the dring patterns filled in */
1730                 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",ringdata[0],ringdata[1],ringdata[2]);
1731                 for (counter = 0; counter < 3; counter++) {
1732                 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
1733                         distMatches = 0;
1734                         /* this only shows up if you have n of the dring patterns filled in */
1735                         ast_verb(3, "Checking %d,%d,%d\n",
1736                                         p->drings.ringnum[counter].ring[0],
1737                                         p->drings.ringnum[counter].ring[1],
1738                                         p->drings.ringnum[counter].ring[2]);
1739                         for (counter1 = 0; counter1 < 3; counter1++) {
1740                                 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
1741                                 if (p->drings.ringnum[counter].ring[counter1] == -1) {
1742                                         ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1743                                         ringdata[counter1]);
1744                                         distMatches++;
1745                                 } else if (ringdata[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
1746                                                                                 ringdata[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
1747                                         ast_verb(3, "Ring pattern matched in range: %d to %d\n",
1748                                         (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
1749                                         (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
1750                                         distMatches++;
1751                                 }
1752                         }
1753
1754                         if (distMatches == 3) {
1755                                 /* The ring matches, set the context to whatever is for distinctive ring.. */
1756                                 ast_copy_string(p->context, p->drings.ringContext[counter].contextData, sizeof(p->context));
1757                                 ast_copy_string(chan->context, p->drings.ringContext[counter].contextData, sizeof(chan->context));
1758                                 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
1759                                 break;
1760                         }
1761                 }
1762         }
1763         /* Restore linear mode (if appropriate) for Caller*ID processing */
1764         dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
1765         restore_gains(p);
1766
1767         return 0;
1768 }
1769
1770 static int send_callerid(struct dahdi_pvt *p);
1771
1772 static int my_stop_callwait(void *pvt)
1773 {
1774         struct dahdi_pvt *p = pvt;
1775         p->callwaitingrepeat = 0;
1776         p->cidcwexpire = 0;
1777
1778         return 0;
1779 }
1780
1781 static int save_conference(struct dahdi_pvt *p);
1782
1783 static int my_callwait(void *pvt)
1784 {
1785         struct dahdi_pvt *p = pvt;
1786         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1787         if (p->cidspill) {
1788                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1789                 free(p->cidspill);
1790         }
1791         if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1792                 return -1;
1793         save_conference(p);
1794         /* Silence */
1795         memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1796         if (!p->callwaitrings && p->callwaitingcallerid) {
1797                 ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
1798                 p->callwaitcas = 1;
1799                 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1800         } else {
1801                 ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
1802                 p->callwaitcas = 0;
1803                 p->cidlen = 2400 + READ_SIZE * 4;
1804         }
1805         p->cidpos = 0;
1806         send_callerid(p);
1807
1808         return 0;
1809 }
1810
1811 static int my_send_callerid(void *pvt, int cwcid, struct ast_callerid *cid)
1812 {
1813         struct dahdi_pvt *p = pvt;
1814
1815         ast_debug(2, "Starting cid spill\n");
1816
1817         if (p->cidspill) {
1818                 ast_log(LOG_WARNING, "cidspill already exists??\n");
1819                 free(p->cidspill);
1820         }
1821
1822         if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1823                 if (cwcid == 0) {
1824                         p->cidlen = ast_callerid_generate(p->cidspill, cid->cid_name, cid->cid_num, AST_LAW(p));
1825                 } else {
1826                         p->callwaitcas = 0;
1827                         p->cidcwexpire = 0;
1828                         p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, cid->cid_name, cid->cid_num, AST_LAW(p));
1829                         p->cidlen += READ_SIZE * 4;
1830                 }
1831                 p->cidpos = 0;
1832                 send_callerid(p);
1833         }
1834         return 0;
1835 }
1836
1837 static int my_dsp_reset_and_flush_digits(void *pvt)
1838 {
1839         struct dahdi_pvt *p = pvt;
1840         if (p->dsp)
1841                 ast_dsp_digitreset(p->dsp);
1842
1843         return 0;
1844 }
1845
1846 static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
1847 {
1848         struct dahdi_pvt *p = pvt;
1849
1850         if (p->channel == CHAN_PSEUDO)
1851                 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");
1852
1853         if (mode == ANALOG_DIGITMODE_DTMF) {
1854                 /* If we do hardware dtmf, no need for a DSP */
1855                 if (p->hardwaredtmf) {
1856                         if (p->dsp) {
1857                                 ast_dsp_free(p->dsp);
1858                                 p->dsp = NULL;
1859                         }
1860                         return 0;
1861                 }
1862
1863                 if (!p->dsp) {
1864                         p->dsp = ast_dsp_new();
1865                         if (!p->dsp) {
1866                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1867                                 return -1;
1868                         }
1869                 }
1870
1871                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
1872         } else if (mode == ANALOG_DIGITMODE_MF) {
1873                 if (!p->dsp) {
1874                         p->dsp = ast_dsp_new();
1875                         if (!p->dsp) {
1876                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1877                                 return -1;
1878                         }
1879                 }
1880                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
1881         }
1882         return 0;
1883 }
1884
1885 static int dahdi_wink(struct dahdi_pvt *p, int index);
1886
1887 static int my_wink(void *pvt, enum analog_sub sub)
1888 {
1889         struct dahdi_pvt *p = pvt;
1890         int index = analogsub_to_dahdisub(sub);
1891         if (index != SUB_REAL) {
1892                 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
1893         }
1894         return dahdi_wink(p, index);
1895 }
1896
1897 static void wakeup_sub(struct dahdi_pvt *p, int a);
1898
1899 static int reset_conf(struct dahdi_pvt *p);
1900
1901 static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);
1902
1903 static void my_handle_dtmfup(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
1904 {
1905         struct ast_frame *f = *dest;
1906         struct dahdi_pvt *p = pvt;
1907         int idx = analogsub_to_dahdisub(analog_index);
1908
1909         ast_debug(1, "DTMF digit: %c on %s\n", f->subclass, ast->name);
1910
1911         if (f->subclass == 'f') {
1912                 /* Fax tone -- Handle and return NULL */
1913                 if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
1914                         /* If faxbuffers are configured, use them for the fax transmission */
1915                         if (p->usefaxbuffers && !p->bufferoverrideinuse) {
1916                                 struct dahdi_bufferinfo bi = {
1917                                         .txbufpolicy = p->faxbuf_policy,
1918                                         .bufsize = p->bufsize,
1919                                         .numbufs = p->faxbuf_no
1920                                 };
1921                                 int res;
1922
1923                                 if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
1924                                         ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast->name, strerror(errno));
1925                                 } else {
1926                                         p->bufferoverrideinuse = 1;
1927                                 }
1928                         }
1929                         p->faxhandled = 1;
1930                         if (strcmp(ast->exten, "fax")) {
1931                                 const char *target_context = S_OR(ast->macrocontext, ast->context);
1932
1933                                 /* We need to unlock 'ast' here because ast_exists_extension has the
1934                                  * potential to start autoservice on the channel. Such action is prone
1935                                  * to deadlock.
1936                                  */
1937                                 ast_mutex_unlock(&p->lock);
1938                                 ast_channel_unlock(ast);
1939                                 if (ast_exists_extension(ast, target_context, "fax", 1, ast->cid.cid_num)) {
1940                                         ast_channel_lock(ast);
1941                                         ast_mutex_lock(&p->lock);
1942                                         ast_verb(3, "Redirecting %s to fax extension\n", ast->name);
1943                                         /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
1944                                         pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast->exten);
1945                                         if (ast_async_goto(ast, target_context, "fax", 1))
1946                                                 ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast->name, target_context);
1947                                 } else {
1948                                         ast_channel_lock(ast);
1949                                         ast_mutex_lock(&p->lock);
1950                                         ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
1951                                 }
1952                         } else {
1953                                 ast_debug(1, "Already in a fax extension, not redirecting\n");
1954                         }
1955                 } else {
1956                         ast_debug(1, "Fax already handled\n");
1957                 }
1958                 dahdi_confmute(p, 0);
1959                 p->subs[idx].f.frametype = AST_FRAME_NULL;
1960                 p->subs[idx].f.subclass = 0;
1961                 *dest = &p->subs[idx].f;
1962         }
1963 }
1964
1965 static void my_lock_private(void *pvt)
1966 {
1967         struct dahdi_pvt *p = pvt;
1968         ast_mutex_lock(&p->lock);
1969 }
1970
1971 static void my_unlock_private(void *pvt)
1972 {
1973         struct dahdi_pvt *p = pvt;
1974         ast_mutex_unlock(&p->lock);
1975 }
1976
1977 static int my_set_linear_mode(void *pvt, int idx, int linear_mode)
1978 {
1979         struct dahdi_pvt *p = pvt;
1980         if (!linear_mode)
1981                 linear_mode = p->subs[idx].linear;
1982         return dahdi_setlinear(p->subs[idx].dfd, linear_mode);
1983 }
1984
1985 static int get_alarms(struct dahdi_pvt *p);
1986 static void handle_alarms(struct dahdi_pvt *p, int alms);
1987 static void my_get_and_handle_alarms(void *pvt)
1988 {
1989         int res;
1990         struct dahdi_pvt *p = pvt;
1991
1992         res = get_alarms(p);
1993         handle_alarms(p, res);
1994 }
1995
1996 static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
1997 {
1998         struct dahdi_pvt *p = ast_bridged_channel(chan)->tech_pvt;
1999         if (p)
2000                 return p->sig_pvt;
2001         else
2002                 return NULL;
2003 }
2004
2005 static int my_get_sub_fd(void *pvt, enum analog_sub sub)
2006 {
2007         struct dahdi_pvt *p = pvt;
2008         int dahdi_sub = analogsub_to_dahdisub(sub);
2009         return p->subs[dahdi_sub].dfd;
2010 }
2011
2012 static void my_set_cadence(void *pvt, int *cidrings, struct ast_channel *ast)
2013 {
2014         struct dahdi_pvt *p = pvt;
2015
2016         /* Choose proper cadence */
2017         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
2018                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
2019                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast->name, strerror(errno));
2020                 *cidrings = cidrings[p->distinctivering - 1];
2021         } else {
2022                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
2023                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast->name, strerror(errno));
2024                 *cidrings = p->sendcalleridafter;
2025         }
2026 }
2027
2028 static void my_set_dialing(void *pvt, int flag)
2029 {
2030         struct dahdi_pvt *p = pvt;
2031         p->dialing = flag;
2032 }
2033
2034 static void my_increase_ss_count(void)
2035 {
2036         ast_mutex_lock(&ss_thread_lock);
2037         ss_thread_count++;
2038         ast_mutex_unlock(&ss_thread_lock);
2039 }
2040
2041 static void my_decrease_ss_count(void)
2042 {
2043         ast_mutex_lock(&ss_thread_lock);
2044         ss_thread_count--;
2045         ast_cond_signal(&ss_thread_complete);
2046         ast_mutex_unlock(&ss_thread_lock);
2047 }
2048
2049 static void my_all_subchannels_hungup(void *pvt)
2050 {
2051         struct dahdi_pvt *p = pvt;
2052         int res, law;
2053
2054         p->faxhandled = 0;
2055         p->didtdd = 0;
2056
2057         if (p->dsp) {
2058                 ast_dsp_free(p->dsp);
2059                 p->dsp = NULL;
2060         }
2061
2062         law = DAHDI_LAW_DEFAULT;
2063         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
2064         if (res < 0)
2065                 ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
2066
2067         dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
2068
2069 #if 1
2070         {
2071         int i;
2072         p->owner = NULL;
2073         /* Cleanup owners here */
2074         for (i = 0; i < 3; i++) {
2075                 p->subs[i].owner = NULL;
2076         }
2077         }
2078 #endif
2079
2080         reset_conf(p);
2081         if (num_restart_pending == 0) {
2082                 restart_monitor();
2083         }
2084 }
2085
2086 static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);
2087
2088 static int my_conf_del(void *pvt, enum analog_sub sub)
2089 {
2090         struct dahdi_pvt *p = pvt;
2091         int x = analogsub_to_dahdisub(sub);
2092
2093         return conf_del(p, &p->subs[x], x);
2094 }
2095
2096 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);
2097
2098 static int my_conf_add(void *pvt, enum analog_sub sub)
2099 {
2100         struct dahdi_pvt *p = pvt;
2101         int x = analogsub_to_dahdisub(sub);
2102
2103         return conf_add(p, &p->subs[x], x, 0);
2104 }
2105
2106 static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);
2107
2108 static int my_complete_conference_update(void *pvt, int needconference)
2109 {
2110         struct dahdi_pvt *p = pvt;
2111         int needconf = needconference;
2112         int x;
2113         int useslavenative;
2114         struct dahdi_pvt *slave = NULL;
2115
2116         useslavenative = isslavenative(p, &slave);
2117
2118         /* If we have a slave, add him to our conference now. or DAX
2119            if this is slave native */
2120         for (x = 0; x < MAX_SLAVES; x++) {
2121                 if (p->slaves[x]) {
2122                         if (useslavenative)
2123                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
2124                         else {
2125                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
2126                                 needconf++;
2127                         }
2128                 }
2129         }
2130         /* If we're supposed to be in there, do so now */
2131         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
2132                 if (useslavenative)
2133                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
2134                 else {
2135                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
2136                         needconf++;
2137                 }
2138         }
2139         /* If we have a master, add ourselves to his conference */
2140         if (p->master) {
2141                 if (isslavenative(p->master, NULL)) {
2142                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
2143                 } else {
2144                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
2145                 }
2146         }
2147         if (!needconf) {
2148                 /* Nobody is left (or should be left) in our conference.
2149                    Kill it. */
2150                 p->confno = -1;
2151         }
2152
2153         return 0;
2154 }
2155
2156 static int check_for_conference(struct dahdi_pvt *p);
2157
2158 static int my_check_for_conference(void *pvt)
2159 {
2160         struct dahdi_pvt *p = pvt;
2161         return check_for_conference(p);
2162 }
2163
2164 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)
2165 {
2166         struct dahdi_pvt *p = pvt;
2167         int da, db;
2168         int tchan;
2169
2170         da = analogsub_to_dahdisub(a);
2171         db = analogsub_to_dahdisub(b);
2172
2173         tchan = p->subs[da].chan;
2174
2175         p->subs[da].chan = p->subs[db].chan;
2176
2177         p->subs[db].chan = tchan;
2178
2179         if (ast_a)
2180                 ast_a->fds[0] = p->subs[da].dfd;
2181         if (ast_b)
2182                 ast_b->fds[0] = p->subs[db].dfd;
2183
2184         p->subs[da].owner = ast_a;
2185         p->subs[db].owner = ast_b;
2186
2187         wakeup_sub(p, a);
2188         wakeup_sub(p, b);
2189
2190         return;
2191 }
2192
2193 static struct ast_channel *dahdi_new(struct dahdi_pvt *, int, int, int, int, int, const char *);
2194
2195 static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
2196 {
2197         struct dahdi_pvt *p = pvt;
2198         int dsub = analogsub_to_dahdisub(sub);
2199
2200         return dahdi_new(p, state, startpbx, dsub, 0, 0, requestor ? requestor->linkedid : "");
2201 }
2202
2203 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2204 static int dahdi_setlaw(int dfd, int law)
2205 {
2206         int res;
2207         res = ioctl(dfd, DAHDI_SETLAW, &law);
2208         if (res)
2209                 return res;
2210         return 0;
2211 }
2212 #endif
2213
2214 #if defined(HAVE_PRI)
2215 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)
2216 {
2217         struct dahdi_pvt *p = pvt;
2218         int audio;
2219         int newlaw = -1;
2220
2221         /* Set to audio mode at this point */
2222         audio = 1;
2223         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1)
2224                 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n", p->channel, audio, strerror(errno));
2225
2226         if (law != SIG_PRI_DEFLAW) {
2227                 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
2228         }
2229
2230         ast_copy_string(p->exten, exten, sizeof(p->exten));
2231
2232         switch (law) {
2233                 case SIG_PRI_DEFLAW:
2234                         newlaw = 0;
2235                         break;
2236                 case SIG_PRI_ALAW:
2237                         newlaw = DAHDI_LAW_ALAW;
2238                         break;
2239                 case SIG_PRI_ULAW:
2240                         newlaw = DAHDI_LAW_MULAW;
2241                         break;
2242         }
2243         return dahdi_new(p, state, startpbx, SUB_REAL, newlaw, transfercapability, requestor ? requestor->linkedid : "");
2244 }
2245 #endif  /* defined(HAVE_PRI) */
2246
2247 static int unalloc_sub(struct dahdi_pvt *p, int x);
2248
2249 static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
2250 {
2251         struct dahdi_pvt *p = pvt;
2252
2253         return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
2254 }
2255
2256 static int alloc_sub(struct dahdi_pvt *p, int x);
2257
2258 static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
2259 {
2260         struct dahdi_pvt *p = pvt;
2261
2262         return alloc_sub(p, analogsub_to_dahdisub(analogsub));
2263 }
2264
2265 static int has_voicemail(struct dahdi_pvt *p);
2266
2267 static int my_has_voicemail(void *pvt)
2268 {
2269         struct dahdi_pvt *p = pvt;
2270
2271         return has_voicemail(p);
2272 }
2273
2274 static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
2275 {
2276         struct dahdi_pvt *p = pvt;
2277         int index;
2278
2279         index = analogsub_to_dahdisub(sub);
2280
2281         return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
2282 }
2283
2284 static enum analog_event dahdievent_to_analogevent(int event)
2285 {
2286         enum analog_event res = ANALOG_EVENT_ERROR;
2287
2288         switch (event) {
2289         case DAHDI_EVENT_DIALCOMPLETE:
2290                 res = ANALOG_EVENT_DIALCOMPLETE;
2291                 break;
2292         case DAHDI_EVENT_WINKFLASH:
2293                 res = ANALOG_EVENT_WINKFLASH;
2294                 break;
2295         case DAHDI_EVENT_ONHOOK:
2296                 res = ANALOG_EVENT_ONHOOK;
2297                 break;
2298         case DAHDI_EVENT_RINGOFFHOOK:
2299                 res = ANALOG_EVENT_RINGOFFHOOK;
2300                 break;
2301         case DAHDI_EVENT_ALARM:
2302                 res = ANALOG_EVENT_ALARM;
2303                 break;
2304         case DAHDI_EVENT_NOALARM:
2305                 res = ANALOG_EVENT_NOALARM;
2306                 break;
2307         case DAHDI_EVENT_HOOKCOMPLETE:
2308                 res = ANALOG_EVENT_HOOKCOMPLETE;
2309                 break;
2310         case DAHDI_EVENT_POLARITY:
2311                 res = ANALOG_EVENT_POLARITY;
2312                 break;
2313         case DAHDI_EVENT_RINGERON:
2314                 res = ANALOG_EVENT_RINGERON;
2315                 break;
2316         case DAHDI_EVENT_RINGEROFF:
2317                 res = ANALOG_EVENT_RINGEROFF;
2318                 break;
2319         case DAHDI_EVENT_RINGBEGIN:
2320                 res = ANALOG_EVENT_RINGBEGIN;
2321                 break;
2322         case DAHDI_EVENT_PULSE_START:
2323                 res = ANALOG_EVENT_PULSE_START;
2324         break;
2325         case DAHDI_EVENT_NEONMWI_ACTIVE:
2326                 res = ANALOG_EVENT_NEONMWI_ACTIVE;
2327                 break;
2328         case DAHDI_EVENT_NEONMWI_INACTIVE:
2329                 res = ANALOG_EVENT_NEONMWI_INACTIVE;
2330                 break;
2331         }
2332
2333         return res;
2334 }
2335
2336 static inline int dahdi_wait_event(int fd);
2337
2338 static int my_wait_event(void *pvt)
2339 {
2340         struct dahdi_pvt *p = pvt;
2341
2342         return dahdi_wait_event(p->subs[SUB_REAL].dfd);
2343 }
2344
2345 static int my_get_event(void *pvt)
2346 {
2347         struct dahdi_pvt *p = pvt;
2348         int res;
2349
2350         if (p->fake_event) {
2351                 res = p->fake_event;
2352                 p->fake_event = 0;
2353         } else
2354                 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
2355
2356         return dahdievent_to_analogevent(res);
2357 }
2358
2359 static int my_is_off_hook(void *pvt)
2360 {
2361         struct dahdi_pvt *p = pvt;
2362         int res;
2363         struct dahdi_params par;
2364
2365         if (p->subs[SUB_REAL].dfd > -1)
2366                 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
2367         else {
2368                 /* Assume not off hook on CVRS */
2369                 res = 0;
2370                 par.rxisoffhook = 0;
2371         }
2372         if (res) {
2373                 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
2374         }
2375
2376         if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
2377                 /* When "onhook" that means no battery on the line, and thus
2378                 it is out of service..., if it's on a TDM card... If it's a channel
2379                 bank, there is no telling... */
2380                 return (par.rxbits > -1) || par.rxisoffhook;
2381         }
2382
2383         return par.rxisoffhook;
2384 }
2385
2386 static void dahdi_enable_ec(struct dahdi_pvt *p);
2387 static void dahdi_disable_ec(struct dahdi_pvt *p);
2388
2389 static int my_set_echocanceller(void *pvt, int enable)
2390 {
2391         struct dahdi_pvt *p = pvt;
2392
2393         if (enable)
2394                 dahdi_enable_ec(p);
2395         else
2396                 dahdi_disable_ec(p);
2397
2398         return 0;
2399 }
2400
2401 static int dahdi_ring_phone(struct dahdi_pvt *p);
2402
2403 static int my_ring(void *pvt)
2404 {
2405         struct dahdi_pvt *p = pvt;
2406
2407         return dahdi_ring_phone(p);
2408 }
2409
2410 static int my_flash(void *pvt)
2411 {
2412         struct dahdi_pvt *p = pvt;
2413         int func = DAHDI_FLASH;
2414         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
2415 }
2416
2417 static inline int dahdi_set_hook(int fd, int hs);
2418
2419 static int my_off_hook(void *pvt)
2420 {
2421         struct dahdi_pvt *p = pvt;
2422         return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
2423 }
2424
2425 static int my_start(void *pvt)
2426 {
2427         struct dahdi_pvt *p = pvt;
2428         int x = DAHDI_START;
2429
2430         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
2431 }
2432
2433 static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
2434 {
2435         int index = analogsub_to_dahdisub(sub);
2436         int res;
2437         struct dahdi_pvt *p = pvt;
2438         struct dahdi_dialoperation ddop;
2439
2440         if (dop->op != ANALOG_DIAL_OP_REPLACE) {
2441                 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
2442                 return -1;
2443         }
2444
2445         if (sub != ANALOG_SUB_REAL)
2446                 printf("Trying to dial digits on sub %d\n", sub);
2447
2448         ddop.op = DAHDI_DIAL_OP_REPLACE;
2449         strncpy(ddop.dialstr, dop->dialstr, sizeof(ddop.dialstr));
2450
2451         printf("Dialing %s on %d\n", ddop.dialstr, p->channel);
2452
2453         res = ioctl(p->subs[index].dfd, DAHDI_DIAL, &ddop);
2454
2455         if (res == -1)
2456                 ast_log(LOG_DEBUG, "DAHDI_DIAL ioctl failed on %s: %s\n", p->owner->name, strerror(errno));
2457
2458         return res;
2459 }
2460
2461 static void dahdi_train_ec(struct dahdi_pvt *p);
2462
2463 static int my_train_echocanceller(void *pvt)
2464 {
2465         struct dahdi_pvt *p = pvt;
2466
2467         dahdi_train_ec(p);
2468
2469         return 0;
2470 }
2471
2472 static int my_is_dialing(void *pvt, enum analog_sub sub)
2473 {
2474         struct dahdi_pvt *p = pvt;
2475         int index;
2476         int x;
2477
2478         index = analogsub_to_dahdisub(sub);
2479
2480         if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
2481                 ast_log(LOG_DEBUG, "DAHDI_DIALING ioctl failed!\n");
2482                 return -1;
2483         }
2484
2485         return x;
2486 }
2487
2488 static int my_on_hook(void *pvt)
2489 {
2490         struct dahdi_pvt *p = pvt;
2491         return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
2492 }
2493
2494 #if defined(HAVE_PRI)
2495 static void my_pri_fixup_chans(void *old_chan, void *new_chan)
2496 {
2497         struct dahdi_pvt *old = old_chan;
2498         struct dahdi_pvt *new = new_chan;
2499         struct sig_pri_chan *pchan = new->sig_pvt;
2500         struct sig_pri_pri *pri = pchan->pri;
2501
2502         new->owner = old->owner;
2503         old->owner = NULL;
2504         if (new->owner) {
2505                 char newname[AST_CHANNEL_NAME];
2506                 snprintf(newname, sizeof(newname), "DAHDI/%d:%d-%d", pri->trunkgroup, new->channel, 1);
2507                 ast_change_name(new->owner, newname);
2508
2509                 new->owner->tech_pvt = new;
2510                 new->owner->fds[0] = new->subs[SUB_REAL].dfd;
2511                 new->subs[SUB_REAL].owner = old->subs[SUB_REAL].owner;
2512                 old->subs[SUB_REAL].owner = NULL;
2513         }
2514         /* Copy any DSP that may be present */
2515         new->dsp = old->dsp;
2516         new->dsp_features = old->dsp_features;
2517         old->dsp = NULL;
2518         old->dsp_features = 0;
2519 }
2520
2521 static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
2522 {
2523         switch (tone) {
2524         case SIG_PRI_TONE_RINGTONE:
2525                 return DAHDI_TONE_RINGTONE;
2526         case SIG_PRI_TONE_STUTTER:
2527                 return DAHDI_TONE_STUTTER;
2528         case SIG_PRI_TONE_CONGESTION:
2529                 return DAHDI_TONE_CONGESTION;
2530         case SIG_PRI_TONE_DIALTONE:
2531                 return DAHDI_TONE_DIALTONE;
2532         case SIG_PRI_TONE_DIALRECALL:
2533                 return DAHDI_TONE_DIALRECALL;
2534         case SIG_PRI_TONE_INFO:
2535                 return DAHDI_TONE_INFO;
2536         case SIG_PRI_TONE_BUSY:
2537                 return DAHDI_TONE_BUSY;
2538         default:
2539                 return -1;
2540         }
2541 }
2542
2543 static void my_handle_dchan_exception(struct sig_pri_pri *pri, int index)
2544 {
2545         int x, res;
2546
2547         res = ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
2548         if (x) {
2549                 ast_log(LOG_NOTICE, "PRI got event: %s (%d) on D-channel of span %d\n", event2str(x), x, pri->span);
2550         }
2551         /* Keep track of alarm state */
2552         if (x == DAHDI_EVENT_ALARM) {
2553                 pri_event_alarm(pri, index, 0);
2554         } else if (x == DAHDI_EVENT_NOALARM) {
2555                 pri_event_noalarm(pri, index, 0);
2556         }
2557 }
2558
2559 static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
2560 {
2561         struct dahdi_pvt *p = pvt;
2562
2563         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
2564 }
2565
2566 /*!
2567  * \internal
2568  * \brief Set the caller id information.
2569  * \since 1.6.3
2570  *
2571  * \param pvt DAHDI private structure
2572  * \param caller Caller-id information to set.
2573  *
2574  * \return Nothing
2575  */
2576 static void my_pri_set_callerid(void *pvt, const struct ast_party_caller *caller)
2577 {
2578         struct dahdi_pvt *p = pvt;
2579
2580         ast_copy_string(p->cid_num, S_OR(caller->id.number, ""), sizeof(p->cid_num));
2581         ast_copy_string(p->cid_name, S_OR(caller->id.name, ""), sizeof(p->cid_name));
2582         p->cid_ton = caller->id.number_type;
2583         p->callingpres = caller->id.number_presentation;
2584         ast_copy_string(p->cid_ani, S_OR(caller->ani, ""), sizeof(p->cid_ani));
2585         p->cid_ani2 = caller->ani2;
2586 }
2587
2588 /*!
2589  * \internal
2590  * \brief Set the Dialed Number Identifier.
2591  * \since 1.6.3
2592  *
2593  * \param pvt DAHDI private structure
2594  * \param dnid Dialed Number Identifier string.
2595  *
2596  * \return Nothing
2597  */
2598 static void my_pri_set_dnid(void *pvt, const char *dnid)
2599 {
2600         struct dahdi_pvt *p = pvt;
2601
2602         ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
2603 }
2604
2605 /*!
2606  * \internal
2607  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
2608  * \since 1.6.3
2609  *
2610  * \param pvt DAHDI private structure
2611  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
2612  *
2613  * \return Nothing
2614  */
2615 static void my_pri_set_rdnis(void *pvt, const char *rdnis)
2616 {
2617         struct dahdi_pvt *p = pvt;
2618
2619         ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
2620 }
2621
2622 static struct sig_pri_callback dahdi_pri_callbacks =
2623 {
2624         .handle_dchan_exception = my_handle_dchan_exception,
2625         .play_tone = my_pri_play_tone,
2626         .set_echocanceller = my_set_echocanceller,
2627         .lock_private = my_lock_private,
2628         .unlock_private = my_unlock_private,
2629         .new_ast_channel = my_new_pri_ast_channel,
2630         .fixup_chans = my_pri_fixup_chans,
2631         .set_dialing = my_set_dialing,
2632         .set_callerid = my_pri_set_callerid,
2633         .set_dnid = my_pri_set_dnid,
2634         .set_rdnis = my_pri_set_rdnis,
2635 };
2636 #endif  /* defined(HAVE_PRI) */
2637
2638 /*!
2639  * \brief Send MWI state change
2640  *
2641  * \arg mailbox_full This is the mailbox associated with the FXO line that the
2642  *      MWI state has changed on.
2643  * \arg thereornot This argument should simply be set to 1 or 0, to indicate
2644  *      whether there are messages waiting or not.
2645  *
2646  *  \return nothing
2647  *
2648  * This function does two things:
2649  *
2650  * 1) It generates an internal Asterisk event notifying any other module that
2651  *    cares about MWI that the state of a mailbox has changed.
2652  *
2653  * 2) It runs the script specified by the mwimonitornotify option to allow
2654  *    some custom handling of the state change.
2655  */
2656 static void notify_message(char *mailbox_full, int thereornot)
2657 {
2658         char s[sizeof(mwimonitornotify) + 80];
2659         struct ast_event *event;
2660         char *mailbox, *context;
2661
2662         /* Strip off @default */
2663         context = mailbox = ast_strdupa(mailbox_full);
2664         strsep(&context, "@");
2665         if (ast_strlen_zero(context))
2666                 context = "default";
2667
2668         if (!(event = ast_event_new(AST_EVENT_MWI,
2669                         AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox,
2670                         AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context,
2671                         AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot,
2672                         AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot,
2673                         AST_EVENT_IE_END))) {
2674                 return;
2675         }
2676
2677         ast_event_queue_and_cache(event);
2678
2679         if (!ast_strlen_zero(mailbox) && !ast_strlen_zero(mwimonitornotify)) {
2680                 snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot);
2681                 ast_safe_system(s);
2682         }
2683 }
2684
2685 static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
2686 {
2687         struct dahdi_pvt *p = pvt;
2688
2689         if (neon_mwievent > -1 && !p->mwimonitor_neon)
2690                 return;
2691
2692         if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) {
2693                 ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox);
2694                 notify_message(p->mailbox, 1);
2695         } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) {
2696                 ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox);
2697                 notify_message(p->mailbox, 0);
2698         }
2699         /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */
2700         /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */
2701         if (neon_mwievent == -1 && p->mwimonitor_rpas) {
2702                 ast_hangup(chan);
2703                 return;
2704         }
2705 }
2706
2707
2708
2709 static struct analog_callback dahdi_analog_callbacks =
2710 {
2711         .play_tone = my_play_tone,
2712         .get_event = my_get_event,
2713         .wait_event = my_wait_event,
2714         .is_off_hook = my_is_off_hook,
2715         .set_echocanceller = my_set_echocanceller,
2716         .ring = my_ring,
2717         .flash = my_flash,
2718         .off_hook = my_off_hook,
2719         .dial_digits = my_dial_digits,
2720         .train_echocanceller = my_train_echocanceller,
2721         .on_hook = my_on_hook,
2722         .is_dialing = my_is_dialing,
2723         .allocate_sub = my_allocate_sub,
2724         .unallocate_sub = my_unallocate_sub,
2725         .swap_subs = my_swap_subchannels,
2726         .has_voicemail = my_has_voicemail,
2727         .check_for_conference = my_check_for_conference,
2728         .conf_add = my_conf_add,
2729         .conf_del = my_conf_del,
2730         .complete_conference_update = my_complete_conference_update,
2731         .start = my_start,
2732         .all_subchannels_hungup = my_all_subchannels_hungup,
2733         .lock_private = my_lock_private,
2734         .unlock_private = my_unlock_private,
2735         .handle_dtmfup = my_handle_dtmfup,
2736         .wink = my_wink,
2737         .new_ast_channel = my_new_analog_ast_channel,
2738         .dsp_set_digitmode = my_dsp_set_digitmode,
2739         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
2740         .send_callerid = my_send_callerid,
2741         .callwait = my_callwait,
2742         .stop_callwait = my_stop_callwait,
2743         .get_callerid = my_get_callerid,
2744         .start_cid_detect = my_start_cid_detect,
2745         .stop_cid_detect = my_stop_cid_detect,
2746         .handle_notify_message = my_handle_notify_message,
2747         .increase_ss_count = my_increase_ss_count,
2748         .decrease_ss_count = my_decrease_ss_count,
2749         .distinctive_ring = my_distinctive_ring,
2750         .set_linear_mode = my_set_linear_mode,
2751         .get_and_handle_alarms = my_get_and_handle_alarms,
2752         .get_sigpvt_bridged_channel = my_get_sigpvt_bridged_channel,
2753         .get_sub_fd = my_get_sub_fd,
2754         .set_cadence = my_set_cadence,
2755         .set_dialing = my_set_dialing,
2756 };
2757
2758 static struct dahdi_pvt *round_robin[32];
2759
2760 #if defined(HAVE_SS7)
2761 static inline void ss7_rel(struct dahdi_ss7 *ss7)
2762 {
2763         ast_mutex_unlock(&ss7->lock);
2764 }
2765 #endif  /* defined(HAVE_SS7) */
2766
2767 #if defined(HAVE_SS7)
2768 static inline int ss7_grab(struct dahdi_pvt *pvt, struct dahdi_ss7 *pri)
2769 {
2770         int res;
2771         /* Grab the lock first */
2772         do {
2773                 res = ast_mutex_trylock(&pri->lock);
2774                 if (res) {
2775                         DEADLOCK_AVOIDANCE(&pvt->lock);
2776                 }
2777         } while (res);
2778         /* Then break the poll */
2779         if (pri->master != AST_PTHREADT_NULL)
2780                 pthread_kill(pri->master, SIGURG);
2781         return 0;
2782 }
2783 #endif  /* defined(HAVE_SS7) */
2784
2785 static int dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok)
2786 {
2787         int res;
2788         if (p->subs[SUB_REAL].owner == ast)
2789                 res = 0;
2790         else if (p->subs[SUB_CALLWAIT].owner == ast)
2791                 res = 1;
2792         else if (p->subs[SUB_THREEWAY].owner == ast)
2793                 res = 2;
2794         else {
2795                 res = -1;
2796                 if (!nullok)
2797                         ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n");
2798         }
2799         return res;
2800 }
2801
2802 static void wakeup_sub(struct dahdi_pvt *p, int a)
2803 {
2804         for (;;) {
2805                 if (p->subs[a].owner) {
2806                         if (ast_channel_trylock(p->subs[a].owner)) {
2807                                 DEADLOCK_AVOIDANCE(&p->lock);
2808                         } else {
2809                                 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
2810                                 ast_channel_unlock(p->subs[a].owner);
2811                                 break;
2812                         }
2813                 } else
2814                         break;
2815         }
2816 }
2817
2818 static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f, void *data)
2819 {
2820 #ifdef HAVE_SS7
2821         struct dahdi_ss7 *ss7 = (struct dahdi_ss7*) data;
2822
2823         if (data) {
2824                 switch (p->sig) {
2825                 case SIG_SS7:
2826                         ast_mutex_unlock(&ss7->lock);
2827                         break;
2828                 default:
2829                         break;
2830                 }
2831         }
2832 #endif
2833         for (;;) {
2834                 if (p->owner) {
2835                         if (ast_channel_trylock(p->owner)) {
2836                                 DEADLOCK_AVOIDANCE(&p->lock);
2837                         } else {
2838                                 ast_queue_frame(p->owner, f);
2839                                 ast_channel_unlock(p->owner);
2840                                 break;
2841                         }
2842                 } else
2843                         break;
2844         }
2845 #if defined(HAVE_SS7)
2846         if (data) {
2847                 switch (p->sig) {
2848                 case SIG_SS7:
2849                         ast_mutex_lock(&ss7->lock);
2850                         break;
2851                 default:
2852                         break;
2853                 }
2854         }
2855 #endif
2856 }
2857
2858 #ifdef HAVE_OPENR2
2859
2860 static int dahdi_r2_answer(struct dahdi_pvt *p)
2861 {
2862         int res = 0;
2863         /* openr2 1.1.0 and older does not even define OR2_LIB_INTERFACE
2864         * and does not has support for openr2_chan_answer_call_with_mode
2865         *  */
2866 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
2867         const char *double_answer = pbx_builtin_getvar_helper(p->owner, "MFCR2_DOUBLE_ANSWER");
2868         int wants_double_answer = ast_true(double_answer) ? 1 : 0;
2869         if (!double_answer) {
2870                 /* this still can result in double answer if the channel context
2871                 * was configured that way */
2872                 res = openr2_chan_answer_call(p->r2chan);
2873         } else if (wants_double_answer) {
2874                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
2875         } else {
2876                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
2877         }
2878 #else
2879         res = openr2_chan_answer_call(p->r2chan);
2880 #endif
2881         return res;
2882 }
2883
2884
2885
2886 /* should be called with the ast_channel locked */
2887 static openr2_calling_party_category_t dahdi_r2_get_channel_category(struct ast_channel *c)
2888 {
2889         openr2_calling_party_category_t cat;
2890         const char *catstr = pbx_builtin_getvar_helper(c, "MFCR2_CATEGORY");
2891         struct dahdi_pvt *p = c->tech_pvt;
2892         if (ast_strlen_zero(catstr)) {
2893                 ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
2894                                 c->name, openr2_proto_get_category_string(p->mfcr2_category));
2895                 return p->mfcr2_category;
2896         }
2897         if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
2898                 ast_log(LOG_WARNING, "Invalid category specified '%s' for chan %s, using default %s\n",
2899                                 catstr, c->name, openr2_proto_get_category_string(p->mfcr2_category));
2900                 return p->mfcr2_category;
2901         }
2902         ast_debug(1, "Using category %s\n", catstr);
2903         return cat;
2904 }
2905
2906 static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
2907 {
2908         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
2909         ast_mutex_lock(&p->lock);
2910         if (p->mfcr2call) {
2911                 ast_mutex_unlock(&p->lock);
2912                 /* TODO: This can happen when some other thread just finished dahdi_request requesting this very same
2913                    interface but has not yet seized the line (dahdi_call), and the far end wins and seize the line,
2914                    can we avoid this somehow?, at this point when dahdi_call send the seize, it is likely that since
2915                    the other end will see our seize as a forced release and drop the call, we will see an invalid
2916                    pattern that will be seen and treated as protocol error. */
2917                 ast_log(LOG_ERROR, "Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
2918                 return;
2919         }
2920         p->mfcr2call = 1;
2921         /* better safe than sorry ... */
2922         p->cid_name[0] = '\0';
2923         p->cid_num[0] = '\0';
2924         p->rdnis[0] = '\0';
2925         p->exten[0] = '\0';
2926         p->mfcr2_ani_index = '\0';
2927         p->mfcr2_dnis_index = '\0';
2928         p->mfcr2_dnis_matched = 0;
2929         p->mfcr2_answer_pending = 0;
2930         p->mfcr2_call_accepted = 0;
2931         ast_mutex_unlock(&p->lock);
2932         ast_log(LOG_NOTICE, "New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
2933 }
2934
2935 static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm)
2936 {
2937         int res;
2938         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
2939         ast_mutex_lock(&p->lock);
2940         p->inalarm = alarm ? 1 : 0;
2941         if (p->inalarm) {
2942                 res = get_alarms(p);
2943                 handle_alarms(p, res);
2944         } else {
2945                 ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel);
2946                 manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", "Channel: %d\r\n", p->channel);
2947         }
2948         ast_mutex_unlock(&p->lock);
2949 }
2950
2951 static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
2952 {
2953         ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
2954 }
2955
2956 static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
2957 {
2958         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
2959         ast_log(LOG_ERROR, "MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
2960         if (p->owner) {
2961                 p->owner->hangupcause = AST_CAUSE_PROTOCOL_ERROR;
2962                 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
2963         }
2964         ast_mutex_lock(&p->lock);
2965         p->mfcr2call = 0;
2966         ast_mutex_unlock(&p->lock);
2967 }
2968
2969 static void dahdi_r2_update_monitor_count(struct dahdi_mfcr2 *mfcr2, int increment)
2970 {
2971         ast_mutex_lock(&mfcr2->monitored_count_lock);
2972         if (increment) {
2973                 mfcr2->monitored_count++;
2974                 if (mfcr2->monitored_count == 1) {
2975                         ast_log(LOG_DEBUG, "At least one device needs monitoring, let's wake up the monitor thread.\n");
2976                         ast_cond_signal(&mfcr2->do_monitor);
2977                 }
2978         } else {
2979                 mfcr2->monitored_count--;
2980                 if (mfcr2->monitored_count < 0) {
2981                         ast_log(LOG_ERROR, "we have a bug here!.\n");
2982                 }
2983         }
2984         ast_mutex_unlock(&mfcr2->monitored_count_lock);
2985 }
2986
2987 static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category)
2988 {
2989         struct dahdi_pvt *p;
2990         struct ast_channel *c;
2991         ast_log(LOG_NOTICE, "MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
2992                         openr2_chan_get_number(r2chan), ani ? ani : "(restricted)", dnis,
2993                         openr2_proto_get_category_string(category));
2994         p = openr2_chan_get_client_data(r2chan);
2995         /* if collect calls are not allowed and this is a collect call, reject it! */
2996         if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
2997                 ast_log(LOG_NOTICE, "Rejecting MFC/R2 collect call\n");
2998                 openr2_chan_disconnect_call(r2chan, OR2_CAUSE_COLLECT_CALL_REJECTED);
2999                 return;
3000         }
3001         ast_mutex_lock(&p->lock);
3002         p->mfcr2_recvd_category = category;
3003         /* if we're not supposed to use CID, clear whatever we have */
3004         if (!p->use_callerid) {
3005                 ast_log(LOG_DEBUG, "No CID allowed in configuration, CID is being cleared!\n");
3006                 p->cid_num[0] = 0;
3007                 p->cid_name[0] = 0;
3008         }
3009         /* if we're supposed to answer immediately, clear DNIS and set 's' exten */
3010         if (p->immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
3011                 ast_log(LOG_DEBUG, "Setting exten => s because of immediate or 0 DNIS configured\n");
3012                 p->exten[0] = 's';
3013                 p->exten[1] = 0;
3014         }
3015         ast_mutex_unlock(&p->lock);
3016         if (!ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
3017                 ast_log(LOG_NOTICE, "MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
3018                                 p->channel, p->exten, p->context);
3019                 openr2_chan_disconnect_call(r2chan, OR2_CAUSE_UNALLOCATED_NUMBER);
3020                 return;
3021         }
3022         if (!p->mfcr2_accept_on_offer) {
3023                 /* The user wants us to start the PBX thread right away without accepting the call first */
3024                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, 0, NULL);
3025                 if (c) {
3026                         dahdi_r2_update_monitor_count(p->mfcr2, 0);
3027                         /* Done here, don't disable reading now since we still need to generate MF tones to accept
3028                            the call or reject it and detect the tone off condition of the other end, all of this
3029                            will be done in the PBX thread now */
3030                         return;
3031                 }
3032                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3033                 openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER);
3034         } else if (p->mfcr2_charge_calls) {
3035                 ast_log(LOG_DEBUG, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
3036                 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
3037         } else {
3038                 ast_log(LOG_DEBUG, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
3039                 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
3040         }
3041 }
3042
3043 static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
3044 {
3045         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3046         ast_log(LOG_NOTICE, "MFC/R2 call end on chan %d\n", p->channel);
3047         ast_mutex_lock(&p->lock);
3048         p->mfcr2call = 0;
3049         ast_mutex_unlock(&p->lock);
3050 }
3051
3052 static void dahdi_enable_ec(struct dahdi_pvt *p);
3053 static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
3054 {
3055         struct dahdi_pvt *p = NULL;
3056         struct ast_channel *c = NULL;
3057         ast_log(LOG_NOTICE, "MFC/R2 call has been accepted on chan %d\n", openr2_chan_get_number(r2chan));
3058         p = openr2_chan_get_client_data(r2chan);
3059         dahdi_enable_ec(p);
3060         p->mfcr2_call_accepted = 1;
3061         /* if it's an incoming call ... */
3062         if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
3063                 /* If accept on offer is not set, it means at this point the PBX thread is already
3064                    launched (was launched in the 'on call offered' handler) and therefore this callback
3065                    is being executed already in the PBX thread rather than the monitor thread, don't launch
3066                    any other thread, just disable the openr2 reading and answer the call if needed */
3067                 if (!p->mfcr2_accept_on_offer) {
3068                         openr2_chan_disable_read(r2chan);
3069                         if (p->mfcr2_answer_pending) {
3070                                 ast_log(LOG_DEBUG, "Answering MFC/R2 call after accepting it on chan %d\n", openr2_chan_get_number(r2chan));
3071                                 dahdi_r2_answer(p);
3072                         }
3073                         return;
3074                 }
3075                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, 0, NULL);
3076                 if (c) {
3077                         dahdi_r2_update_monitor_count(p->mfcr2, 0);
3078                         /* chan_dahdi will take care of reading from now on in the PBX thread, tell the
3079                            library to forget about it */
3080                         openr2_chan_disable_read(r2chan);
3081                         return;
3082                 }
3083                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3084                 /* failed to create the channel, bail out and report it as an out of order line */
3085                 openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER);
3086                 return;
3087         }
3088         /* this is an outgoing call, no need to launch the PBX thread, most likely we're in one already */
3089         ast_log(LOG_NOTICE, "Call accepted on forward channel %d\n", p->channel);
3090         p->subs[SUB_REAL].needringing = 1;
3091         p->dialing = 0;
3092         /* chan_dahdi will take care of reading from now on in the PBX thread, tell the
3093            library to forget about it */
3094         openr2_chan_disable_read(r2chan);
3095 }
3096
3097 static void dahdi_r2_on_call_answered(openr2_chan_t *r2chan)
3098 {
3099         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3100         ast_log(LOG_DEBUG, "MFC/R2 call has been answered on chan %d\n", openr2_chan_get_number(r2chan));
3101         p->subs[SUB_REAL].needanswer = 1;
3102 }
3103
3104 static void dahdi_r2_on_call_read(openr2_chan_t *r2chan, const unsigned char *buf, int buflen)
3105 {
3106         /*ast_log(LOG_DEBUG, "Read data from dahdi channel %d\n", openr2_chan_get_number(r2chan));*/
3107 }
3108
3109 static int dahdi_r2_cause_to_ast_cause(openr2_call_disconnect_cause_t cause)
3110 {
3111         switch (cause) {
3112         case OR2_CAUSE_BUSY_NUMBER:
3113                 return AST_CAUSE_BUSY;
3114         case OR2_CAUSE_NETWORK_CONGESTION:
3115                 return AST_CAUSE_CONGESTION;
3116         case OR2_CAUSE_OUT_OF_ORDER:
3117                 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
3118         case OR2_CAUSE_UNALLOCATED_NUMBER:
3119                 return AST_CAUSE_UNREGISTERED;
3120         case OR2_CAUSE_NO_ANSWER:
3121                 return AST_CAUSE_NO_ANSWER;
3122         case OR2_CAUSE_NORMAL_CLEARING:
3123                 return AST_CAUSE_NORMAL_CLEARING;
3124         case OR2_CAUSE_UNSPECIFIED:
3125         default:
3126                 return AST_CAUSE_NOTDEFINED;
3127         }
3128 }
3129
3130 static void dahdi_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause)
3131 {
3132         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3133         ast_verb(3, "MFC/R2 call disconnected on chan %d\n", openr2_chan_get_number(r2chan));
3134         ast_mutex_lock(&p->lock);
3135         if (!p->owner) {
3136                 ast_mutex_unlock(&p->lock);
3137                 /* no owner, therefore we can't use dahdi_hangup to disconnect, do it right now */
3138                 openr2_chan_disconnect_call(r2chan, OR2_CAUSE_NORMAL_CLEARING);
3139                 return;
3140         }
3141         /* when we have an owner we don't call openr2_chan_disconnect_call here, that will
3142            be done in dahdi_hangup */
3143         if (p->owner->_state == AST_STATE_UP) {
3144                 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
3145                 ast_mutex_unlock(&p->lock);
3146         } else if (openr2_chan_get_direction(r2chan) == OR2_DIR_FORWARD) {
3147                 /* being the forward side we must report what happened to the call to whoever requested it */
3148                 switch (cause) {
3149                 case OR2_CAUSE_BUSY_NUMBER:
3150                         p->subs[SUB_REAL].needbusy = 1;
3151                         break;
3152                 case OR2_CAUSE_NETWORK_CONGESTION:
3153                 case OR2_CAUSE_OUT_OF_ORDER:
3154                 case OR2_CAUSE_UNALLOCATED_NUMBER:
3155                 case OR2_CAUSE_NO_ANSWER:
3156                 case OR2_CAUSE_UNSPECIFIED:
3157                 case OR2_CAUSE_NORMAL_CLEARING:
3158                         p->subs[SUB_REAL].needcongestion = 1;
3159                         break;
3160                 default:
3161                         p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
3162                 }
3163                 ast_mutex_unlock(&p->lock);
3164         } else {
3165                 ast_mutex_unlock(&p->lock);
3166                 /* being the backward side and not UP yet, we only need to request hangup */
3167                 /* TODO: what about doing this same thing when were AST_STATE_UP? */
3168                 ast_queue_hangup_with_cause(p->owner, dahdi_r2_cause_to_ast_cause(cause));
3169         }
3170 }
3171
3172 static void dahdi_r2_write_log(openr2_log_level_t level, char *logmessage)
3173 {
3174         switch (level) {
3175         case OR2_LOG_NOTICE:
3176                 ast_log(LOG_NOTICE, "%s", logmessage);
3177                 break;
3178         case OR2_LOG_WARNING:
3179                 ast_log(LOG_WARNING, "%s", logmessage);
3180                 break;
3181         case OR2_LOG_ERROR:
3182                 ast_log(LOG_ERROR, "%s", logmessage);
3183                 break;
3184         case OR2_LOG_STACK_TRACE:
3185         case OR2_LOG_MF_TRACE:
3186         case OR2_LOG_CAS_TRACE:
3187         case OR2_LOG_DEBUG:
3188         case OR2_LOG_EX_DEBUG:
3189                 ast_log(LOG_DEBUG, "%s", logmessage);
3190                 break;
3191         default:
3192                 ast_log(LOG_WARNING, "We should handle logging level %d here.\n", level);
3193                 ast_log(LOG_DEBUG, "%s", logmessage);
3194                 break;
3195         }
3196 }
3197
3198 static void dahdi_r2_on_line_blocked(openr2_chan_t *r2chan)
3199 {
3200         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3201         ast_mutex_lock(&p->lock);
3202         p->remotelyblocked = 1;
3203         ast_mutex_unlock(&p->lock);
3204         ast_log(LOG_NOTICE, "Far end blocked on chan %d\n", openr2_chan_get_number(r2chan));
3205 }
3206
3207 static void dahdi_r2_on_line_idle(openr2_chan_t *r2chan)
3208 {
3209         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3210         ast_mutex_lock(&p->lock);
3211         p->remotelyblocked = 0;
3212         ast_mutex_unlock(&p->lock);
3213         ast_log(LOG_NOTICE, "Far end unblocked on chan %d\n", openr2_chan_get_number(r2chan));
3214 }
3215
3216 static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap)
3217         __attribute__((format (printf, 3, 0)));
3218 static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap)
3219 {
3220 #define CONTEXT_TAG "Context - "
3221         char logmsg[256];
3222         char completemsg[sizeof(logmsg) + sizeof(CONTEXT_TAG) - 1];
3223         vsnprintf(logmsg, sizeof(logmsg), fmt, ap);
3224         snprintf(completemsg, sizeof(completemsg), CONTEXT_TAG "%s", logmsg);
3225         dahdi_r2_write_log(level, completemsg);
3226 #undef CONTEXT_TAG
3227 }
3228
3229 static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap)
3230         __attribute__((format (printf, 3, 0)));
3231 static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap)
3232 {
3233 #define CHAN_TAG "Chan "
3234         char logmsg[256];
3235         char completemsg[sizeof(logmsg) + sizeof(CHAN_TAG) - 1];
3236         vsnprintf(logmsg, sizeof(logmsg), fmt, ap);
3237         snprintf(completemsg, sizeof(completemsg), CHAN_TAG "%d - %s", openr2_chan_get_number(r2chan), logmsg);
3238         dahdi_r2_write_log(level, completemsg);
3239 }
3240
3241 static int dahdi_r2_on_dnis_digit_received(openr2_chan_t *r2chan, char digit)
3242 {
3243         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3244         /* if 'immediate' is set, let's stop requesting DNIS */
3245         if (p->immediate) {
3246                 return 0;
3247         }
3248         p->exten[p->mfcr2_dnis_index] = digit;
3249         p->rdnis[p->mfcr2_dnis_index] = digit;
3250         p->mfcr2_dnis_index++;
3251         p->exten[p->mfcr2_dnis_index] = 0;
3252         p->rdnis[p->mfcr2_dnis_index] = 0;
3253         /* if the DNIS is a match and cannot match more, stop requesting DNIS */
3254         if ((p->mfcr2_dnis_matched ||
3255             (ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num) && (p->mfcr2_dnis_matched = 1))) &&
3256             !ast_matchmore_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
3257                 return 0;
3258         }
3259         /* otherwise keep going */
3260         return 1;
3261 }
3262
3263 static void dahdi_r2_on_ani_digit_received(openr2_chan_t *r2chan, char digit)
3264 {
3265         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3266         p->cid_num[p->mfcr2_ani_index] = digit;
3267         p->cid_name[p->mfcr2_ani_index] = digit;
3268         p->mfcr2_ani_index++;
3269         p->cid_num[p->mfcr2_ani_index] = 0;
3270         p->cid_name[p->mfcr2_ani_index] = 0;
3271 }
3272
3273 static openr2_event_interface_t dahdi_r2_event_iface = {
3274         .on_call_init = dahdi_r2_on_call_init,
3275         .on_call_offered = dahdi_r2_on_call_offered,
3276         .on_call_accepted = dahdi_r2_on_call_accepted,
3277         .on_call_answered = dahdi_r2_on_call_answered,
3278         .on_call_disconnect = dahdi_r2_on_call_disconnect,
3279         .on_call_end = dahdi_r2_on_call_end,
3280         .on_call_read = dahdi_r2_on_call_read,
3281         .on_hardware_alarm = dahdi_r2_on_hardware_alarm,
3282         .on_os_error = dahdi_r2_on_os_error,
3283         .on_protocol_error = dahdi_r2_on_protocol_error,
3284         .on_line_blocked = dahdi_r2_on_line_blocked,
3285         .on_line_idle = dahdi_r2_on_line_idle,
3286         /* cast seems to be needed to get rid of the annoying warning regarding format attribute  */
3287         .on_context_log = (openr2_handle_context_logging_func)dahdi_r2_on_context_log,
3288         .on_dnis_digit_received = dahdi_r2_on_dnis_digit_received,
3289         .on_ani_digit_received = dahdi_r2_on_ani_digit_received,
3290         /* so far we do nothing with billing pulses */
3291         .on_billing_pulse_received = NULL
3292 };
3293
3294 static inline int16_t dahdi_r2_alaw_to_linear(uint8_t sample)
3295 {
3296         return AST_ALAW(sample);
3297 }
3298
3299 static inline uint8_t dahdi_r2_linear_to_alaw(int sample)
3300 {
3301         return AST_LIN2A(sample);
3302 }
3303
3304 static openr2_transcoder_interface_t dahdi_r2_transcode_iface = {
3305         dahdi_r2_alaw_to_linear,
3306         dahdi_r2_linear_to_alaw
3307 };
3308
3309 #endif /* HAVE_OPENR2 */
3310
3311 static void swap_subs(struct dahdi_pvt *p, int a, int b)
3312 {
3313         int tchan;
3314         int tinthreeway;
3315         struct ast_channel *towner;
3316
3317         ast_debug(1, "Swapping %d and %d\n", a, b);
3318
3319         tchan = p->subs[a].chan;
3320         towner = p->subs[a].owner;
3321         tinthreeway = p->subs[a].inthreeway;
3322
3323         p->subs[a].chan = p->subs[b].chan;
3324         p->subs[a].owner = p->subs[b].owner;
3325         p->subs[a].inthreeway = p->subs[b].inthreeway;
3326
3327         p->subs[b].chan = tchan;
3328         p->subs[b].owner = towner;
3329         p->subs[b].inthreeway = tinthreeway;
3330
3331         if (p->subs[a].owner)
3332                 ast_channel_set_fd(p->subs[a].owner, 0, p->subs[a].dfd);
3333         if (p->subs[b].owner)
3334                 ast_channel_set_fd(p->subs[b].owner, 0, p->subs[b].dfd);
3335         wakeup_sub(p, a);
3336         wakeup_sub(p, b);
3337 }
3338
3339 static int dahdi_open(char *fn)
3340 {
3341         int fd;
3342         int isnum;
3343         int chan = 0;
3344         int bs;
3345         int x;
3346         isnum = 1;
3347         for (x = 0; x < strlen(fn); x++) {
3348                 if (!isdigit(fn[x])) {
3349                         isnum = 0;
3350                         break;
3351                 }
3352         }
3353         if (isnum) {
3354                 chan = atoi(fn);
3355                 if (chan < 1) {
3356                         ast_log(LOG_WARNING, "Invalid channel number '%s'\n", fn);
3357                         return -1;
3358                 }
3359                 fn = "/dev/dahdi/channel";
3360         }
3361         fd = open(fn, O_RDWR | O_NONBLOCK);
3362         if (fd < 0) {
3363                 ast_log(LOG_WARNING, "Unable to open '%s': %s\n", fn, strerror(errno));
3364                 return -1;
3365         }
3366         if (chan) {
3367                 if (ioctl(fd, DAHDI_SPECIFY, &chan)) {
3368                         x = errno;
3369                         close(fd);
3370                         errno = x;
3371                         ast_log(LOG_WARNING, "Unable to specify channel %d: %s\n", chan, strerror(errno));
3372                         return -1;
3373                 }
3374         }
3375         bs = READ_SIZE;
3376         if (ioctl(fd, DAHDI_SET_BLOCKSIZE, &bs) == -1) {
3377                 ast_log(LOG_WARNING, "Unable to set blocksize '%d': %s\n", bs,  strerror(errno));
3378                 x = errno;
3379                 close(fd);
3380                 errno = x;
3381                 return -1;
3382         }
3383         return fd;
3384 }
3385
3386 static void dahdi_close(int fd)
3387 {
3388         if (fd > 0)
3389                 close(fd);
3390 }
3391
3392 static void dahdi_close_sub(struct dahdi_pvt *chan_pvt, int sub_num)
3393 {
3394         dahdi_close(chan_pvt->subs[sub_num].dfd);
3395         chan_pvt->subs[sub_num].dfd = -1;
3396 }
3397
3398 #if defined(HAVE_PRI)
3399 static void dahdi_close_pri_fd(struct dahdi_pri *pri, int fd_num)
3400 {
3401         dahdi_close(pri->pri.fds[fd_num]);
3402         pri->pri.fds[fd_num] = -1;
3403 }
3404 #endif  /* defined(HAVE_PRI) */
3405
3406 #if defined(HAVE_SS7)
3407 static void dahdi_close_ss7_fd(struct dahdi_ss7 *ss7, int fd_num)
3408 {
3409         dahdi_close(ss7->fds[fd_num]);
3410         ss7->fds[fd_num] = -1;
3411 }
3412 #endif  /* defined(HAVE_SS7) */
3413
3414 static int dahdi_setlinear(int dfd, int linear)
3415 {
3416         int res;
3417         res = ioctl(dfd, DAHDI_SETLINEAR, &linear);
3418         if (res)
3419                 return res;
3420         return 0;
3421 }
3422
3423
3424 static int alloc_sub(struct dahdi_pvt *p, int x)
3425 {
3426         struct dahdi_bufferinfo bi;
3427         int res;
3428         if (p->subs[x].dfd >= 0) {
3429                 ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
3430                 return -1;
3431         }
3432
3433         p->subs[x].dfd = dahdi_open("/dev/dahdi/pseudo");
3434         if (p->subs[x].dfd <= -1) {
3435                 ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
3436                 return -1;
3437         }
3438
3439         res = ioctl(p->subs[x].dfd, DAHDI_GET_BUFINFO, &bi);
3440         if (!res) {
3441                 bi.txbufpolicy = p->buf_policy;
3442                 bi.rxbufpolicy = p->buf_policy;
3443                 bi.numbufs = p->buf_no;
3444                 res = ioctl(p->subs[x].dfd, DAHDI_SET_BUFINFO, &bi);
3445                 if (res < 0) {
3446                         ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d: %s\n", x, strerror(errno));
3447                 }
3448         } else
3449                 ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d: %s\n", x, strerror(errno));
3450
3451         if (ioctl(p->subs[x].dfd, DAHDI_CHANNO, &p->subs[x].chan) == 1) {
3452                 ast_log(LOG_WARNING, "Unable to get channel number for pseudo channel on FD %d: %s\n", p->subs[x].dfd, strerror(errno));
3453                 dahdi_close_sub(p, x);
3454                 p->subs[x].dfd = -1;
3455                 return -1;
3456         }
3457         ast_debug(1, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].dfd, p->subs[x].chan);
3458         return 0;
3459 }
3460
3461 static int unalloc_sub(struct dahdi_pvt *p, int x)
3462 {
3463         if (!x) {
3464                 ast_log(LOG_WARNING, "Trying to unalloc the real channel %d?!?\n", p->channel);
3465                 return -1;
3466         }
3467         ast_debug(1, "Released sub %d of channel %d\n", x, p->channel);
3468         dahdi_close_sub(p, x);
3469         p->subs[x].linear = 0;
3470         p->subs[x].chan = 0;
3471         p->subs[x].owner = NULL;
3472         p->subs[x].inthreeway = 0;
3473         p->polarity = POLARITY_IDLE;
3474         memset(&p->subs[x].curconf, 0, sizeof(p->subs[x].curconf));
3475         return 0;
3476 }
3477
3478 static int digit_to_dtmfindex(char digit)
3479 {
3480         if (isdigit(digit))
3481                 return DAHDI_TONE_DTMF_BASE + (digit - '0');
3482         else if (digit >= 'A' && digit <= 'D')
3483                 return DAHDI_TONE_DTMF_A + (digit - 'A');
3484         else if (digit >= 'a' && digit <= 'd')
3485                 return DAHDI_TONE_DTMF_A + (digit - 'a');
3486         else if (digit == '*')
3487                 return DAHDI_TONE_DTMF_s;
3488         else if (digit == '#')
3489                 return DAHDI_TONE_DTMF_p;
3490         else
3491                 return -1;
3492 }
3493
3494 static int dahdi_digit_begin(struct ast_channel *chan, char digit)
3495 {
3496         struct dahdi_pvt *pvt;
3497         int idx;
3498         int dtmf = -1;
3499         int res;
3500
3501         pvt = chan->tech_pvt;
3502
3503         ast_mutex_lock(&pvt->lock);
3504
3505         idx = dahdi_get_index(chan, pvt, 0);
3506
3507         if ((idx != SUB_REAL) || !pvt->owner)
3508                 goto out;
3509
3510 #ifdef HAVE_PRI
3511         if (pvt->sig == SIG_PRI || pvt->sig == SIG_BRI || pvt->sig == SIG_BRI_PTMP) {
3512                 res = sig_pri_digit_begin(pvt->sig_pvt, chan, digit);
3513                 if (!res)
3514                         goto out;
3515         }
3516 #endif
3517         if ((dtmf = digit_to_dtmfindex(digit)) == -1)
3518                 goto out;
3519
3520         if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &dtmf)) {
3521                 struct dahdi_dialoperation zo = {
3522                         .op = DAHDI_DIAL_OP_APPEND,
3523                 };
3524
3525                 zo.dialstr[0] = 'T';
3526                 zo.dialstr[1] = digit;
3527                 zo.dialstr[2] = '\0';
3528                 if ((res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_DIAL, &zo)))
3529                         ast_log(LOG_WARNING, "Couldn't dial digit %c: %s\n", digit, strerror(errno));
3530                 else
3531                         pvt->dialing = 1;
3532         } else {
3533                 ast_debug(1, "Started VLDTMF digit '%c'\n", digit);
3534                 pvt->dialing = 1;
3535                 pvt->begindigit = digit;
3536         }
3537
3538 out:
3539         ast_mutex_unlock(&pvt->lock);
3540
3541         return 0;
3542 }
3543
3544 static int dahdi_digit_end(struct ast_channel *chan, char digit, unsigned int duration)
3545 {
3546         struct dahdi_pvt *pvt;
3547         int res = 0;
3548         int idx;
3549         int x;
3550
3551         pvt = chan->tech_pvt;
3552
3553         ast_mutex_lock(&pvt->lock);
3554
3555         idx = dahdi_get_index(chan, pvt, 0);
3556
3557         if ((idx != SUB_REAL) || !pvt->owner || pvt->pulse)
3558                 goto out;
3559
3560 #ifdef HAVE_PRI
3561         /* This means that the digit was already sent via PRI signalling */
3562         if (((pvt->sig == SIG_PRI) || (pvt->sig == SIG_BRI) || (pvt->sig == SIG_BRI_PTMP))
3563                         && !pvt->begindigit)
3564                 goto out;
3565 #endif
3566
3567         if (pvt->begindigit) {
3568                 x = -1;
3569                 ast_debug(1, "Ending VLDTMF digit '%c'\n", digit);
3570                 res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &x);
3571                 pvt->dialing = 0;
3572                 pvt->begindigit = 0;
3573         }
3574
3575 out:
3576         ast_mutex_unlock(&pvt->lock);
3577
3578         return res;
3579 }
3580
3581 static const char * const events[] = {
3582         "No event",
3583         "On hook",
3584         "Ring/Answered",
3585         "Wink/Flash",
3586         "Alarm",
3587         "No more alarm",
3588         "HDLC Abort",
3589         "HDLC Overrun",
3590         "HDLC Bad FCS",
3591         "Dial Complete",
3592         "Ringer On",
3593         "Ringer Off",
3594         "Hook Transition Complete",
3595         "Bits Changed",
3596         "Pulse Start",
3597         "Timer Expired",
3598         "Timer Ping",
3599         "Polarity Reversal",
3600         "Ring Begin",
3601 };
3602
3603 static struct {
3604         int alarm;
3605         char *name;
3606 } alarms[] = {
3607         { DAHDI_ALARM_RED, "Red Alarm" },
3608         { DAHDI_ALARM_YELLOW, "Yellow Alarm" },
3609         { DAHDI_ALARM_BLUE, "Blue Alarm" },
3610         { DAHDI_ALARM_RECOVER, "Recovering" },
3611         { DAHDI_ALARM_LOOPBACK, "Loopback" },
3612         { DAHDI_ALARM_NOTOPEN, "Not Open" },
3613         { DAHDI_ALARM_NONE, "None" },
3614 };
3615
3616 static char *alarm2str(int alm)
3617 {
3618         int x;
3619         for (x = 0; x < ARRAY_LEN(alarms); x++) {
3620                 if (alarms[x].alarm & alm)
3621                         return alarms[x].name;
3622         }
3623         return alm ? "Unknown Alarm" : "No Alarm";
3624 }
3625
3626 static const char *event2str(int event)
3627 {
3628         static char buf[256];
3629         if ((event < (ARRAY_LEN(events))) && (event > -1))
3630                 return events[event];
3631         sprintf(buf, "Event %d", event); /* safe */
3632         return buf;
3633 }
3634
3635 static char *dahdi_sig2str(int sig)
3636 {
3637         static char buf[256];
3638         switch (sig) {
3639         case SIG_EM:
3640                 return "E & M Immediate";
3641         case SIG_EMWINK:
3642                 return "E & M Wink";
3643         case SIG_EM_E1:
3644                 return "E & M E1";
3645         case SIG_FEATD:
3646                 return "Feature Group D (DTMF)";
3647         case SIG_FEATDMF:
3648                 return "Feature Group D (MF)";
3649         case SIG_FEATDMF_TA:
3650                 return "Feature Groud D (MF) Tandem Access";
3651         case SIG_FEATB:
3652                 return "Feature Group B (MF)";
3653         case SIG_E911:
3654                 return "E911 (MF)";
3655         case SIG_FGC_CAMA:
3656                 return "FGC/CAMA (Dialpulse)";
3657         case SIG_FGC_CAMAMF:
3658                 return "FGC/CAMA (MF)";
3659         case SIG_FXSLS:
3660                 return "FXS Loopstart";
3661         case SIG_FXSGS:
3662                 return "FXS Groundstart";
3663         case SIG_FXSKS:
3664                 return "FXS Kewlstart";
3665         case SIG_FXOLS:
3666                 return "FXO Loopstart";
3667         case SIG_FXOGS:
3668                 return "FXO Groundstart";
3669         case SIG_FXOKS:
3670                 return "FXO Kewlstart";
3671         case SIG_PRI:
3672                 return "ISDN PRI";
3673         case SIG_BRI:
3674                 return "ISDN BRI Point to Point";
3675         case SIG_BRI_PTMP:
3676                 return "ISDN BRI Point to MultiPoint";
3677         case SIG_SS7:
3678                 return "SS7";
3679         case SIG_MFCR2:
3680                 return "MFC/R2";
3681         case SIG_SF:
3682                 return "SF (Tone) Immediate";
3683         case SIG_SFWINK:
3684                 return "SF (Tone) Wink";
3685         case SIG_SF_FEATD:
3686                 return "SF (Tone) with Feature Group D (DTMF)";
3687         case SIG_SF_FEATDMF:
3688                 return "SF (Tone) with Feature Group D (MF)";
3689         case SIG_SF_FEATB:
3690                 return "SF (Tone) with Feature Group B (MF)";
3691         case 0:
3692                 return "Pseudo";
3693         default:
3694                 snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
3695                 return buf;
3696         }
3697 }
3698
3699 int analog_lib_handles(int signalling, int radio, int oprmode)
3700 {
3701         switch (signalling) {
3702         case SIG_FXOLS:
3703         case SIG_FXOGS:
3704         case SIG_FXOKS:
3705         case SIG_FXSLS:
3706         case SIG_FXSGS:
3707         case SIG_FXSKS:
3708         case SIG_EMWINK:
3709         case SIG_EM:
3710         case SIG_EM_E1:
3711         case SIG_FEATD:
3712         case SIG_FEATDMF:
3713         case SIG_E911:
3714         case SIG_FGC_CAMA:
3715         case SIG_FGC_CAMAMF:
3716         case SIG_FEATB:
3717         case SIG_SFWINK:
3718         case SIG_SF:
3719         case SIG_SF_FEATD:
3720         case SIG_SF_FEATDMF:
3721         case SIG_FEATDMF_TA:
3722         case SIG_SF_FEATB:
3723                 break;
3724         default:
3725                 /* The rest of the function should cover the remainder of signalling types */
3726                 return 0;
3727         }
3728
3729         if (radio)
3730                 return 0;
3731
3732         if (oprmode)
3733                 return 0;
3734
3735         return 1;
3736 }
3737
3738 #define sig2str dahdi_sig2str
3739
3740 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int idx, int slavechannel)
3741 {
3742         /* If the conference already exists, and we're already in it
3743            don't bother doing anything */
3744         struct dahdi_confinfo zi;