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