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