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