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