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