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