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