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