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