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