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