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