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