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