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