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