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