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