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