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