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