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