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