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