cc82f156f821dc748e9d7d38ac3fc1be7e3a24d3
[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                         if (errno != ELAST) {
1223                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1224                                 callerid_free(p->cs);
1225                                 return -1;
1226                         }
1227                 }
1228
1229                 if (analog_p->ringt > 0) {
1230                         if (!(--analog_p->ringt)) {
1231                                 /* only return if we timeout from a ring event */
1232                                 return -1;
1233                         }
1234                 }
1235
1236                 if (p->cid_signalling == CID_SIG_V23_JP) {
1237                         res = callerid_feed_jp(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1238                 } else {
1239                         res = callerid_feed(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1240                 }
1241                 if (res < 0) {
1242                         /*
1243                          * The previous diagnostic message output likely
1244                          * explains why it failed.
1245                          */
1246                         ast_log(LOG_WARNING, "Failed to decode CallerID\n");
1247                         return -1;
1248                 }
1249
1250                 if (res == 1) {
1251                         callerid_get(p->cs, &name, &num, &flags);
1252                         if (name)
1253                                 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
1254                         if (num)
1255                                 ast_copy_string(numbuf, num, ANALOG_MAX_CID);
1256
1257                         ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
1258                         return 0;
1259                 }
1260         }
1261
1262         *ev = ANALOG_EVENT_NONE;
1263         return 2;
1264 }
1265
1266 static const char *event2str(int event);
1267 static int restore_gains(struct dahdi_pvt *p);
1268
1269 static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
1270 {
1271         unsigned char buf[256];
1272         int distMatches;
1273         int curRingData[RING_PATTERNS];
1274         int receivedRingT;
1275         int counter1;
1276         int counter;
1277         int i;
1278         int res;
1279         int checkaftercid = 0;
1280
1281         struct dahdi_pvt *p = pvt;
1282         struct analog_pvt *analog_p = p->sig_pvt;
1283
1284         if (ringdata == NULL) {
1285                 ringdata = curRingData;
1286         } else {
1287                 checkaftercid = 1;
1288         }
1289
1290         /* We must have a ring by now, so, if configured, lets try to listen for
1291          * distinctive ringing */
1292         if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
1293                 /* Clear the current ring data array so we don't have old data in it. */
1294                 for (receivedRingT = 0; receivedRingT < RING_PATTERNS; receivedRingT++)
1295                         ringdata[receivedRingT] = 0;
1296                 receivedRingT = 0;
1297                 if (checkaftercid && distinctiveringaftercid)
1298                         ast_verb(3, "Detecting post-CID distinctive ring\n");
1299                 /* Check to see if context is what it should be, if not set to be. */
1300                 else if (strcmp(p->context,p->defcontext) != 0) {
1301                         ast_copy_string(p->context, p->defcontext, sizeof(p->context));
1302                         ast_channel_context_set(chan, p->defcontext);
1303                 }
1304
1305                 for (;;) {
1306                         i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1307                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
1308                                 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
1309                                 ast_hangup(chan);
1310                                 return 1;
1311                         }
1312                         if (i & DAHDI_IOMUX_SIGEVENT) {
1313                                 res = dahdi_get_event(p->subs[idx].dfd);
1314                                 if (res == DAHDI_EVENT_NOALARM) {
1315                                         p->inalarm = 0;
1316                                         analog_p->inalarm = 0;
1317                                 }
1318                                 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
1319                                 res = 0;
1320                                 /* Let us detect distinctive ring */
1321
1322                                 ringdata[receivedRingT] = analog_p->ringt;
1323
1324                                 if (analog_p->ringt < analog_p->ringt_base/2)
1325                                         break;
1326                                 /* Increment the ringT counter so we can match it against
1327                                    values in chan_dahdi.conf for distinctive ring */
1328                                 if (++receivedRingT == RING_PATTERNS)
1329                                         break;
1330                         } else if (i & DAHDI_IOMUX_READ) {
1331                                 res = read(p->subs[idx].dfd, buf, sizeof(buf));
1332                                 if (res < 0) {
1333                                         if (errno != ELAST) {
1334                                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1335                                                 ast_hangup(chan);
1336                                                 return 1;
1337                                         }
1338                                         break;
1339                                 }
1340                                 if (analog_p->ringt > 0) {
1341                                         if (!(--analog_p->ringt)) {
1342                                                 res = -1;
1343                                                 break;
1344                                         }
1345                                 }
1346                         }
1347                 }
1348         }
1349         if ((checkaftercid && usedistinctiveringdetection) || !checkaftercid) {
1350                 /* this only shows up if you have n of the dring patterns filled in */
1351                 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",ringdata[0],ringdata[1],ringdata[2]);
1352                 for (counter = 0; counter < 3; counter++) {
1353                 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
1354                         distMatches = 0;
1355                         /* this only shows up if you have n of the dring patterns filled in */
1356                         ast_verb(3, "Checking %d,%d,%d\n",
1357                                         p->drings.ringnum[counter].ring[0],
1358                                         p->drings.ringnum[counter].ring[1],
1359                                         p->drings.ringnum[counter].ring[2]);
1360                         for (counter1 = 0; counter1 < 3; counter1++) {
1361                                 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
1362                                 if (p->drings.ringnum[counter].ring[counter1] == -1) {
1363                                         ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1364                                         ringdata[counter1]);
1365                                         distMatches++;
1366                                 } else if (ringdata[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
1367                                                                                 ringdata[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
1368                                         ast_verb(3, "Ring pattern matched in range: %d to %d\n",
1369                                         (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
1370                                         (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
1371                                         distMatches++;
1372                                 }
1373                         }
1374
1375                         if (distMatches == 3) {
1376                                 /* The ring matches, set the context to whatever is for distinctive ring.. */
1377                                 ast_copy_string(p->context, S_OR(p->drings.ringContext[counter].contextData, p->defcontext), sizeof(p->context));
1378                                 ast_channel_context_set(chan, S_OR(p->drings.ringContext[counter].contextData, p->defcontext));
1379                                 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
1380                                 break;
1381                         }
1382                 }
1383         }
1384         /* Restore linear mode (if appropriate) for Caller*ID processing */
1385         dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
1386         restore_gains(p);
1387
1388         return 0;
1389 }
1390
1391 static int my_stop_callwait(void *pvt)
1392 {
1393         struct dahdi_pvt *p = pvt;
1394         p->callwaitingrepeat = 0;
1395         p->cidcwexpire = 0;
1396         p->cid_suppress_expire = 0;
1397
1398         return 0;
1399 }
1400
1401 static int send_callerid(struct dahdi_pvt *p);
1402 static int save_conference(struct dahdi_pvt *p);
1403 static int restore_conference(struct dahdi_pvt *p);
1404
1405 static int my_callwait(void *pvt)
1406 {
1407         struct dahdi_pvt *p = pvt;
1408         struct ast_format tmpfmt;
1409         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1410         if (p->cidspill) {
1411                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1412                 ast_free(p->cidspill);
1413         }
1414
1415         /*
1416          * SAS: Subscriber Alert Signal, 440Hz for 300ms
1417          * CAS: CPE Alert Signal, 2130Hz * 2750Hz sine waves
1418          */
1419         if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1420                 return -1;
1421         save_conference(p);
1422         /* Silence */
1423         memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1424         if (!p->callwaitrings && p->callwaitingcallerid) {
1425                 ast_gen_cas(p->cidspill, 1, 2400 + 680, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1426                 p->callwaitcas = 1;
1427                 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1428         } else {
1429                 ast_gen_cas(p->cidspill, 1, 2400, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1430                 p->callwaitcas = 0;
1431                 p->cidlen = 2400 + READ_SIZE * 4;
1432         }
1433         p->cidpos = 0;
1434         send_callerid(p);
1435
1436         return 0;
1437 }
1438
1439 static int my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
1440 {
1441         struct dahdi_pvt *p = pvt;
1442         struct ast_format tmpfmt;
1443
1444         ast_debug(2, "Starting cid spill\n");
1445
1446         if (p->cidspill) {
1447                 ast_log(LOG_WARNING, "cidspill already exists??\n");
1448                 ast_free(p->cidspill);
1449         }
1450
1451         if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1452                 if (cwcid == 0) {
1453                         p->cidlen = ast_callerid_generate(p->cidspill,
1454                                 caller->id.name.str,
1455                                 caller->id.number.str,
1456                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1457                 } else {
1458                         ast_verb(3, "CPE supports Call Waiting Caller*ID.  Sending '%s/%s'\n",
1459                                 caller->id.name.str, caller->id.number.str);
1460                         p->callwaitcas = 0;
1461                         p->cidcwexpire = 0;
1462                         p->cidlen = ast_callerid_callwaiting_generate(p->cidspill,
1463                                 caller->id.name.str,
1464                                 caller->id.number.str,
1465                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1466                         p->cidlen += READ_SIZE * 4;
1467                 }
1468                 p->cidpos = 0;
1469                 p->cid_suppress_expire = 0;
1470                 send_callerid(p);
1471         }
1472         return 0;
1473 }
1474
1475 static int my_dsp_reset_and_flush_digits(void *pvt)
1476 {
1477         struct dahdi_pvt *p = pvt;
1478         if (p->dsp)
1479                 ast_dsp_digitreset(p->dsp);
1480
1481         return 0;
1482 }
1483
1484 static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
1485 {
1486         struct dahdi_pvt *p = pvt;
1487
1488         if (p->channel == CHAN_PSEUDO)
1489                 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");
1490
1491         if (mode == ANALOG_DIGITMODE_DTMF) {
1492                 /* If we do hardware dtmf, no need for a DSP */
1493                 if (p->hardwaredtmf) {
1494                         if (p->dsp) {
1495                                 ast_dsp_free(p->dsp);
1496                                 p->dsp = NULL;
1497                         }
1498                         return 0;
1499                 }
1500
1501                 if (!p->dsp) {
1502                         p->dsp = ast_dsp_new();
1503                         if (!p->dsp) {
1504                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1505                                 return -1;
1506                         }
1507                 }
1508
1509                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
1510         } else if (mode == ANALOG_DIGITMODE_MF) {
1511                 if (!p->dsp) {
1512                         p->dsp = ast_dsp_new();
1513                         if (!p->dsp) {
1514                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
1515                                 return -1;
1516                         }
1517                 }
1518                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
1519         }
1520         return 0;
1521 }
1522
1523 static int dahdi_wink(struct dahdi_pvt *p, int index);
1524
1525 static int my_wink(void *pvt, enum analog_sub sub)
1526 {
1527         struct dahdi_pvt *p = pvt;
1528         int index = analogsub_to_dahdisub(sub);
1529         if (index != SUB_REAL) {
1530                 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
1531         }
1532         return dahdi_wink(p, index);
1533 }
1534
1535 static void wakeup_sub(struct dahdi_pvt *p, int a);
1536
1537 static int reset_conf(struct dahdi_pvt *p);
1538
1539 static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);
1540
1541 static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
1542 {
1543         struct ast_frame *f = *dest;
1544         struct dahdi_pvt *p = pvt;
1545         int idx = analogsub_to_dahdisub(analog_index);
1546
1547         ast_debug(1, "%s DTMF digit: 0x%02X '%c' on %s\n",
1548                 f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
1549                 f->subclass.integer, f->subclass.integer, ast_channel_name(ast));
1550
1551         if (f->subclass.integer == 'f') {
1552                 if (f->frametype == AST_FRAME_DTMF_END) {
1553                         /* Fax tone -- Handle and return NULL */
1554                         if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
1555                                 /* If faxbuffers are configured, use them for the fax transmission */
1556                                 if (p->usefaxbuffers && !p->bufferoverrideinuse) {
1557                                         struct dahdi_bufferinfo bi = {
1558                                                 .txbufpolicy = p->faxbuf_policy,
1559                                                 .bufsize = p->bufsize,
1560                                                 .numbufs = p->faxbuf_no
1561                                         };
1562                                         int res;
1563
1564                                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
1565                                                 ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast_channel_name(ast), strerror(errno));
1566                                         } else {
1567                                                 p->bufferoverrideinuse = 1;
1568                                         }
1569                                 }
1570                                 p->faxhandled = 1;
1571                                 if (p->dsp) {
1572                                         p->dsp_features &= ~DSP_FEATURE_FAX_DETECT;
1573                                         ast_dsp_set_features(p->dsp, p->dsp_features);
1574                                         ast_debug(1, "Disabling FAX tone detection on %s after tone received\n", ast_channel_name(ast));
1575                                 }
1576                                 if (strcmp(ast_channel_exten(ast), "fax")) {
1577                                         const char *target_context = S_OR(ast_channel_macrocontext(ast), ast_channel_context(ast));
1578
1579                                         /* We need to unlock 'ast' here because ast_exists_extension has the
1580                                          * potential to start autoservice on the channel. Such action is prone
1581                                          * to deadlock.
1582                                          */
1583                                         ast_mutex_unlock(&p->lock);
1584                                         ast_channel_unlock(ast);
1585                                         if (ast_exists_extension(ast, target_context, "fax", 1,
1586                                                 S_COR(ast_channel_caller(ast)->id.number.valid, ast_channel_caller(ast)->id.number.str, NULL))) {
1587                                                 ast_channel_lock(ast);
1588                                                 ast_mutex_lock(&p->lock);
1589                                                 ast_verb(3, "Redirecting %s to fax extension\n", ast_channel_name(ast));
1590                                                 /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
1591                                                 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
1592                                                 if (ast_async_goto(ast, target_context, "fax", 1))
1593                                                         ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(ast), target_context);
1594                                         } else {
1595                                                 ast_channel_lock(ast);
1596                                                 ast_mutex_lock(&p->lock);
1597                                                 ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
1598                                         }
1599                                 } else {
1600                                         ast_debug(1, "Already in a fax extension, not redirecting\n");
1601                                 }
1602                         } else {
1603                                 ast_debug(1, "Fax already handled\n");
1604                         }
1605                         dahdi_confmute(p, 0);
1606                 }
1607                 p->subs[idx].f.frametype = AST_FRAME_NULL;
1608                 p->subs[idx].f.subclass.integer = 0;
1609                 *dest = &p->subs[idx].f;
1610         }
1611 }
1612
1613 static void my_lock_private(void *pvt)
1614 {
1615         struct dahdi_pvt *p = pvt;
1616         ast_mutex_lock(&p->lock);
1617 }
1618
1619 static void my_unlock_private(void *pvt)
1620 {
1621         struct dahdi_pvt *p = pvt;
1622         ast_mutex_unlock(&p->lock);
1623 }
1624
1625 static void my_deadlock_avoidance_private(void *pvt)
1626 {
1627         struct dahdi_pvt *p = pvt;
1628
1629         DEADLOCK_AVOIDANCE(&p->lock);
1630 }
1631
1632 static struct ast_manager_event_blob *dahdichannel_to_ami(struct stasis_message *msg)
1633 {
1634         RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
1635         struct ast_channel_blob *obj = stasis_message_data(msg);
1636         struct ast_json *span, *channel;
1637
1638         channel_string = ast_manager_build_channel_state_string(obj->snapshot);
1639         if (!channel_string) {
1640                 return NULL;
1641         }
1642
1643         span = ast_json_object_get(obj->blob, "span");
1644         channel = ast_json_object_get(obj->blob, "channel");
1645
1646         return ast_manager_event_blob_create(EVENT_FLAG_CALL, "DAHDIChannel",
1647                 "%s"
1648                 "DAHDISpan: %d\r\n"
1649                 "DAHDIChannel: %s\r\n",
1650                 ast_str_buffer(channel_string),
1651                 (unsigned int)ast_json_integer_get(span),
1652                 ast_json_string_get(channel));
1653 }
1654
1655 STASIS_MESSAGE_TYPE_DEFN_LOCAL(dahdichannel_type,
1656         .to_ami = dahdichannel_to_ami,
1657         );
1658
1659 /*! \brief Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages */
1660 static void publish_dahdichannel(struct ast_channel *chan, int span, const char *dahdi_channel)
1661 {
1662         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
1663
1664         ast_assert(dahdi_channel != NULL);
1665
1666         blob = ast_json_pack("{s: i, s: s}",
1667                 "span", span,
1668                 "channel", dahdi_channel);
1669         if (!blob) {
1670                 return;
1671         }
1672
1673         ast_channel_publish_blob(chan, dahdichannel_type(), blob);
1674 }
1675
1676 /*!
1677  * \internal
1678  * \brief Post an AMI DAHDI channel association event.
1679  * \since 1.8
1680  *
1681  * \param p DAHDI private pointer
1682  * \param chan Channel associated with the private pointer
1683  *
1684  * \return Nothing
1685  */
1686 static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
1687 {
1688         char ch_name[20];
1689
1690         if (p->channel < CHAN_PSEUDO) {
1691                 /* No B channel */
1692                 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
1693         } else if (p->channel == CHAN_PSEUDO) {
1694                 /* Pseudo channel */
1695                 strcpy(ch_name, "pseudo");
1696         } else {
1697                 /* Real channel */
1698                 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
1699         }
1700         publish_dahdichannel(chan, p->span, ch_name);
1701 }
1702
1703 #ifdef HAVE_PRI
1704 /*!
1705  * \internal
1706  * \brief Post an AMI DAHDI channel association event.
1707  * \since 1.8
1708  *
1709  * \param pvt DAHDI private pointer
1710  * \param chan Channel associated with the private pointer
1711  *
1712  * \return Nothing
1713  */
1714 static void my_ami_channel_event(void *pvt, struct ast_channel *chan)
1715 {
1716         struct dahdi_pvt *p = pvt;
1717
1718         dahdi_ami_channel_event(p, chan);
1719 }
1720 #endif
1721
1722 /* linear_mode = 0 - turn linear mode off, >0 - turn linear mode on
1723 *       returns the last value of the linear setting
1724 */
1725 static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
1726 {
1727         struct dahdi_pvt *p = pvt;
1728         int oldval;
1729         int idx = analogsub_to_dahdisub(sub);
1730
1731         dahdi_setlinear(p->subs[idx].dfd, linear_mode);
1732         oldval = p->subs[idx].linear;
1733         p->subs[idx].linear = linear_mode ? 1 : 0;
1734         return oldval;
1735 }
1736
1737 static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
1738 {
1739         struct dahdi_pvt *p = pvt;
1740         int idx = analogsub_to_dahdisub(sub);
1741
1742         p->subs[idx].inthreeway = inthreeway;
1743 }
1744
1745 static int get_alarms(struct dahdi_pvt *p);
1746 static void handle_alarms(struct dahdi_pvt *p, int alms);
1747 static void my_get_and_handle_alarms(void *pvt)
1748 {
1749         int res;
1750         struct dahdi_pvt *p = pvt;
1751
1752         res = get_alarms(p);
1753         handle_alarms(p, res);
1754 }
1755
1756 static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
1757 {
1758         RAII_VAR(struct ast_channel *, bridged, ast_channel_bridge_peer(chan), ast_channel_cleanup);
1759
1760         if (bridged && ast_channel_tech(bridged) == &dahdi_tech) {
1761                 struct dahdi_pvt *p = ast_channel_tech_pvt(bridged);
1762
1763                 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
1764                         return p->sig_pvt;
1765                 }
1766         }
1767         return NULL;
1768 }
1769
1770 static int my_get_sub_fd(void *pvt, enum analog_sub sub)
1771 {
1772         struct dahdi_pvt *p = pvt;
1773         int dahdi_sub = analogsub_to_dahdisub(sub);
1774         return p->subs[dahdi_sub].dfd;
1775 }
1776
1777 static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
1778 {
1779         struct dahdi_pvt *p = pvt;
1780
1781         /* Choose proper cadence */
1782         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
1783                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
1784                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast_channel_name(ast), strerror(errno));
1785                 *cid_rings = cidrings[p->distinctivering - 1];
1786         } else {
1787                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
1788                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast_channel_name(ast), strerror(errno));
1789                 *cid_rings = p->sendcalleridafter;
1790         }
1791 }
1792
1793 static void my_set_alarm(void *pvt, int in_alarm)
1794 {
1795         struct dahdi_pvt *p = pvt;
1796
1797         p->inalarm = in_alarm;
1798 }
1799
1800 static void my_set_dialing(void *pvt, int is_dialing)
1801 {
1802         struct dahdi_pvt *p = pvt;
1803
1804         p->dialing = is_dialing;
1805 }
1806
1807 static void my_set_outgoing(void *pvt, int is_outgoing)
1808 {
1809         struct dahdi_pvt *p = pvt;
1810
1811         p->outgoing = is_outgoing;
1812 }
1813
1814 #if defined(HAVE_PRI) || defined(HAVE_SS7)
1815 static void my_set_digital(void *pvt, int is_digital)
1816 {
1817         struct dahdi_pvt *p = pvt;
1818
1819         p->digital = is_digital;
1820 }
1821 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
1822
1823 #if defined(HAVE_SS7)
1824 static void my_set_inservice(void *pvt, int is_inservice)
1825 {
1826         struct dahdi_pvt *p = pvt;
1827
1828         p->inservice = is_inservice;
1829 }
1830 #endif  /* defined(HAVE_SS7) */
1831
1832 #if defined(HAVE_SS7)
1833 static void my_set_locallyblocked(void *pvt, int is_blocked)
1834 {
1835         struct dahdi_pvt *p = pvt;
1836
1837         p->locallyblocked = is_blocked;
1838 }
1839 #endif  /* defined(HAVE_SS7) */
1840
1841 #if defined(HAVE_SS7)
1842 static void my_set_remotelyblocked(void *pvt, int is_blocked)
1843 {
1844         struct dahdi_pvt *p = pvt;
1845
1846         p->remotelyblocked = is_blocked;
1847 }
1848 #endif  /* defined(HAVE_SS7) */
1849
1850 static void my_set_ringtimeout(void *pvt, int ringt)
1851 {
1852         struct dahdi_pvt *p = pvt;
1853         p->ringt = ringt;
1854 }
1855
1856 static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
1857 {
1858         struct dahdi_pvt *p = pvt;
1859
1860         if (p->waitfordialtone && CANPROGRESSDETECT(p) && p->dsp) {
1861                 ast_debug(1, "Defer dialing for %dms or dialtone\n", p->waitfordialtone);
1862                 gettimeofday(&p->waitingfordt, NULL);
1863                 ast_setstate(ast, AST_STATE_OFFHOOK);
1864         }
1865 }
1866
1867 static int my_check_waitingfordt(void *pvt)
1868 {
1869         struct dahdi_pvt *p = pvt;
1870
1871         if (p->waitingfordt.tv_usec) {
1872                 return 1;
1873         }
1874
1875         return 0;
1876 }
1877
1878 static void my_set_confirmanswer(void *pvt, int flag)
1879 {
1880         struct dahdi_pvt *p = pvt;
1881         p->confirmanswer = flag;
1882 }
1883
1884 static int my_check_confirmanswer(void *pvt)
1885 {
1886         struct dahdi_pvt *p = pvt;
1887         if (p->confirmanswer) {
1888                 return 1;
1889         }
1890
1891         return 0;
1892 }
1893
1894 static void my_set_callwaiting(void *pvt, int callwaiting_enable)
1895 {
1896         struct dahdi_pvt *p = pvt;
1897
1898         p->callwaiting = callwaiting_enable;
1899 }
1900
1901 static void my_cancel_cidspill(void *pvt)
1902 {
1903         struct dahdi_pvt *p = pvt;
1904
1905         ast_free(p->cidspill);
1906         p->cidspill = NULL;
1907         restore_conference(p);
1908 }
1909
1910 static int my_confmute(void *pvt, int mute)
1911 {
1912         struct dahdi_pvt *p = pvt;
1913         return dahdi_confmute(p, mute);
1914 }
1915
1916 static void my_set_pulsedial(void *pvt, int flag)
1917 {
1918         struct dahdi_pvt *p = pvt;
1919         p->pulsedial = flag;
1920 }
1921
1922 static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
1923 {
1924         struct dahdi_pvt *p = pvt;
1925
1926         p->owner = new_owner;
1927 }
1928
1929 static const char *my_get_orig_dialstring(void *pvt)
1930 {
1931         struct dahdi_pvt *p = pvt;
1932
1933         return p->dialstring;
1934 }
1935
1936 static void my_increase_ss_count(void)
1937 {
1938         ast_mutex_lock(&ss_thread_lock);
1939         ss_thread_count++;
1940         ast_mutex_unlock(&ss_thread_lock);
1941 }
1942
1943 static void my_decrease_ss_count(void)
1944 {
1945         ast_mutex_lock(&ss_thread_lock);
1946         ss_thread_count--;
1947         ast_cond_signal(&ss_thread_complete);
1948         ast_mutex_unlock(&ss_thread_lock);
1949 }
1950
1951 static void my_all_subchannels_hungup(void *pvt)
1952 {
1953         struct dahdi_pvt *p = pvt;
1954         int res, law;
1955
1956         p->faxhandled = 0;
1957         p->didtdd = 0;
1958
1959         if (p->dsp) {
1960                 ast_dsp_free(p->dsp);
1961                 p->dsp = NULL;
1962         }
1963
1964         p->law = p->law_default;
1965         law = p->law_default;
1966         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
1967         if (res < 0)
1968                 ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
1969
1970         dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
1971
1972 #if 1
1973         {
1974         int i;
1975         p->owner = NULL;
1976         /* Cleanup owners here */
1977         for (i = 0; i < 3; i++) {
1978                 p->subs[i].owner = NULL;
1979         }
1980         }
1981 #endif
1982
1983         reset_conf(p);
1984         if (num_restart_pending == 0) {
1985                 restart_monitor();
1986         }
1987 }
1988
1989 static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);
1990
1991 static int my_conf_del(void *pvt, enum analog_sub sub)
1992 {
1993         struct dahdi_pvt *p = pvt;
1994         int x = analogsub_to_dahdisub(sub);
1995
1996         return conf_del(p, &p->subs[x], x);
1997 }
1998
1999 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);
2000
2001 static int my_conf_add(void *pvt, enum analog_sub sub)
2002 {
2003         struct dahdi_pvt *p = pvt;
2004         int x = analogsub_to_dahdisub(sub);
2005
2006         return conf_add(p, &p->subs[x], x, 0);
2007 }
2008
2009 static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);
2010
2011 static int my_complete_conference_update(void *pvt, int needconference)
2012 {
2013         struct dahdi_pvt *p = pvt;
2014         int needconf = needconference;
2015         int x;
2016         int useslavenative;
2017         struct dahdi_pvt *slave = NULL;
2018
2019         useslavenative = isslavenative(p, &slave);
2020
2021         /* If we have a slave, add him to our conference now. or DAX
2022            if this is slave native */
2023         for (x = 0; x < MAX_SLAVES; x++) {
2024                 if (p->slaves[x]) {
2025                         if (useslavenative)
2026                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
2027                         else {
2028                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
2029                                 needconf++;
2030                         }
2031                 }
2032         }
2033         /* If we're supposed to be in there, do so now */
2034         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
2035                 if (useslavenative)
2036                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
2037                 else {
2038                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
2039                         needconf++;
2040                 }
2041         }
2042         /* If we have a master, add ourselves to his conference */
2043         if (p->master) {
2044                 if (isslavenative(p->master, NULL)) {
2045                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
2046                 } else {
2047                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
2048                 }
2049         }
2050         if (!needconf) {
2051                 /* Nobody is left (or should be left) in our conference.
2052                    Kill it. */
2053                 p->confno = -1;
2054         }
2055
2056         return 0;
2057 }
2058
2059 static int check_for_conference(struct dahdi_pvt *p);
2060
2061 static int my_check_for_conference(void *pvt)
2062 {
2063         struct dahdi_pvt *p = pvt;
2064         return check_for_conference(p);
2065 }
2066
2067 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)
2068 {
2069         struct dahdi_pvt *p = pvt;
2070         int da, db;
2071         int tchan;
2072         int tinthreeway;
2073
2074         da = analogsub_to_dahdisub(a);
2075         db = analogsub_to_dahdisub(b);
2076
2077         tchan = p->subs[da].chan;
2078         p->subs[da].chan = p->subs[db].chan;
2079         p->subs[db].chan = tchan;
2080
2081         tinthreeway = p->subs[da].inthreeway;
2082         p->subs[da].inthreeway = p->subs[db].inthreeway;
2083         p->subs[db].inthreeway = tinthreeway;
2084
2085         p->subs[da].owner = ast_a;
2086         p->subs[db].owner = ast_b;
2087
2088         if (ast_a)
2089                 ast_channel_set_fd(ast_a, 0, p->subs[da].dfd);
2090         if (ast_b)
2091                 ast_channel_set_fd(ast_b, 0, p->subs[db].dfd);
2092
2093         wakeup_sub(p, a);
2094         wakeup_sub(p, b);
2095
2096         return;
2097 }
2098
2099 /*!
2100  * \internal
2101  * \brief performs duties of dahdi_new, but also removes and possibly unbinds (if callid_created is 1) before returning
2102  * \note this variant of dahdi should only be used in conjunction with ast_callid_threadstorage_auto()
2103  *
2104  * \param callid_created value returned from ast_callid_threadstorage_auto()
2105  */
2106 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);
2107
2108 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);
2109
2110 static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
2111 {
2112         struct ast_callid *callid = NULL;
2113         int callid_created = ast_callid_threadstorage_auto(&callid);
2114         struct dahdi_pvt *p = pvt;
2115         int dsub = analogsub_to_dahdisub(sub);
2116
2117         return dahdi_new_callid_clean(p, state, startpbx, dsub, 0, requestor ? ast_channel_linkedid(requestor) : "", callid, callid_created);
2118 }
2119
2120 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2121 static int dahdi_setlaw(int dfd, int law)
2122 {
2123         int res;
2124         res = ioctl(dfd, DAHDI_SETLAW, &law);
2125         if (res)
2126                 return res;
2127         return 0;
2128 }
2129 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2130
2131 #if defined(HAVE_PRI)
2132 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)
2133 {
2134         struct dahdi_pvt *p = pvt;
2135         int audio;
2136         int newlaw = -1;
2137         struct ast_callid *callid = NULL;
2138         int callid_created = ast_callid_threadstorage_auto(&callid);
2139
2140         switch (p->sig) {
2141         case SIG_PRI_LIB_HANDLE_CASES:
2142                 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
2143                         /* PRI nobch pseudo channel.  Does not handle ioctl(DAHDI_AUDIOMODE) */
2144                         break;
2145                 }
2146                 /* Fall through */
2147         default:
2148                 /* Set to audio mode at this point */
2149                 audio = 1;
2150                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1) {
2151                         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
2152                                 p->channel, audio, strerror(errno));
2153                 }
2154                 break;
2155         }
2156
2157         if (law != SIG_PRI_DEFLAW) {
2158                 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
2159         }
2160
2161         ast_copy_string(p->exten, exten, sizeof(p->exten));
2162
2163         switch (law) {
2164                 case SIG_PRI_DEFLAW:
2165                         newlaw = 0;
2166                         break;
2167                 case SIG_PRI_ALAW:
2168                         newlaw = DAHDI_LAW_ALAW;
2169                         break;
2170                 case SIG_PRI_ULAW:
2171                         newlaw = DAHDI_LAW_MULAW;
2172                         break;
2173         }
2174
2175         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, requestor ? ast_channel_linkedid(requestor) : "", callid, callid_created);
2176 }
2177 #endif  /* defined(HAVE_PRI) */
2178
2179 static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law);
2180
2181 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2182 /*!
2183  * \internal
2184  * \brief Open the PRI/SS7 channel media path.
2185  * \since 1.8
2186  *
2187  * \param p Channel private control structure.
2188  *
2189  * \return Nothing
2190  */
2191 static void my_pri_ss7_open_media(void *p)
2192 {
2193         struct dahdi_pvt *pvt = p;
2194         int res;
2195         int dfd;
2196         int set_val;
2197
2198         dfd = pvt->subs[SUB_REAL].dfd;
2199
2200         /* Open the media path. */
2201         set_val = 1;
2202         res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
2203         if (res < 0) {
2204                 ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n",
2205                         pvt->channel, strerror(errno));
2206         }
2207
2208         /* Set correct companding law for this call. */
2209         res = dahdi_setlaw(dfd, pvt->law);
2210         if (res < 0) {
2211                 ast_log(LOG_WARNING, "Unable to set law on channel %d\n", pvt->channel);
2212         }
2213
2214         /* Set correct gain for this call. */
2215         if (pvt->digital) {
2216                 res = set_actual_gain(dfd, 0, 0, pvt->rxdrc, pvt->txdrc, pvt->law);
2217         } else {
2218                 res = set_actual_gain(dfd, pvt->rxgain, pvt->txgain, pvt->rxdrc, pvt->txdrc,
2219                         pvt->law);
2220         }
2221         if (res < 0) {
2222                 ast_log(LOG_WARNING, "Unable to set gains on channel %d\n", pvt->channel);
2223         }
2224
2225         if (pvt->dsp_features && pvt->dsp) {
2226                 ast_dsp_set_features(pvt->dsp, pvt->dsp_features);
2227                 pvt->dsp_features = 0;
2228         }
2229 }
2230 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2231
2232 #if defined(HAVE_PRI)
2233 /*!
2234  * \internal
2235  * \brief Ask DAHDI to dial the given dial string.
2236  * \since 1.8.11
2237  *
2238  * \param p Channel private control structure.
2239  * \param dial_string String to pass to DAHDI to dial.
2240  *
2241  * \note The channel private lock needs to be held when calling.
2242  *
2243  * \return Nothing
2244  */
2245 static void my_pri_dial_digits(void *p, const char *dial_string)
2246 {
2247         char dial_str[DAHDI_MAX_DTMF_BUF];
2248         struct dahdi_pvt *pvt = p;
2249         int res;
2250
2251         snprintf(dial_str, sizeof(dial_str), "T%s", dial_string);
2252         res = dahdi_dial_str(pvt, DAHDI_DIAL_OP_APPEND, dial_str);
2253         if (!res) {
2254                 pvt->dialing = 1;
2255         }
2256 }
2257 #endif  /* defined(HAVE_PRI) */
2258
2259 static int unalloc_sub(struct dahdi_pvt *p, int x);
2260
2261 static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
2262 {
2263         struct dahdi_pvt *p = pvt;
2264
2265         return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
2266 }
2267
2268 static int alloc_sub(struct dahdi_pvt *p, int x);
2269
2270 static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
2271 {
2272         struct dahdi_pvt *p = pvt;
2273
2274         return alloc_sub(p, analogsub_to_dahdisub(analogsub));
2275 }
2276
2277 static int has_voicemail(struct dahdi_pvt *p);
2278
2279 static int my_has_voicemail(void *pvt)
2280 {
2281         struct dahdi_pvt *p = pvt;
2282
2283         return has_voicemail(p);
2284 }
2285
2286 static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
2287 {
2288         struct dahdi_pvt *p = pvt;
2289         int index;
2290
2291         index = analogsub_to_dahdisub(sub);
2292
2293         return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
2294 }
2295
2296 static enum analog_event dahdievent_to_analogevent(int event)
2297 {
2298         enum analog_event res;
2299
2300         switch (event) {
2301         case DAHDI_EVENT_ONHOOK:
2302                 res = ANALOG_EVENT_ONHOOK;
2303                 break;
2304         case DAHDI_EVENT_RINGOFFHOOK:
2305                 res = ANALOG_EVENT_RINGOFFHOOK;
2306                 break;
2307         case DAHDI_EVENT_WINKFLASH:
2308                 res = ANALOG_EVENT_WINKFLASH;
2309                 break;
2310         case DAHDI_EVENT_ALARM:
2311                 res = ANALOG_EVENT_ALARM;
2312                 break;
2313         case DAHDI_EVENT_NOALARM:
2314                 res = ANALOG_EVENT_NOALARM;
2315                 break;
2316         case DAHDI_EVENT_DIALCOMPLETE:
2317                 res = ANALOG_EVENT_DIALCOMPLETE;
2318                 break;
2319         case DAHDI_EVENT_RINGERON:
2320                 res = ANALOG_EVENT_RINGERON;
2321                 break;
2322         case DAHDI_EVENT_RINGEROFF:
2323                 res = ANALOG_EVENT_RINGEROFF;
2324                 break;
2325         case DAHDI_EVENT_HOOKCOMPLETE:
2326                 res = ANALOG_EVENT_HOOKCOMPLETE;
2327                 break;
2328         case DAHDI_EVENT_PULSE_START:
2329                 res = ANALOG_EVENT_PULSE_START;
2330                 break;
2331         case DAHDI_EVENT_POLARITY:
2332                 res = ANALOG_EVENT_POLARITY;
2333                 break;
2334         case DAHDI_EVENT_RINGBEGIN:
2335                 res = ANALOG_EVENT_RINGBEGIN;
2336                 break;
2337         case DAHDI_EVENT_EC_DISABLED:
2338                 res = ANALOG_EVENT_EC_DISABLED;
2339                 break;
2340         case DAHDI_EVENT_REMOVED:
2341                 res = ANALOG_EVENT_REMOVED;
2342                 break;
2343         case DAHDI_EVENT_NEONMWI_ACTIVE:
2344                 res = ANALOG_EVENT_NEONMWI_ACTIVE;
2345                 break;
2346         case DAHDI_EVENT_NEONMWI_INACTIVE:
2347                 res = ANALOG_EVENT_NEONMWI_INACTIVE;
2348                 break;
2349 #ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2350         case DAHDI_EVENT_TX_CED_DETECTED:
2351                 res = ANALOG_EVENT_TX_CED_DETECTED;
2352                 break;
2353         case DAHDI_EVENT_RX_CED_DETECTED:
2354                 res = ANALOG_EVENT_RX_CED_DETECTED;
2355                 break;
2356         case DAHDI_EVENT_EC_NLP_DISABLED:
2357                 res = ANALOG_EVENT_EC_NLP_DISABLED;
2358                 break;
2359         case DAHDI_EVENT_EC_NLP_ENABLED:
2360                 res = ANALOG_EVENT_EC_NLP_ENABLED;
2361                 break;
2362 #endif
2363         case DAHDI_EVENT_PULSEDIGIT:
2364                 res = ANALOG_EVENT_PULSEDIGIT;
2365                 break;
2366         case DAHDI_EVENT_DTMFDOWN:
2367                 res = ANALOG_EVENT_DTMFDOWN;
2368                 break;
2369         case DAHDI_EVENT_DTMFUP:
2370                 res = ANALOG_EVENT_DTMFUP;
2371                 break;
2372         default:
2373                 switch(event & 0xFFFF0000) {
2374                 case DAHDI_EVENT_PULSEDIGIT:
2375                 case DAHDI_EVENT_DTMFDOWN:
2376                 case DAHDI_EVENT_DTMFUP:
2377                         /* The event includes a digit number in the low word.
2378                          * Converting it to a 'enum analog_event' would remove
2379                          * that information. Thus it is returned as-is.
2380                          */
2381                         return event;
2382                 }
2383
2384                 res = ANALOG_EVENT_ERROR;
2385                 break;
2386         }
2387
2388         return res;
2389 }
2390
2391 static inline int dahdi_wait_event(int fd);
2392
2393 static int my_wait_event(void *pvt)
2394 {
2395         struct dahdi_pvt *p = pvt;
2396
2397         return dahdi_wait_event(p->subs[SUB_REAL].dfd);
2398 }
2399
2400 static int my_get_event(void *pvt)
2401 {
2402         struct dahdi_pvt *p = pvt;
2403         int res;
2404
2405         if (p->fake_event) {
2406                 res = p->fake_event;
2407                 p->fake_event = 0;
2408         } else
2409                 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
2410
2411         return dahdievent_to_analogevent(res);
2412 }
2413
2414 static int my_is_off_hook(void *pvt)
2415 {
2416         struct dahdi_pvt *p = pvt;
2417         int res;
2418         struct dahdi_params par;
2419
2420         memset(&par, 0, sizeof(par));
2421
2422         if (p->subs[SUB_REAL].dfd > -1)
2423                 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
2424         else {
2425                 /* Assume not off hook on CVRS */
2426                 res = 0;
2427                 par.rxisoffhook = 0;
2428         }
2429         if (res) {
2430                 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
2431         }
2432
2433         if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
2434                 /* When "onhook" that means no battery on the line, and thus
2435                 it is out of service..., if it's on a TDM card... If it's a channel
2436                 bank, there is no telling... */
2437                 return (par.rxbits > -1) || par.rxisoffhook;
2438         }
2439
2440         return par.rxisoffhook;
2441 }
2442
2443 static int my_set_echocanceller(void *pvt, int enable)
2444 {
2445         struct dahdi_pvt *p = pvt;
2446
2447         if (enable)
2448                 dahdi_ec_enable(p);
2449         else
2450                 dahdi_ec_disable(p);
2451
2452         return 0;
2453 }
2454
2455 static int dahdi_ring_phone(struct dahdi_pvt *p);
2456
2457 static int my_ring(void *pvt)
2458 {
2459         struct dahdi_pvt *p = pvt;
2460
2461         return dahdi_ring_phone(p);
2462 }
2463
2464 static int my_flash(void *pvt)
2465 {
2466         struct dahdi_pvt *p = pvt;
2467         int func = DAHDI_FLASH;
2468         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
2469 }
2470
2471 static inline int dahdi_set_hook(int fd, int hs);
2472
2473 static int my_off_hook(void *pvt)
2474 {
2475         struct dahdi_pvt *p = pvt;
2476         return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
2477 }
2478
2479 static void my_set_needringing(void *pvt, int value)
2480 {
2481         struct dahdi_pvt *p = pvt;
2482         p->subs[SUB_REAL].needringing = value;
2483 }
2484
2485 static void my_set_polarity(void *pvt, int value)
2486 {
2487         struct dahdi_pvt *p = pvt;
2488
2489         if (p->channel == CHAN_PSEUDO) {
2490                 return;
2491         }
2492         p->polarity = value;
2493         ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETPOLARITY, &value);
2494 }
2495
2496 static void my_start_polarityswitch(void *pvt)
2497 {
2498         struct dahdi_pvt *p = pvt;
2499
2500         if (p->answeronpolarityswitch || p->hanguponpolarityswitch) {
2501                 my_set_polarity(pvt, 0);
2502         }
2503 }
2504
2505 static void my_answer_polarityswitch(void *pvt)
2506 {
2507         struct dahdi_pvt *p = pvt;
2508
2509         if (!p->answeronpolarityswitch) {
2510                 return;
2511         }
2512
2513         my_set_polarity(pvt, 1);
2514 }
2515
2516 static void my_hangup_polarityswitch(void *pvt)
2517 {
2518         struct dahdi_pvt *p = pvt;
2519
2520         if (!p->hanguponpolarityswitch) {
2521                 return;
2522         }
2523
2524         if (p->answeronpolarityswitch) {
2525                 my_set_polarity(pvt, 0);
2526         } else {
2527                 my_set_polarity(pvt, 1);
2528         }
2529 }
2530
2531 static int my_start(void *pvt)
2532 {
2533         struct dahdi_pvt *p = pvt;
2534         int x = DAHDI_START;
2535
2536         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
2537 }
2538
2539 static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
2540 {
2541         struct dahdi_pvt *p = pvt;
2542
2543         if (dop->op != ANALOG_DIAL_OP_REPLACE) {
2544                 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
2545                 return -1;
2546         }
2547
2548         if (sub != ANALOG_SUB_REAL) {
2549                 ast_log(LOG_ERROR, "Trying to dial_digits '%s' on channel %d subchannel %d\n",
2550                         dop->dialstr, p->channel, sub);
2551                 return -1;
2552         }
2553
2554         return dahdi_dial_str(p, DAHDI_DIAL_OP_REPLACE, dop->dialstr);
2555 }
2556
2557 static void dahdi_train_ec(struct dahdi_pvt *p);
2558
2559 static int my_train_echocanceller(void *pvt)
2560 {
2561         struct dahdi_pvt *p = pvt;
2562
2563         dahdi_train_ec(p);
2564
2565         return 0;
2566 }
2567
2568 static int my_is_dialing(void *pvt, enum analog_sub sub)
2569 {
2570         struct dahdi_pvt *p = pvt;
2571         int index;
2572         int x;
2573
2574         index = analogsub_to_dahdisub(sub);
2575
2576         if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
2577                 ast_debug(1, "DAHDI_DIALING ioctl failed!\n");
2578                 return -1;
2579         }
2580
2581         return x;
2582 }
2583
2584 static int my_on_hook(void *pvt)
2585 {
2586         struct dahdi_pvt *p = pvt;
2587         return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
2588 }
2589
2590 #if defined(HAVE_PRI)
2591 static void my_pri_fixup_chans(void *chan_old, void *chan_new)
2592 {
2593         struct dahdi_pvt *old_chan = chan_old;
2594         struct dahdi_pvt *new_chan = chan_new;
2595
2596         new_chan->owner = old_chan->owner;
2597         old_chan->owner = NULL;
2598         if (new_chan->owner) {
2599                 ast_channel_tech_pvt_set(new_chan->owner, new_chan);
2600                 ast_channel_internal_fd_set(new_chan->owner, 0, new_chan->subs[SUB_REAL].dfd);
2601                 new_chan->subs[SUB_REAL].owner = old_chan->subs[SUB_REAL].owner;
2602                 old_chan->subs[SUB_REAL].owner = NULL;
2603         }
2604         /* Copy any DSP that may be present */
2605         new_chan->dsp = old_chan->dsp;
2606         new_chan->dsp_features = old_chan->dsp_features;
2607         old_chan->dsp = NULL;
2608         old_chan->dsp_features = 0;
2609
2610         /* Transfer flags from the old channel. */
2611         new_chan->dialing = old_chan->dialing;
2612         new_chan->digital = old_chan->digital;
2613         new_chan->outgoing = old_chan->outgoing;
2614         old_chan->dialing = 0;
2615         old_chan->digital = 0;
2616         old_chan->outgoing = 0;
2617
2618         /* More stuff to transfer to the new channel. */
2619         new_chan->law = old_chan->law;
2620         strcpy(new_chan->dialstring, old_chan->dialstring);
2621 }
2622 #endif  /* defined(HAVE_PRI) */
2623
2624 #if defined(HAVE_PRI)
2625 static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
2626 {
2627         switch (tone) {
2628         case SIG_PRI_TONE_RINGTONE:
2629                 return DAHDI_TONE_RINGTONE;
2630         case SIG_PRI_TONE_STUTTER:
2631                 return DAHDI_TONE_STUTTER;
2632         case SIG_PRI_TONE_CONGESTION:
2633                 return DAHDI_TONE_CONGESTION;
2634         case SIG_PRI_TONE_DIALTONE:
2635                 return DAHDI_TONE_DIALTONE;
2636         case SIG_PRI_TONE_DIALRECALL:
2637                 return DAHDI_TONE_DIALRECALL;
2638         case SIG_PRI_TONE_INFO:
2639                 return DAHDI_TONE_INFO;
2640         case SIG_PRI_TONE_BUSY:
2641                 return DAHDI_TONE_BUSY;
2642         default:
2643                 return -1;
2644         }
2645 }
2646 #endif  /* defined(HAVE_PRI) */
2647
2648 #if defined(HAVE_PRI)
2649 static void pri_destroy_span(struct sig_pri_span *pri);
2650
2651 static void my_handle_dchan_exception(struct sig_pri_span *pri, int index)
2652 {
2653         int x;
2654
2655         ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
2656         switch (x) {
2657         case DAHDI_EVENT_NONE:
2658                 break;
2659         case DAHDI_EVENT_ALARM:
2660         case DAHDI_EVENT_NOALARM:
2661                 if (sig_pri_is_alarm_ignored(pri)) {
2662                         break;
2663                 }
2664                 /* Fall through */
2665         default:
2666                 ast_log(LOG_NOTICE, "Got DAHDI event: %s (%d) on D-channel of span %d\n",
2667                         event2str(x), x, pri->span);
2668                 break;
2669         }
2670         /* Keep track of alarm state */
2671         switch (x) {
2672         case DAHDI_EVENT_ALARM:
2673                 pri_event_alarm(pri, index, 0);
2674                 break;
2675         case DAHDI_EVENT_NOALARM:
2676                 pri_event_noalarm(pri, index, 0);
2677                 break;
2678         case DAHDI_EVENT_REMOVED:
2679                 pri_destroy_span(pri);
2680                 break;
2681         default:
2682                 break;
2683         }
2684 }
2685 #endif  /* defined(HAVE_PRI) */
2686
2687 #if defined(HAVE_PRI)
2688 static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
2689 {
2690         struct dahdi_pvt *p = pvt;
2691
2692         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
2693 }
2694 #endif  /* defined(HAVE_PRI) */
2695
2696 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2697 /*!
2698  * \internal
2699  * \brief Set the caller id information.
2700  * \since 1.8
2701  *
2702  * \param pvt DAHDI private structure
2703  * \param caller Caller-id information to set.
2704  *
2705  * \return Nothing
2706  */
2707 static void my_set_callerid(void *pvt, const struct ast_party_caller *caller)
2708 {
2709         struct dahdi_pvt *p = pvt;
2710
2711         ast_copy_string(p->cid_num,
2712                 S_COR(caller->id.number.valid, caller->id.number.str, ""),
2713                 sizeof(p->cid_num));
2714         ast_copy_string(p->cid_name,
2715                 S_COR(caller->id.name.valid, caller->id.name.str, ""),
2716                 sizeof(p->cid_name));
2717         ast_copy_string(p->cid_subaddr,
2718                 S_COR(caller->id.subaddress.valid, caller->id.subaddress.str, ""),
2719                 sizeof(p->cid_subaddr));
2720         p->cid_ton = caller->id.number.plan;
2721         p->callingpres = ast_party_id_presentation(&caller->id);
2722         if (caller->id.tag) {
2723                 ast_copy_string(p->cid_tag, caller->id.tag, sizeof(p->cid_tag));
2724         }
2725         ast_copy_string(p->cid_ani,
2726                 S_COR(caller->ani.number.valid, caller->ani.number.str, ""),
2727                 sizeof(p->cid_ani));
2728         p->cid_ani2 = caller->ani2;
2729 }
2730 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2731
2732 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2733 /*!
2734  * \internal
2735  * \brief Set the Dialed Number Identifier.
2736  * \since 1.8
2737  *
2738  * \param pvt DAHDI private structure
2739  * \param dnid Dialed Number Identifier string.
2740  *
2741  * \return Nothing
2742  */
2743 static void my_set_dnid(void *pvt, const char *dnid)
2744 {
2745         struct dahdi_pvt *p = pvt;
2746
2747         ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
2748 }
2749 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2750
2751 #if defined(HAVE_PRI)
2752 /*!
2753  * \internal
2754  * \brief Set the Redirecting Directory Number Information Service (RDNIS).
2755  * \since 1.8
2756  *
2757  * \param pvt DAHDI private structure
2758  * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
2759  *
2760  * \return Nothing
2761  */
2762 static void my_set_rdnis(void *pvt, const char *rdnis)
2763 {
2764         struct dahdi_pvt *p = pvt;
2765
2766         ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
2767 }
2768 #endif  /* defined(HAVE_PRI) */
2769
2770 #if defined(HAVE_PRI)
2771 /*!
2772  * \internal
2773  * \brief Make a dialstring for native ISDN CC to recall properly.
2774  * \since 1.8
2775  *
2776  * \param priv Channel private control structure.
2777  * \param buf Where to put the modified dialstring.
2778  * \param buf_size Size of modified dialstring buffer.
2779  *
2780  * \details
2781  * original dialstring:
2782  * DAHDI/[i<span>-](g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2783  *
2784  * The modified dialstring will have prefixed the channel-group section
2785  * with the ISDN channel restriction.
2786  *
2787  * buf:
2788  * DAHDI/i<span>-(g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
2789  *
2790  * The routine will check to see if the ISDN channel restriction is already
2791  * in the original dialstring.
2792  *
2793  * \return Nothing
2794  */
2795 static void my_pri_make_cc_dialstring(void *priv, char *buf, size_t buf_size)
2796 {
2797         char *dial;
2798         struct dahdi_pvt *pvt;
2799         AST_DECLARE_APP_ARGS(args,
2800                 AST_APP_ARG(tech);      /* channel technology token */
2801                 AST_APP_ARG(group);     /* channel/group token */
2802                 //AST_APP_ARG(ext);     /* extension token */
2803                 //AST_APP_ARG(opts);    /* options token */
2804                 //AST_APP_ARG(other);   /* Any remining unused arguments */
2805         );
2806
2807         pvt = priv;
2808         dial = ast_strdupa(pvt->dialstring);
2809         AST_NONSTANDARD_APP_ARGS(args, dial, '/');
2810         if (!args.tech) {
2811                 ast_copy_string(buf, pvt->dialstring, buf_size);
2812                 return;
2813         }
2814         if (!args.group) {
2815                 /* Append the ISDN span channel restriction to the dialstring. */
2816                 snprintf(buf, buf_size, "%s/i%d-", args.tech, pvt->pri->span);
2817                 return;
2818         }
2819         if (isdigit(args.group[0]) || args.group[0] == 'i' || strchr(args.group, '!')) {
2820                 /* The ISDN span channel restriction is not needed or already
2821                  * in the dialstring. */
2822                 ast_copy_string(buf, pvt->dialstring, buf_size);
2823                 return;
2824         }
2825         /* Insert the ISDN span channel restriction into the dialstring. */
2826         snprintf(buf, buf_size, "%s/i%d-%s", args.tech, pvt->pri->span, args.group);
2827 }
2828 #endif  /* defined(HAVE_PRI) */
2829
2830 #if defined(HAVE_PRI)
2831 /*!
2832  * \internal
2833  * \brief Reevaluate the PRI span device state.
2834  * \since 1.8
2835  *
2836  * \param pri Asterisk D channel control structure.
2837  *
2838  * \return Nothing
2839  *
2840  * \note Assumes the pri->lock is already obtained.
2841  */
2842 static void dahdi_pri_update_span_devstate(struct sig_pri_span *pri)
2843 {
2844         unsigned idx;
2845         unsigned num_b_chans;   /* Number of B channels provisioned on the span. */
2846         unsigned in_use;                /* Number of B channels in use on the span. */
2847         unsigned in_alarm;              /* TRUE if the span is in alarm condition. */
2848         enum ast_device_state new_state;
2849
2850         /* Count the number of B channels and the number of B channels in use. */
2851         num_b_chans = 0;
2852         in_use = 0;
2853         in_alarm = 1;
2854         for (idx = pri->numchans; idx--;) {
2855                 if (pri->pvts[idx] && !pri->pvts[idx]->no_b_channel) {
2856                         /* This is a B channel interface. */
2857                         ++num_b_chans;
2858                         if (!sig_pri_is_chan_available(pri->pvts[idx])) {
2859                                 ++in_use;
2860                         }
2861                         if (!pri->pvts[idx]->inalarm) {
2862                                 /* There is a channel that is not in alarm. */
2863                                 in_alarm = 0;
2864                         }
2865                 }
2866         }
2867
2868         /* Update the span congestion device state and report any change. */
2869         if (in_alarm) {
2870                 new_state = AST_DEVICE_UNAVAILABLE;
2871         } else {
2872                 new_state = num_b_chans == in_use ? AST_DEVICE_BUSY : AST_DEVICE_NOT_INUSE;
2873         }
2874         if (pri->congestion_devstate != new_state) {
2875                 pri->congestion_devstate = new_state;
2876                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/congestion", pri->span);
2877         }
2878 #if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
2879         /* Update the span threshold device state and report any change. */
2880         if (in_alarm) {
2881                 new_state = AST_DEVICE_UNAVAILABLE;
2882         } else if (!in_use) {
2883                 new_state = AST_DEVICE_NOT_INUSE;
2884         } else if (!pri->user_busy_threshold) {
2885                 new_state = in_use < num_b_chans ? AST_DEVICE_INUSE : AST_DEVICE_BUSY;
2886         } else {
2887                 new_state = in_use < pri->user_busy_threshold ? AST_DEVICE_INUSE
2888                         : AST_DEVICE_BUSY;
2889         }
2890         if (pri->threshold_devstate != new_state) {
2891                 pri->threshold_devstate = new_state;
2892                 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/threshold", pri->span);
2893         }
2894 #endif  /* defined(THRESHOLD_DEVSTATE_PLACEHOLDER) */
2895 }
2896 #endif  /* defined(HAVE_PRI) */
2897
2898 #if defined(HAVE_PRI)
2899 /*!
2900  * \internal
2901  * \brief Reference this module.
2902  * \since 1.8
2903  *
2904  * \return Nothing
2905  */
2906 static void my_module_ref(void)
2907 {
2908         ast_module_ref(ast_module_info->self);
2909 }
2910 #endif  /* defined(HAVE_PRI) */
2911
2912 #if defined(HAVE_PRI)
2913 /*!
2914  * \internal
2915  * \brief Unreference this module.
2916  * \since 1.8
2917  *
2918  * \return Nothing
2919  */
2920 static void my_module_unref(void)
2921 {
2922         ast_module_unref(ast_module_info->self);
2923 }
2924 #endif  /* defined(HAVE_PRI) */
2925
2926 #if defined(HAVE_PRI)
2927 #if defined(HAVE_PRI_CALL_WAITING)
2928 static void my_pri_init_config(void *priv, struct sig_pri_span *pri);
2929 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
2930 static int dahdi_new_pri_nobch_channel(struct sig_pri_span *pri);
2931
2932 struct sig_pri_callback sig_pri_callbacks =
2933 {
2934         .handle_dchan_exception = my_handle_dchan_exception,
2935         .play_tone = my_pri_play_tone,
2936         .set_echocanceller = my_set_echocanceller,
2937         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
2938         .lock_private = my_lock_private,
2939         .unlock_private = my_unlock_private,
2940         .deadlock_avoidance_private = my_deadlock_avoidance_private,
2941         .new_ast_channel = my_new_pri_ast_channel,
2942         .fixup_chans = my_pri_fixup_chans,
2943         .set_alarm = my_set_alarm,
2944         .set_dialing = my_set_dialing,
2945         .set_outgoing = my_set_outgoing,
2946         .set_digital = my_set_digital,
2947         .set_callerid = my_set_callerid,
2948         .set_dnid = my_set_dnid,
2949         .set_rdnis = my_set_rdnis,
2950         .new_nobch_intf = dahdi_new_pri_nobch_channel,
2951 #if defined(HAVE_PRI_CALL_WAITING)
2952         .init_config = my_pri_init_config,
2953 #endif  /* defined(HAVE_PRI_CALL_WAITING) */
2954         .get_orig_dialstring = my_get_orig_dialstring,
2955         .make_cc_dialstring = my_pri_make_cc_dialstring,
2956         .update_span_devstate = dahdi_pri_update_span_devstate,
2957         .module_ref = my_module_ref,
2958         .module_unref = my_module_unref,
2959         .dial_digits = my_pri_dial_digits,
2960         .open_media = my_pri_ss7_open_media,
2961         .ami_channel_event = my_ami_channel_event,
2962 };
2963 #endif  /* defined(HAVE_PRI) */
2964
2965 #if defined(HAVE_SS7)
2966 /*!
2967  * \internal
2968  * \brief Handle the SS7 link exception.
2969  * \since 1.8
2970  *
2971  * \param linkset Controlling linkset for the channel.
2972  * \param which Link index of the signaling channel.
2973  *
2974  * \return Nothing
2975  */
2976 static void my_handle_link_exception(struct sig_ss7_linkset *linkset, int which)
2977 {
2978         int event;
2979
2980         if (ioctl(linkset->fds[which], DAHDI_GETEVENT, &event)) {
2981                 ast_log(LOG_ERROR, "SS7: Error in exception retrieval on span %d/%d!\n",
2982                         linkset->span, which);
2983                 return;
2984         }
2985         switch (event) {
2986         case DAHDI_EVENT_NONE:
2987                 break;
2988         case DAHDI_EVENT_ALARM:
2989                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
2990                         event2str(event), event, linkset->span, which);
2991                 sig_ss7_link_alarm(linkset, which);
2992                 break;
2993         case DAHDI_EVENT_NOALARM:
2994                 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
2995                         event2str(event), event, linkset->span, which);
2996                 sig_ss7_link_noalarm(linkset, which);
2997                 break;
2998         default:
2999                 ast_log(LOG_NOTICE, "SS7 got event: %s(%d) on span %d/%d\n",
3000                         event2str(event), event, linkset->span, which);
3001                 break;
3002         }
3003 }
3004 #endif  /* defined(HAVE_SS7) */
3005
3006 #if defined(HAVE_SS7)
3007 static void my_ss7_set_loopback(void *pvt, int enable)
3008 {
3009         struct dahdi_pvt *p = pvt;
3010
3011         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_LOOPBACK, &enable)) {
3012                 ast_log(LOG_WARNING, "Unable to set loopback on channel %d: %s\n", p->channel,
3013                         strerror(errno));
3014         }
3015 }
3016 #endif  /* defined(HAVE_SS7) */
3017
3018 #if defined(HAVE_SS7)
3019 /*!
3020  * \internal
3021  * \brief Create a new asterisk channel structure for SS7.
3022  * \since 1.8
3023  *
3024  * \param pvt Private channel structure.
3025  * \param state Initial state of new channel.
3026  * \param law Combanding law to use.
3027  * \param exten Dialplan extension for incoming call.
3028  * \param requestor Channel requesting this new channel.
3029  *
3030  * \retval ast_channel on success.
3031  * \retval NULL on error.
3032  */
3033 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)
3034 {
3035         struct dahdi_pvt *p = pvt;
3036         int audio;
3037         int newlaw;
3038         struct ast_callid *callid = NULL;
3039         int callid_created = ast_callid_threadstorage_auto(&callid);
3040
3041         /* Set to audio mode at this point */
3042         audio = 1;
3043         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1)
3044                 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
3045                         p->channel, audio, strerror(errno));
3046
3047         if (law != SIG_SS7_DEFLAW) {
3048                 dahdi_setlaw(p->subs[SUB_REAL].dfd,
3049                         (law == SIG_SS7_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
3050         }
3051
3052         ast_copy_string(p->exten, exten, sizeof(p->exten));
3053
3054         newlaw = -1;
3055         switch (law) {
3056         case SIG_SS7_DEFLAW:
3057                 newlaw = 0;
3058                 break;
3059         case SIG_SS7_ALAW:
3060                 newlaw = DAHDI_LAW_ALAW;
3061                 break;
3062         case SIG_SS7_ULAW:
3063                 newlaw = DAHDI_LAW_MULAW;
3064                 break;
3065         }
3066         return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, requestor ? ast_channel_linkedid(requestor) : "", callid, callid_created);
3067 }
3068 #endif  /* defined(HAVE_SS7) */
3069
3070 #if defined(HAVE_SS7)
3071 static int sig_ss7_tone_to_dahditone(enum sig_ss7_tone tone)
3072 {
3073         switch (tone) {
3074         case SIG_SS7_TONE_RINGTONE:
3075                 return DAHDI_TONE_RINGTONE;
3076         case SIG_SS7_TONE_STUTTER:
3077                 return DAHDI_TONE_STUTTER;
3078         case SIG_SS7_TONE_CONGESTION:
3079                 return DAHDI_TONE_CONGESTION;
3080         case SIG_SS7_TONE_DIALTONE:
3081                 return DAHDI_TONE_DIALTONE;
3082         case SIG_SS7_TONE_DIALRECALL:
3083                 return DAHDI_TONE_DIALRECALL;
3084         case SIG_SS7_TONE_INFO:
3085                 return DAHDI_TONE_INFO;
3086         case SIG_SS7_TONE_BUSY:
3087                 return DAHDI_TONE_BUSY;
3088         default:
3089                 return -1;
3090         }
3091 }
3092 #endif  /* defined(HAVE_SS7) */
3093
3094 #if defined(HAVE_SS7)
3095 static int my_ss7_play_tone(void *pvt, enum sig_ss7_tone tone)
3096 {
3097         struct dahdi_pvt *p = pvt;
3098
3099         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_ss7_tone_to_dahditone(tone));
3100 }
3101 #endif  /* defined(HAVE_SS7) */
3102
3103 #if defined(HAVE_SS7)
3104 struct sig_ss7_callback sig_ss7_callbacks =
3105 {
3106         .lock_private = my_lock_private,
3107         .unlock_private = my_unlock_private,
3108         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3109
3110         .set_echocanceller = my_set_echocanceller,
3111         .set_loopback = my_ss7_set_loopback,
3112
3113         .new_ast_channel = my_new_ss7_ast_channel,
3114         .play_tone = my_ss7_play_tone,
3115
3116         .handle_link_exception = my_handle_link_exception,
3117         .set_alarm = my_set_alarm,
3118         .set_dialing = my_set_dialing,
3119         .set_outgoing = my_set_outgoing,
3120         .set_digital = my_set_digital,
3121         .set_inservice = my_set_inservice,
3122         .set_locallyblocked = my_set_locallyblocked,
3123         .set_remotelyblocked = my_set_remotelyblocked,
3124         .set_callerid = my_set_callerid,
3125         .set_dnid = my_set_dnid,
3126         .open_media = my_pri_ss7_open_media,
3127 };
3128 #endif  /* defined(HAVE_SS7) */
3129
3130 /*!
3131  * \brief Send MWI state change
3132  *
3133  * \arg mailbox_full This is the mailbox associated with the FXO line that the
3134  *      MWI state has changed on.
3135  * \arg thereornot This argument should simply be set to 1 or 0, to indicate
3136  *      whether there are messages waiting or not.
3137  *
3138  *  \return nothing
3139  *
3140  * This function does two things:
3141  *
3142  * 1) It generates an internal Asterisk event notifying any other module that
3143  *    cares about MWI that the state of a mailbox has changed.
3144  *
3145  * 2) It runs the script specified by the mwimonitornotify option to allow
3146  *    some custom handling of the state change.
3147  */
3148 static void notify_message(char *mailbox_full, int thereornot)
3149 {
3150         char s[sizeof(mwimonitornotify) + 80];
3151         char *mailbox, *context;
3152
3153         /* Strip off @default */
3154         context = mailbox = ast_strdupa(mailbox_full);
3155         strsep(&context, "@");
3156         if (ast_strlen_zero(context))
3157                 context = "default";
3158
3159         ast_publish_mwi_state(mailbox, context, thereornot, thereornot);
3160
3161         if (!ast_strlen_zero(mailbox) && !ast_strlen_zero(mwimonitornotify)) {
3162                 snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot);
3163                 ast_safe_system(s);
3164         }
3165 }
3166
3167 static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
3168 {
3169         struct dahdi_pvt *p = pvt;
3170
3171         if (neon_mwievent > -1 && !p->mwimonitor_neon)
3172                 return;
3173
3174         if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) {
3175                 ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox);
3176                 notify_message(p->mailbox, 1);
3177         } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) {
3178                 ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox);
3179                 notify_message(p->mailbox, 0);
3180         }
3181         /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */
3182         /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */
3183         if (neon_mwievent == -1 && p->mwimonitor_rpas) {
3184                 ast_hangup(chan);
3185                 return;
3186         }
3187 }
3188
3189 static int my_have_progressdetect(void *pvt)
3190 {
3191         struct dahdi_pvt *p = pvt;
3192
3193         if ((p->callprogress & CALLPROGRESS_PROGRESS)
3194                 && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
3195                 return 1;
3196         } else {
3197                 /* Don't have progress detection. */
3198                 return 0;
3199         }
3200 }
3201
3202 struct analog_callback analog_callbacks =
3203 {
3204         .play_tone = my_play_tone,
3205         .get_event = my_get_event,
3206         .wait_event = my_wait_event,
3207         .is_off_hook = my_is_off_hook,
3208         .set_echocanceller = my_set_echocanceller,
3209         .ring = my_ring,
3210         .flash = my_flash,
3211         .off_hook = my_off_hook,
3212         .dial_digits = my_dial_digits,
3213         .train_echocanceller = my_train_echocanceller,
3214         .on_hook = my_on_hook,
3215         .is_dialing = my_is_dialing,
3216         .allocate_sub = my_allocate_sub,
3217         .unallocate_sub = my_unallocate_sub,
3218         .swap_subs = my_swap_subchannels,
3219         .has_voicemail = my_has_voicemail,
3220         .check_for_conference = my_check_for_conference,
3221         .conf_add = my_conf_add,
3222         .conf_del = my_conf_del,
3223         .complete_conference_update = my_complete_conference_update,
3224         .start = my_start,
3225         .all_subchannels_hungup = my_all_subchannels_hungup,
3226         .lock_private = my_lock_private,
3227         .unlock_private = my_unlock_private,
3228         .deadlock_avoidance_private = my_deadlock_avoidance_private,
3229         .handle_dtmf = my_handle_dtmf,
3230         .wink = my_wink,
3231         .new_ast_channel = my_new_analog_ast_channel,
3232         .dsp_set_digitmode = my_dsp_set_digitmode,
3233         .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
3234         .send_callerid = my_send_callerid,
3235         .callwait = my_callwait,
3236         .stop_callwait = my_stop_callwait,
3237         .get_callerid = my_get_callerid,
3238         .start_cid_detect = my_start_cid_detect,
3239         .stop_cid_detect = my_stop_cid_detect,
3240         .handle_notify_message = my_handle_notify_message,
3241         .increase_ss_count = my_increase_ss_count,
3242         .decrease_ss_count = my_decrease_ss_count,
3243         .distinctive_ring = my_distinctive_ring,
3244         .set_linear_mode = my_set_linear_mode,
3245         .set_inthreeway = my_set_inthreeway,
3246         .get_and_handle_alarms = my_get_and_handle_alarms,
3247         .get_sigpvt_bridged_channel = my_get_sigpvt_bridged_channel,
3248         .get_sub_fd = my_get_sub_fd,
3249         .set_cadence = my_set_cadence,
3250         .set_alarm = my_set_alarm,
3251         .set_dialing = my_set_dialing,
3252         .set_outgoing = my_set_outgoing,
3253         .set_ringtimeout = my_set_ringtimeout,
3254         .set_waitingfordt = my_set_waitingfordt,
3255         .check_waitingfordt = my_check_waitingfordt,
3256         .set_confirmanswer = my_set_confirmanswer,
3257         .check_confirmanswer = my_check_confirmanswer,
3258         .set_callwaiting = my_set_callwaiting,
3259         .cancel_cidspill = my_cancel_cidspill,
3260         .confmute = my_confmute,
3261         .set_pulsedial = my_set_pulsedial,
3262         .set_new_owner = my_set_new_owner,
3263         .get_orig_dialstring = my_get_orig_dialstring,
3264         .set_needringing = my_set_needringing,
3265         .set_polarity = my_set_polarity,
3266         .start_polarityswitch = my_start_polarityswitch,
3267         .answer_polarityswitch = my_answer_polarityswitch,
3268         .hangup_polarityswitch = my_hangup_polarityswitch,
3269         .have_progressdetect = my_have_progressdetect,
3270 };
3271
3272 /*! Round robin search locations. */
3273 static struct dahdi_pvt *round_robin[32];
3274
3275 int _dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
3276 {
3277         int res;
3278         if (p->subs[SUB_REAL].owner == ast)
3279                 res = 0;
3280         else if (p->subs[SUB_CALLWAIT].owner == ast)
3281                 res = 1;
3282         else if (p->subs[SUB_THREEWAY].owner == ast)
3283                 res = 2;
3284         else {
3285                 res = -1;
3286                 if (!nullok)
3287                         ast_log(LOG_WARNING,
3288                                 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
3289                                 ast ? ast_channel_name(ast) : "", p->channel, fname, line);
3290         }
3291         return res;
3292 }
3293
3294 /*!
3295  * \internal
3296  * \brief Obtain the specified subchannel owner lock if the owner exists.
3297  *
3298  * \param pvt Channel private struct.
3299  * \param sub_idx Subchannel owner to lock.
3300  *
3301  * \note Assumes the pvt->lock is already obtained.
3302  *
3303  * \note
3304  * Because deadlock avoidance may have been necessary, you need to confirm
3305  * the state of things before continuing.
3306  *
3307  * \return Nothing
3308  */
3309 static void dahdi_lock_sub_owner(struct dahdi_pvt *pvt, int sub_idx)
3310 {
3311         for (;;) {
3312                 if (!pvt->subs[sub_idx].owner) {
3313                         /* No subchannel owner pointer */
3314                         break;
3315                 }
3316                 if (!ast_channel_trylock(pvt->subs[sub_idx].owner)) {
3317                         /* Got subchannel owner lock */
3318                         break;
3319                 }
3320                 /* We must unlock the private to avoid the possibility of a deadlock */
3321                 DEADLOCK_AVOIDANCE(&pvt->lock);
3322         }
3323 }
3324
3325 static void wakeup_sub(struct dahdi_pvt *p, int a)
3326 {
3327         dahdi_lock_sub_owner(p, a);
3328         if (p->subs[a].owner) {
3329                 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
3330                 ast_channel_unlock(p->subs[a].owner);
3331         }
3332 }
3333
3334 static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f)
3335 {
3336         for (;;) {
3337                 if (p->owner) {
3338                         if (ast_channel_trylock(p->owner)) {
3339                                 DEADLOCK_AVOIDANCE(&p->lock);
3340                         } else {
3341                                 ast_queue_frame(p->owner, f);
3342                                 ast_channel_unlock(p->owner);
3343                                 break;
3344                         }
3345                 } else
3346                         break;
3347         }
3348 }
3349
3350 static void publish_channel_alarm_clear(int channel)
3351 {
3352         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3353         RAII_VAR(struct ast_str *, dahdi_chan, ast_str_create(32), ast_free);
3354         if (!dahdi_chan) {
3355                 return;
3356         }
3357
3358         ast_str_set(&dahdi_chan, 0, "%d", channel);
3359         ast_log(LOG_NOTICE, "Alarm cleared on channel DAHDI/%d\n", channel);
3360         body = ast_json_pack("{s: s}", "DAHDIChannel", ast_str_buffer(dahdi_chan));
3361         if (!body) {
3362                 return;
3363         }
3364
3365         ast_manager_publish_event("AlarmClear", EVENT_FLAG_SYSTEM, body);
3366 }
3367
3368 static void publish_span_alarm_clear(int span)
3369 {
3370         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
3371
3372         ast_log(LOG_NOTICE, "Alarm cleared on span %d\n", span);
3373         body = ast_json_pack("{s: i}", "Span", span);
3374         if (!body) {
3375                 return;
3376         }
3377
3378         ast_manager_publish_event("SpanAlarmClear", EVENT_FLAG_SYSTEM, body);
3379 }
3380
3381 static void handle_clear_alarms(struct dahdi_pvt *p)
3382 {
3383 #if defined(HAVE_PRI)
3384         if (dahdi_sig_pri_lib_handles(p->sig) && sig_pri_is_alarm_ignored(p->pri)) {
3385                 return;
3386         }
3387 #endif  /* defined(HAVE_PRI) */
3388
3389         if (report_alarms & REPORT_CHANNEL_ALARMS) {
3390                 publish_channel_alarm_clear(p->channel);
3391         }
3392         if (report_alarms & REPORT_SPAN_ALARMS && p->manages_span_alarms) {
3393                 publish_span_alarm_clear(p->span);
3394         }
3395 }
3396
3397 #ifdef HAVE_OPENR2
3398
3399 static int dahdi_r2_answer(struct dahdi_pvt *p)
3400 {
3401         int res = 0;
3402         /* openr2 1.1.0 and older does not even define OR2_LIB_INTERFACE
3403         * and does not has support for openr2_chan_answer_call_with_mode
3404         *  */
3405 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
3406         const char *double_answer = pbx_builtin_getvar_helper(p->owner, "MFCR2_DOUBLE_ANSWER");
3407         int wants_double_answer = ast_true(double_answer) ? 1 : 0;
3408         if (!double_answer) {
3409                 /* this still can result in double answer if the channel context
3410                 * was configured that way */
3411                 res = openr2_chan_answer_call(p->r2chan);
3412         } else if (wants_double_answer) {
3413                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
3414         } else {
3415                 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
3416         }
3417 #else
3418         res = openr2_chan_answer_call(p->r2chan);
3419 #endif
3420         return res;
3421 }
3422
3423
3424
3425 /* should be called with the ast_channel locked */
3426 static openr2_calling_party_category_t dahdi_r2_get_channel_category(struct ast_channel *c)
3427 {
3428         openr2_calling_party_category_t cat;
3429         const char *catstr = pbx_builtin_getvar_helper(c, "MFCR2_CATEGORY");
3430         struct dahdi_pvt *p = ast_channel_tech_pvt(c);
3431         if (ast_strlen_zero(catstr)) {
3432                 ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
3433                                 ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3434                 return p->mfcr2_category;
3435         }
3436         if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
3437                 ast_log(LOG_WARNING, "Invalid category specified '%s' for chan %s, using default %s\n",
3438                                 catstr, ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
3439                 return p->mfcr2_category;
3440         }
3441         ast_debug(1, "Using category %s\n", catstr);
3442         return cat;
3443 }
3444
3445 static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
3446 {
3447         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3448         ast_mutex_lock(&p->lock);
3449         if (p->mfcr2call) {
3450                 ast_mutex_unlock(&p->lock);
3451                 /* TODO: This can happen when some other thread just finished dahdi_request requesting this very same
3452                    interface but has not yet seized the line (dahdi_call), and the far end wins and seize the line,
3453                    can we avoid this somehow?, at this point when dahdi_call send the seize, it is likely that since
3454                    the other end will see our seize as a forced release and drop the call, we will see an invalid
3455                    pattern that will be seen and treated as protocol error. */
3456                 ast_log(LOG_ERROR, "Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
3457                 return;
3458         }
3459         p->mfcr2call = 1;
3460         /* better safe than sorry ... */
3461         p->cid_name[0] = '\0';
3462         p->cid_num[0] = '\0';
3463         p->cid_subaddr[0] = '\0';
3464         p->rdnis[0] = '\0';
3465         p->exten[0] = '\0';
3466         p->mfcr2_ani_index = '\0';
3467         p->mfcr2_dnis_index = '\0';
3468         p->mfcr2_dnis_matched = 0;
3469         p->mfcr2_answer_pending = 0;
3470         p->mfcr2_call_accepted = 0;
3471         ast_mutex_unlock(&p->lock);
3472         ast_verbose("New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
3473 }
3474
3475 static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm)
3476 {
3477         int res;
3478         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3479         ast_mutex_lock(&p->lock);
3480         p->inalarm = alarm ? 1 : 0;
3481         if (p->inalarm) {
3482                 res = get_alarms(p);
3483                 handle_alarms(p, res);
3484         } else {
3485                 handle_clear_alarms(p);
3486         }
3487         ast_mutex_unlock(&p->lock);
3488 }
3489
3490 static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
3491 {
3492         ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
3493 }
3494
3495 static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
3496 {
3497         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3498         ast_log(LOG_ERROR, "MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
3499         if (p->owner) {
3500                 ast_channel_hangupcause_set(p->owner, AST_CAUSE_PROTOCOL_ERROR);
3501                 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
3502         }
3503         ast_mutex_lock(&p->lock);
3504         p->mfcr2call = 0;
3505         ast_mutex_unlock(&p->lock);
3506 }
3507
3508 static void dahdi_r2_disconnect_call(struct dahdi_pvt *p, openr2_call_disconnect_cause_t cause)
3509 {
3510         if (openr2_chan_disconnect_call(p->r2chan, cause)) {
3511                 ast_log(LOG_NOTICE, "Bad! failed to disconnect call on channel %d with reason %s, hope for the best!\n",
3512                    p->channel, openr2_proto_get_disconnect_string(cause));
3513                 /* force the chan to idle and release the call flag now since we will not see a clean on_call_end */
3514                 openr2_chan_set_idle(p->r2chan);
3515                 ast_mutex_lock(&p->lock);
3516                 p->mfcr2call = 0;
3517                 ast_mutex_unlock(&p->lock);
3518         }
3519 }
3520
3521 static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category)
3522 {
3523         struct dahdi_pvt *p;
3524         struct ast_channel *c;
3525         struct ast_callid *callid = NULL;
3526         int callid_created = ast_callid_threadstorage_auto(&callid);
3527         ast_verbose("MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
3528                         openr2_chan_get_number(r2chan), ani ? ani : "(restricted)", dnis,
3529                         openr2_proto_get_category_string(category));
3530         p = openr2_chan_get_client_data(r2chan);
3531         /* if collect calls are not allowed and this is a collect call, reject it! */
3532         if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
3533                 ast_log(LOG_NOTICE, "Rejecting MFC/R2 collect call\n");
3534                 dahdi_r2_disconnect_call(p, OR2_CAUSE_COLLECT_CALL_REJECTED);
3535                 goto dahdi_r2_on_call_offered_cleanup;
3536         }
3537         ast_mutex_lock(&p->lock);
3538         p->mfcr2_recvd_category = category;
3539         /* if we're not supposed to use CID, clear whatever we have */
3540         if (!p->use_callerid) {
3541                 ast_debug(1, "No CID allowed in configuration, CID is being cleared!\n");
3542                 p->cid_num[0] = 0;
3543                 p->cid_name[0] = 0;
3544         }
3545         /* if we're supposed to answer immediately, clear DNIS and set 's' exten */
3546         if (p->immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
3547                 ast_debug(1, "Setting exten => s because of immediate or 0 DNIS configured\n");
3548                 p->exten[0] = 's';
3549                 p->exten[1] = 0;
3550         }
3551         ast_mutex_unlock(&p->lock);
3552         if (!ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
3553                 ast_log(LOG_NOTICE, "MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
3554                                 p->channel, p->exten, p->context);
3555                 dahdi_r2_disconnect_call(p, OR2_CAUSE_UNALLOCATED_NUMBER);
3556                 goto dahdi_r2_on_call_offered_cleanup;
3557         }
3558         if (!p->mfcr2_accept_on_offer) {
3559                 /* The user wants us to start the PBX thread right away without accepting the call first */
3560                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, callid);
3561                 if (c) {
3562                         /* Done here, don't disable reading now since we still need to generate MF tones to accept
3563                            the call or reject it and detect the tone off condition of the other end, all of this
3564                            will be done in the PBX thread now */
3565                         goto dahdi_r2_on_call_offered_cleanup;
3566                 }
3567                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3568                 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
3569         } else if (p->mfcr2_charge_calls) {
3570                 ast_debug(1, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
3571                 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
3572         } else {
3573                 ast_debug(1, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
3574                 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
3575         }
3576
3577 dahdi_r2_on_call_offered_cleanup:
3578         ast_callid_threadstorage_auto_clean(callid, callid_created);
3579 }
3580
3581 static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
3582 {
3583         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3584         ast_verbose("MFC/R2 call end on channel %d\n", p->channel);
3585         ast_mutex_lock(&p->lock);
3586         p->mfcr2call = 0;
3587         ast_mutex_unlock(&p->lock);
3588 }
3589
3590 static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
3591 {
3592         struct dahdi_pvt *p = NULL;
3593         struct ast_channel *c = NULL;
3594         struct ast_callid *callid = NULL;
3595         int callid_created = ast_callid_threadstorage_auto(&callid);
3596         p = openr2_chan_get_client_data(r2chan);
3597         dahdi_ec_enable(p);
3598         p->mfcr2_call_accepted = 1;
3599         /* if it's an incoming call ... */
3600         if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
3601                 ast_verbose("MFC/R2 call has been accepted on backward channel %d\n", openr2_chan_get_number(r2chan));
3602                 /* If accept on offer is not set, it means at this point the PBX thread is already
3603                    launched (was launched in the 'on call offered' handler) and therefore this callback
3604                    is being executed already in the PBX thread rather than the monitor thread, don't launch
3605                    any other thread, just disable the openr2 reading and answer the call if needed */
3606                 if (!p->mfcr2_accept_on_offer) {
3607                         openr2_chan_disable_read(r2chan);
3608                         if (p->mfcr2_answer_pending) {
3609                                 ast_debug(1, "Answering MFC/R2 call after accepting it on chan %d\n", openr2_chan_get_number(r2chan));
3610                                 dahdi_r2_answer(p);
3611                         }
3612                         goto dahdi_r2_on_call_accepted_cleanup;
3613                 }
3614                 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, callid);
3615                 if (c) {
3616                         /* chan_dahdi will take care of reading from now on in the PBX thread, tell the
3617                            library to forget about it */
3618                         openr2_chan_disable_read(r2chan);
3619                         goto dahdi_r2_on_call_accepted_cleanup;
3620                 }
3621                 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
3622                 /* failed to create the channel, bail out and report it as an out of order line */
3623                 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
3624                 goto dahdi_r2_on_call_accepted_cleanup;
3625         }
3626         /* this is an outgoing call, no need to launch the PBX thread, most likely we're in one already */
3627         ast_verbose("MFC/R2 call has been accepted on forward channel %d\n", p->channel);
3628         p->subs[SUB_REAL].needringing = 1;
3629         p->dialing = 0;
3630         /* chan_dahdi will take care of reading from now on in the PBX thread, tell the library to forget about it */
3631         openr2_chan_disable_read(r2chan);
3632
3633 dahdi_r2_on_call_accepted_cleanup:
3634         ast_callid_threadstorage_auto_clean(callid, callid_created);
3635 }
3636
3637 static void dahdi_r2_on_call_answered(openr2_chan_t *r2chan)
3638 {
3639         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3640         ast_verbose("MFC/R2 call has been answered on channel %d\n", openr2_chan_get_number(r2chan));
3641         p->subs[SUB_REAL].needanswer = 1;
3642 }
3643
3644 static void dahdi_r2_on_call_read(openr2_chan_t *r2chan, const unsigned char *buf, int buflen)
3645 {
3646         /*ast_debug(1, "Read data from dahdi channel %d\n", openr2_chan_get_number(r2chan));*/
3647 }
3648
3649 static int dahdi_r2_cause_to_ast_cause(openr2_call_disconnect_cause_t cause)
3650 {
3651         switch (cause) {
3652         case OR2_CAUSE_BUSY_NUMBER:
3653                 return AST_CAUSE_BUSY;
3654         case OR2_CAUSE_NETWORK_CONGESTION:
3655                 return AST_CAUSE_CONGESTION;
3656         case OR2_CAUSE_OUT_OF_ORDER:
3657                 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
3658         case OR2_CAUSE_UNALLOCATED_NUMBER:
3659                 return AST_CAUSE_UNREGISTERED;
3660         case OR2_CAUSE_NO_ANSWER:
3661                 return AST_CAUSE_NO_ANSWER;
3662         case OR2_CAUSE_NORMAL_CLEARING:
3663                 return AST_CAUSE_NORMAL_CLEARING;
3664         case OR2_CAUSE_UNSPECIFIED:
3665         default:
3666                 return AST_CAUSE_NOTDEFINED;
3667         }
3668 }
3669
3670 static void dahdi_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause)
3671 {
3672         struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
3673         char cause_str[50];
3674         struct ast_control_pvt_cause_code *cause_code;
3675         int datalen = sizeof(*cause_code);
3676
3677         ast_verbose("MFC/R2 call disconnected on channel %d\n", openr2_chan_get_number(r2chan));
3678         ast_mutex_lock(&p->lock);
3679         if (!p->owner) {
3680                 ast_mutex_unlock(&p->lock);
3681                 /* no owner, therefore we can't use dahdi_hangup to disconnect, do it right now */
3682                 dahdi_r2_disconnect_call(p, OR2_CAUSE_NORMAL_CLEARING);
3683                 return;
3684         }
3685
3686         snprintf(cause_str, sizeof(cause_str), "R2 DISCONNECT (%s)", openr2_proto_get_disconnect_string(cause));
3687         datalen += strlen(cause_str);
3688         cause_code = ast_alloca(datalen);
3689         memset(cause_code, 0, datalen);
3690         cause_code->ast_cause = dahdi_r2_cause_to_ast_cause(cause);
3691         ast_copy_string(cause_code->chan_name, ast_channel_name(p->owner), AST_CHANNEL_NAME);
3692         ast_copy_string(cause_code->code, cause_str, datalen + 1 - sizeof(*cause_code));
3693         ast_queue_control_data(p->owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, datalen);
3694         ast_channel_hangupcause_hash_set(p->owner, cause_code, datalen);
3695
3696         /* when we have an owner we don't call dahdi_r2_disconnect_call here, that will
3697            be done in dahdi_hangup */
3698         if (ast_channel_state(p->owner) == AST_STATE_UP) {
3699                 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
3700                 ast_mutex_unlock(&p->lock);
3701         } else if (openr2_chan_get_direction(r2chan) == OR2_DIR_FORWARD) {
3702                 /* being the forward side we must report what happened to the call to whoever requested it */
3703                 switch (cause) {
3704                 case OR2_CAUSE_BUSY_NUMBER:
3705                         p->subs[SUB_REAL].needbusy = 1;
3706                         break;
3707                 case OR2_CAUSE_NETWORK_CONGESTION:
3708                 case OR2_CAUSE_OUT_OF_ORDER:
3709                 case OR2_CAUSE_UNALLOCATED_NUMBER:
3710                 case OR2_CAUSE_NO_ANSWER:
3711                 case OR2_CAUSE_UNSPECIFIED:
3712                 case OR2_CAUSE_NORMAL_CLEARING:
3713                         p->subs[SUB_REAL].needcongestion = 1;
3714                         break;
3715                 default:
3716                         ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
3717                 }
3718                 ast_mutex_unlock(&p->lock);
3719         } else {
3720                 ast_mutex_unlock(&p->lock);
3721                 /* being the backward side and not UP yet, we only need to request hangup */
3722                 /* TODO: what about doing this same thing when were AST_STATE_UP? */
3723                 ast_queue_hangup_with_cause(p->owner, dahdi_r2_cause_to_ast_cause(cause));
3724         }
3725 }
3726
3727 static void dahdi_r2_write_log(openr2_log_level_t level, char *logmessage)
3728 {
3729         switch (level) {
3730         case OR2_LOG_NOTICE:
3731                 ast_verbose("%s", logmessage);
3732                 break;
3733         case OR2_LOG_WARNING:
3734                 ast_log(LOG_WARNING, "%s", logmessage);
3735                 break;
3736         case OR2_LOG_ERROR:
3737                 ast_log(LOG_ERROR, "%s", logmessage);
3738                 break;