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