Patch for improving unload on zap (thanks James)
[asterisk/asterisk.git] / channels / chan_zap.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * Zaptel Pseudo TDM interface 
5  * 
6  * Copyright (C) 2003 Digium
7  *
8  * Mark Spencer <markster@digium.com>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <stdio.h>
15 #include <string.h>
16 #include <asterisk/lock.h>
17 #include <asterisk/channel.h>
18 #include <asterisk/channel_pvt.h>
19 #include <asterisk/config.h>
20 #include <asterisk/logger.h>
21 #include <asterisk/module.h>
22 #include <asterisk/pbx.h>
23 #include <asterisk/options.h>
24 #include <asterisk/file.h>
25 #include <asterisk/ulaw.h>
26 #include <asterisk/alaw.h>
27 #include <asterisk/callerid.h>
28 #include <asterisk/adsi.h>
29 #include <asterisk/cli.h>
30 #include <asterisk/cdr.h>
31 #include <asterisk/parking.h>
32 #include <asterisk/musiconhold.h>
33 #include <asterisk/say.h>
34 #include <asterisk/tdd.h>
35 #include <asterisk/app.h>
36 #include <asterisk/dsp.h>
37 #include <asterisk/astdb.h>
38 #include <asterisk/manager.h>
39 #include <asterisk/causes.h>
40 #include <sys/signal.h>
41 #include <sys/select.h>
42 #include <errno.h>
43 #include <stdlib.h>
44 #include <stdint.h>
45 #include <unistd.h>
46 #include <sys/ioctl.h>
47 #include <linux/zaptel.h>
48 #include <math.h>
49 #include <tonezone.h>
50 #include <ctype.h>
51 #ifdef ZAPATA_PRI
52 #include <libpri.h>
53 #endif
54 #ifdef ZAPATA_R2
55 #include <libmfcr2.h>
56 #endif
57
58 #include "../asterisk.h"
59
60 /* 
61    XXX 
62    XXX   We definitely need to lock the private structure in zt_read and such 
63    XXX  
64  */
65
66
67 /*
68  * Define ZHONE_HACK to cause us to go off hook and then back on hook when
69  * the user hangs up to reset the state machine so ring works properly.
70  * This is used to be able to support kewlstart by putting the zhone in
71  * groundstart mode since their forward disconnect supervision is entirely
72  * broken even though their documentation says it isn't and their support
73  * is entirely unwilling to provide any assistance with their channel banks
74  * even though their web site says they support their products for life.
75  */
76
77 /* #define ZHONE_HACK */
78
79 /* Typically, how many rings before we should send Caller*ID */
80 #define DEFAULT_CIDRINGS 1
81
82 #define CHANNEL_PSEUDO -12
83
84 #define AST_LAW(p) (((p)->law == ZT_LAW_ALAW) ? AST_FORMAT_ALAW : AST_FORMAT_ULAW)
85
86 static char *desc = "Zapata Telephony"
87 #ifdef ZAPATA_PRI
88                " w/PRI"
89 #endif
90 #ifdef ZAPATA_R2
91                " w/R2"
92 #endif
93 ;
94
95 static char *tdesc = "Zapata Telephony Driver"
96 #ifdef ZAPATA_PRI
97                " w/PRI"
98 #endif
99 #ifdef ZAPATA_R2
100                " w/R2"
101 #endif
102 ;
103
104 static char *type = "Zap";
105 static char *typecompat = "Tor";        /* Retain compatibility with chan_tor */
106 static char *config = "zapata.conf";
107
108 #define SIG_EM          ZT_SIG_EM
109 #define SIG_EMWINK      (0x10000 | ZT_SIG_EM)
110 #define SIG_FEATD       (0x20000 | ZT_SIG_EM)
111 #define SIG_FEATDMF     (0x40000 | ZT_SIG_EM)
112 #define SIG_FEATB       (0x80000 | ZT_SIG_EM)
113 #define SIG_FXSLS       ZT_SIG_FXSLS
114 #define SIG_FXSGS       ZT_SIG_FXSGS
115 #define SIG_FXSKS       ZT_SIG_FXSKS
116 #define SIG_FXOLS       ZT_SIG_FXOLS
117 #define SIG_FXOGS       ZT_SIG_FXOGS
118 #define SIG_FXOKS       ZT_SIG_FXOKS
119 #define SIG_PRI         ZT_SIG_CLEAR
120 #define SIG_R2          ZT_SIG_CAS
121 #define SIG_SF          ZT_SIG_SF
122 #define SIG_SFWINK      (0x10000 | ZT_SIG_SF)
123 #define SIG_SF_FEATD    (0x20000 | ZT_SIG_SF)
124 #define SIG_SF_FEATDMF  (0x40000 | ZT_SIG_SF)
125 #define SIG_SF_FEATB    (0x80000 | ZT_SIG_SF)
126
127 #define NUM_SPANS       32
128 #define RESET_INTERVAL  3600    /* How often (in seconds) to reset unused channels */
129
130 #define CHAN_PSEUDO     -2
131
132 static char context[AST_MAX_EXTENSION] = "default";
133 static char callerid[256] = "";
134
135 static char language[MAX_LANGUAGE] = "";
136 static char musicclass[MAX_LANGUAGE] = "";
137
138 static int use_callerid = 1;
139
140 static int cur_signalling = -1;
141
142 static unsigned int cur_group = 0;
143 static unsigned int cur_callergroup = 0;
144 static unsigned int cur_pickupgroup = 0;
145 static int relaxdtmf = 0;
146
147 static int immediate = 0;
148
149 static int stripmsd = 0;
150
151 static int callwaiting = 0;
152
153 static int callwaitingcallerid = 0;
154
155 static int hidecallerid = 0;
156
157 static int restrictcid = 0;
158
159 static int use_callingpres = 0;
160
161 static int callreturn = 0;
162
163 static int threewaycalling = 0;
164
165 static int transfer = 0;
166
167 static int cancallforward = 0;
168
169 static float rxgain = 0.0;
170
171 static float txgain = 0.0;
172
173 static int echocancel;
174
175 static int echotraining;
176
177 static int echocanbridged = 0;
178
179 static int busydetect = 0;
180
181 static int busycount = 3;
182
183 static int callprogress = 0;
184
185 static char accountcode[20] = "";
186
187 static char mailbox[AST_MAX_EXTENSION];
188
189 static int amaflags = 0;
190
191 static int adsi = 0;
192
193 static int numbufs = 4;
194
195 #ifdef ZAPATA_PRI
196 static int minunused = 2;
197 static int minidle = 0;
198 static char idleext[AST_MAX_EXTENSION];
199 static char idledial[AST_MAX_EXTENSION];
200 static int overlapdial = 0;
201 #endif
202
203 /* Wait up to 16 seconds for first digit (FXO logic) */
204 static int firstdigittimeout = 16000;
205
206 /* How long to wait for following digits (FXO logic) */
207 static int gendigittimeout = 8000;
208
209 /* How long to wait for an extra digit, if there is an ambiguous match */
210 static int matchdigittimeout = 3000;
211
212 static int usecnt =0;
213 static ast_mutex_t usecnt_lock = AST_MUTEX_INITIALIZER;
214
215 /* Protect the interface list (of zt_pvt's) */
216 static ast_mutex_t iflock = AST_MUTEX_INITIALIZER;
217
218 /* Protect the monitoring thread, so only one process can kill or start it, and not
219    when it's doing something critical. */
220 static ast_mutex_t monlock = AST_MUTEX_INITIALIZER;
221
222 /* This is the thread for the monitor which checks for input on the channels
223    which are not currently in use.  */
224 static pthread_t monitor_thread = 0;
225
226 static int restart_monitor(void);
227
228 static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc);
229
230 static int zt_sendtext(struct ast_channel *c, char *text);
231
232 static inline int zt_get_event(int fd)
233 {
234         /* Avoid the silly zt_getevent which ignores a bunch of events */
235         int j;
236         if (ioctl(fd, ZT_GETEVENT, &j) == -1) return -1;
237         return j;
238 }
239
240 static inline int zt_wait_event(int fd)
241 {
242         /* Avoid the silly zt_waitevent which ignores a bunch of events */
243         int i,j=0;
244         i = ZT_IOMUX_SIGEVENT;
245         if (ioctl(fd, ZT_IOMUX, &i) == -1) return -1;
246         if (ioctl(fd, ZT_GETEVENT, &j) == -1) return -1;
247         return j;
248 }
249
250 /* Chunk size to read -- we use 20ms chunks to make things happy.  */   
251 #define READ_SIZE 160
252
253 #define MASK_AVAIL              (1 << 0)                /* Channel available for PRI use */
254 #define MASK_INUSE              (1 << 1)                /* Channel currently in use */
255
256 #define CALLWAITING_SILENT_SAMPLES      ( (300 * 8) / READ_SIZE) /* 300 ms */
257 #define CALLWAITING_REPEAT_SAMPLES      ( (10000 * 8) / READ_SIZE) /* 300 ms */
258 #define CIDCW_EXPIRE_SAMPLES            ( (500 * 8) / READ_SIZE) /* 500 ms */
259 #define MIN_MS_SINCE_FLASH                      ( (2000) )      /* 2000 ms */
260 #define RINGT                                           ( (8000 * 8) / READ_SIZE)
261
262 struct zt_pvt;
263
264
265 #ifdef ZAPATA_R2
266 static int r2prot = -1;
267 #endif
268
269
270 #ifdef ZAPATA_PRI
271 struct zt_pri {
272         pthread_t master;                       /* Thread of master */
273         ast_mutex_t lock;               /* Mutex */
274         char idleext[AST_MAX_EXTENSION];                /* Where to idle extra calls */
275         char idlecontext[AST_MAX_EXTENSION];            /* What context to use for idle */
276         char idledial[AST_MAX_EXTENSION];               /* What to dial before dumping */
277         int minunused;                          /* Min # of channels to keep empty */
278         int minidle;                            /* Min # of "idling" calls to keep active */
279         int nodetype;                           /* Node type */
280         int switchtype;                         /* Type of switch to emulate */
281         int dialplan;                   /* Dialing plan */
282         int dchannel;                   /* What channel the dchannel is on */
283         int channels;                   /* Num of chans in span (31 or 24) */
284         int overlapdial;                /* In overlap dialing mode */
285         struct pri *pri;
286         int debug;
287         int fd;
288         int up;
289         int offset;
290         int span;
291         int chanmask[32];                       /* Channel status */
292         int resetting;
293         int resetchannel;
294         time_t lastreset;
295         struct zt_pvt *pvt[32]; /* Member channel pvt structs */
296         struct zt_channel *chan[32];    /* Channels on each line */
297 };
298
299
300 static struct zt_pri pris[NUM_SPANS];
301
302 static int pritype = PRI_CPE;
303
304 #if 0
305 #define DEFAULT_PRI_DEBUG (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE)
306 #else
307 #define DEFAULT_PRI_DEBUG 0
308 #endif
309
310 static inline void pri_rel(struct zt_pri *pri)
311 {
312         ast_mutex_unlock(&pri->lock);
313 }
314
315 static int switchtype = PRI_SWITCH_NI2;
316 static int dialplan = PRI_NATIONAL_ISDN + 1;
317
318 #endif
319
320 #define SUB_REAL                0                       /* Active call */
321 #define SUB_CALLWAIT    1                       /* Call-Waiting call on hold */
322 #define SUB_THREEWAY    2                       /* Three-way call */
323
324 static char *subnames[] = {
325         "Real",
326         "Callwait",
327         "Threeway"
328 };
329
330 struct zt_subchannel {
331         int zfd;
332         struct ast_channel *owner;
333         int chan;
334         short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
335         struct ast_frame f;             /* One frame for each channel.  How did this ever work before? */
336         int needringing;
337         int needcallerid;
338         int needanswer;
339         int linear;
340         int inthreeway;
341         ZT_CONFINFO curconf;
342 };
343
344 #define CONF_USER_REAL          (1 << 0)
345 #define CONF_USER_THIRDCALL     (1 << 1)
346
347 #define MAX_SLAVES      4
348
349 static struct zt_pvt {
350         ast_mutex_t lock;
351         struct ast_channel *owner;      /* Our current active owner (if applicable) */
352                 /* Up to three channels can be associated with this call */
353                 
354         struct zt_subchannel sub_unused;        /* Just a safety precaution */
355         struct zt_subchannel subs[3];   /* Sub-channels */
356         struct zt_confinfo saveconf;    /* Saved conference info */
357
358         struct zt_pvt *slaves[MAX_SLAVES];      /* Slave to us (follows our conferencing) */
359         struct zt_pvt *master;  /* Master to us (we follow their conferencing) */
360         int inconference;               /* If our real should be in the conference */
361         
362         int sig;                                        /* Signalling style */
363         int radio;                              /* radio type */
364         int firstradio;                         /* first radio flag */
365         float rxgain;
366         float txgain;
367         struct zt_pvt *next;                    /* Next channel in list */
368         struct zt_pvt *prev;                    /* Prev channel in list */
369         char context[AST_MAX_EXTENSION];
370         char exten[AST_MAX_EXTENSION];
371         char language[MAX_LANGUAGE];
372         char musicclass[MAX_LANGUAGE];
373         char callerid[AST_MAX_EXTENSION];
374         char lastcallerid[AST_MAX_EXTENSION];
375         char callwaitcid[AST_MAX_EXTENSION];
376         char rdnis[AST_MAX_EXTENSION];
377         char dnid[AST_MAX_EXTENSION];
378         unsigned int group;
379         int law;
380         int confno;                                     /* Our conference */
381         int confusers;                          /* Who is using our conference */
382         int propconfno;                         /* Propagated conference number */
383         unsigned int callgroup;
384         unsigned int pickupgroup;
385         int immediate;                          /* Answer before getting digits? */
386         int channel;                            /* Channel Number */
387         int span;                                       /* Span number */
388         int dialing;
389         int dialednone;
390         int use_callerid;                       /* Whether or not to use caller id on this channel */
391         int hidecallerid;
392         int callreturn;
393         int permhidecallerid;           /* Whether to hide our outgoing caller ID or not */
394         int restrictcid;                /* Whether restrict the callerid -> only send ANI */
395         int use_callingpres;            /* Whether to use the callingpres the calling switch sends */
396         int callingpres;                /* The value of callling presentation that we're going to use when placing a PRI call */
397         int callwaitingrepeat;          /* How many samples to wait before repeating call waiting */
398         int cidcwexpire;                        /* When to expire our muting for CID/CW */
399         unsigned char *cidspill;
400         int cidpos;
401         int cidlen;
402         int ringt;
403         int stripmsd;
404         int callwaiting;
405         int callwaitcas;
406         int callwaitrings;
407         int echocancel;
408         int echotraining;
409         int echocanbridged;
410         int echocanon;
411         int echobreak;
412         char echorest[10];
413         int permcallwaiting;
414         int callwaitingcallerid;
415         int threewaycalling;
416         int transfer;
417         int digital;
418         int outgoing;
419         int dnd;
420         int busydetect;
421         int busycount;
422         int callprogress;
423         struct timeval flashtime;       /* Last flash-hook time */
424         struct ast_dsp *dsp;
425         int cref;                                       /* Call reference number */
426         ZT_DIAL_OPERATION dop;
427         int destroy;
428         int ignoredtmf;                         
429         int inalarm;
430         char accountcode[20];           /* Account code */
431         int amaflags;                           /* AMA Flags */
432         char didtdd;                    /* flag to say its done it once */
433         struct tdd_state *tdd;          /* TDD flag */
434         int adsi;
435         int cancallforward;
436         char call_forward[AST_MAX_EXTENSION];
437         char mailbox[AST_MAX_EXTENSION];
438         int onhooktime;
439         int msgstate;
440         
441         int confirmanswer;              /* Wait for '#' to confirm answer */
442         int distinctivering;    /* Which distinctivering to use */
443         int cidrings;                   /* Which ring to deliver CID on */
444         
445         int faxhandled;                 /* Has a fax tone already been handled? */
446         
447         char mate;                      /* flag to say its in MATE mode */
448         int pulsedial;          /* whether a pulse dial phone is detected */
449         int dtmfrelax;          /* whether to run in relaxed DTMF mode */
450         int fake_event;
451 #ifdef ZAPATA_PRI
452         struct zt_pri *pri;
453         q931_call *call;
454         int isidlecall;
455         int resetting;
456         int prioffset;
457         int alreadyhungup;
458 #ifdef PRI_EVENT_PROCEEDING
459         int proceeding;
460 #endif
461         int setup_ack;          /* wheter we received SETUP_ACKNOWLEDGE or not */
462 #endif  
463 #ifdef ZAPATA_R2
464         int r2prot;
465         mfcr2_t *r2;
466         int hasr2call;
467         int r2blocked;
468         int sigchecked;
469 #endif  
470 } *iflist = NULL, *ifend = NULL;
471
472 struct zt_pvt *round_robin[32];
473
474 #ifdef ZAPATA_PRI
475 static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri)
476 {
477         int res;
478         /* Grab the lock first */
479         do {
480             res = ast_mutex_trylock(&pri->lock);
481                 if (res) {
482                         ast_mutex_unlock(&pvt->lock);
483                         /* Release the lock and try again */
484                         usleep(1);
485                         ast_mutex_lock(&pvt->lock);
486                 }
487         } while(res);
488         /* Then break the select */
489         pthread_kill(pri->master, SIGURG);
490         return 0;
491 }
492 #endif
493
494 static struct zt_ring_cadence cadences[] = {
495         { { 125, 125, 2000, 4000 } },                   /* Quick chirp followed by normal ring */
496         { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /* British style ring */
497         { { 125, 125, 125, 125, 125, 4000 } },  /* Three short bursts */
498         { { 1000, 500, 2500, 5000 } },  /* Long ring */
499 };
500
501 static int cidrings[] = {
502         2,                                                                              /* Right after first long ring */
503         4,                                                                              /* Right after long part */
504         3,                                                                              /* After third chirp */
505         2,                                                                              /* Second spell */
506 };
507
508 #define NUM_CADENCE (sizeof(cadences) / sizeof(cadences[0]))
509
510 #define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
511                         (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
512
513 #define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
514 #define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
515
516 #ifdef ZAPATA_PRI
517 /* translate between PRI causes and asterisk's */
518 static int hangup_pri2cause(int cause)
519 {
520         switch(cause) {
521                 case PRI_CAUSE_USER_BUSY:
522                         return AST_CAUSE_BUSY;
523                 case PRI_CAUSE_NORMAL_CLEARING:
524                         return AST_CAUSE_NORMAL;
525                 case PRI_CAUSE_NORMAL_CIRCUIT_CONGESTION:
526                 case PRI_CAUSE_REQUESTED_CHAN_UNAVAIL:
527                         return AST_CAUSE_CONGESTION;
528                 case PRI_CAUSE_UNALLOCATED:
529                 case PRI_CAUSE_NUMBER_CHANGED:
530                         return AST_CAUSE_UNALLOCATED;
531                 default:
532                         return AST_CAUSE_FAILURE;
533         }
534         /* never reached */
535         return 0;
536 }
537
538 /* translate between ast cause and PRI */
539 static int hangup_cause2pri(int cause)
540 {
541         switch(cause) {
542                 case AST_CAUSE_BUSY:
543                         return PRI_CAUSE_USER_BUSY;
544                 case AST_CAUSE_NORMAL:
545                 default:
546                         return PRI_CAUSE_NORMAL_CLEARING;
547         }
548         /* never reached */
549         return 0;
550 }
551 #endif
552
553 static int zt_get_index(struct ast_channel *ast, struct zt_pvt *p, int nullok)
554 {
555         int res;
556         if (p->subs[0].owner == ast)
557                 res = 0;
558         else if (p->subs[1].owner == ast)
559                 res = 1;
560         else if (p->subs[2].owner == ast)
561                 res = 2;
562         else {
563                 res = -1;
564                 if (!nullok)
565                         ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n");
566         }
567         return res;
568 }
569
570 static void swap_subs(struct zt_pvt *p, int a, int b)
571 {
572         int tchan;
573         int tinthreeway;
574         struct ast_channel *towner;
575         struct ast_frame null = { AST_FRAME_NULL, };
576
577         ast_log(LOG_DEBUG, "Swapping %d and %d\n", a, b);
578
579         tchan = p->subs[a].chan;
580         towner = p->subs[a].owner;
581         tinthreeway = p->subs[a].inthreeway;
582
583         p->subs[a].chan = p->subs[b].chan;
584         p->subs[a].owner = p->subs[b].owner;
585         p->subs[a].inthreeway = p->subs[b].inthreeway;
586
587         p->subs[b].chan = tchan;
588         p->subs[b].owner = towner;
589         p->subs[b].inthreeway = tinthreeway;
590
591         if (p->subs[a].owner) {
592                 p->subs[a].owner->fds[0] = p->subs[a].zfd;
593                 ast_queue_frame(p->subs[a].owner, &null, 0);
594         }
595         if (p->subs[b].owner) {
596                 p->subs[b].owner->fds[0] = p->subs[b].zfd;
597                 ast_queue_frame(p->subs[b].owner, &null, 0);
598         }
599         
600 }
601
602 static int zt_open(char *fn)
603 {
604         int fd;
605         int isnum;
606         int chan = 0;
607         int bs;
608         int x;
609         isnum = 1;
610         for (x=0;x<strlen(fn);x++) {
611                 if (!isdigit(fn[x])) {
612                         isnum = 0;
613                         break;
614                 }
615         }
616         if (isnum) {
617                 chan = atoi(fn);
618                 if (chan < 1) {
619                         ast_log(LOG_WARNING, "Invalid channel number '%s'\n", fn);
620                         return -1;
621                 }
622                 fn = "/dev/zap/channel";
623         }
624         fd = open(fn, O_RDWR | O_NONBLOCK);
625         if (fd < 0) {
626                 ast_log(LOG_WARNING, "Unable to open '%s': %s\n", fn, strerror(errno));
627                 return -1;
628         }
629         if (chan) {
630                 if (ioctl(fd, ZT_SPECIFY, &chan)) {
631                         x = errno;
632                         close(fd);
633                         errno = x;
634                         ast_log(LOG_WARNING, "Unable to specify channel %d: %s\n", chan, strerror(errno));
635                         return -1;
636                 }
637         }
638         bs = READ_SIZE;
639         if (ioctl(fd, ZT_SET_BLOCKSIZE, &bs) == -1) return -1;
640         return fd;
641 }
642
643 static void zt_close(int fd)
644 {
645         close(fd);
646 }
647
648 int zt_setlinear(int zfd, int linear)
649 {
650         int res;
651         res = ioctl(zfd, ZT_SETLINEAR, &linear);
652         if (res)
653                 return res;
654         return 0;
655 }
656
657
658 int zt_setlaw(int zfd, int law)
659 {
660         int res;
661         res = ioctl(zfd, ZT_SETLAW, &law);
662         if (res)
663                 return res;
664         return 0;
665 }
666
667 static int alloc_sub(struct zt_pvt *p, int x)
668 {
669         ZT_BUFFERINFO bi;
670         int res;
671         if (p->subs[x].zfd < 0) {
672                 p->subs[x].zfd = zt_open("/dev/zap/pseudo");
673                 if (p->subs[x].zfd > -1) {
674                         res = ioctl(p->subs[x].zfd, ZT_GET_BUFINFO, &bi);
675                         if (!res) {
676                                 bi.txbufpolicy = ZT_POLICY_IMMEDIATE;
677                                 bi.rxbufpolicy = ZT_POLICY_IMMEDIATE;
678                                 bi.numbufs = numbufs;
679                                 res = ioctl(p->subs[x].zfd, ZT_SET_BUFINFO, &bi);
680                                 if (res < 0) {
681                                         ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d\n", x);
682                                 }
683                         } else 
684                                 ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d\n", x);
685                         if (ioctl(p->subs[x].zfd, ZT_CHANNO, &p->subs[x].chan) == 1) {
686                                 ast_log(LOG_WARNING,"Unable to get channel number for pseudo channel on FD %d\n",p->subs[x].zfd);
687                                 zt_close(p->subs[x].zfd);
688                                 p->subs[x].zfd = -1;
689                                 return -1;
690                         }
691                         if (option_debug)
692                                 ast_log(LOG_DEBUG, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].zfd, p->subs[x].chan);
693                         return 0;
694                 } else
695                         ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
696                 return -1;
697         }
698         ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
699         return -1;
700 }
701
702 static int unalloc_sub(struct zt_pvt *p, int x)
703 {
704         if (!x) {
705                 ast_log(LOG_WARNING, "Trying to unalloc the real channel %d?!?\n", p->channel);
706                 return -1;
707         }
708         ast_log(LOG_DEBUG, "Released sub %d of channel %d\n", x, p->channel);
709         if (p->subs[x].zfd > -1) {
710                 zt_close(p->subs[x].zfd);
711         }
712         p->subs[x].zfd = -1;
713         p->subs[x].linear = 0;
714         p->subs[x].chan = 0;
715         p->subs[x].owner = NULL;
716         p->subs[x].inthreeway = 0;
717         memset(&p->subs[x].curconf, 0, sizeof(p->subs[x].curconf));
718         return 0;
719 }
720
721 static int zt_digit(struct ast_channel *ast, char digit)
722 {
723         ZT_DIAL_OPERATION zo;
724         struct zt_pvt *p;
725         int res = 0;
726         int index;
727         p = ast->pvt->pvt;
728         index = zt_get_index(ast, p, 0);
729         if (index == SUB_REAL) {
730 #ifdef ZAPATA_PRI
731 #ifdef PRI_EVENT_SETUP_ACK
732                 if (p->sig == SIG_PRI && ast->_state == AST_STATE_DIALING && p->setup_ack && !p->proceeding) {
733 #else
734 #ifdef PRI_EVENT_PROCEEDING
735                 if (p->sig == SIG_PRI && ast->_state == AST_STATE_DIALING && !p->proceeding) {
736 #else
737                 if (p->sig == SIG_PRI && ast->_state == AST_STATE_DIALING) {
738 #endif
739 #endif
740                         if (!pri_grab(p, p->pri))
741                                 pri_information(p->pri->pri,p->call,digit);
742                         else
743                                 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
744                         pri_rel(p->pri);
745                 } else {
746 #else
747                 {
748 #endif
749                         zo.op = ZT_DIAL_OP_APPEND;
750                         zo.dialstr[0] = 'T';
751                         zo.dialstr[1] = digit;
752                         zo.dialstr[2] = 0;
753                         if ((res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &zo)))
754                                 ast_log(LOG_WARNING, "Couldn't dial digit %c\n", digit);
755                         else
756                                 p->dialing = 1;
757                 }
758         }
759         
760         return res;
761 }
762
763 static char *events[] = {
764         "No event",
765         "On hook",
766         "Ring/Answered",
767         "Wink/Flash",
768         "Alarm",
769         "No more alarm",
770                 "HDLC Abort",
771                 "HDLC Overrun",
772                 "HDLC Bad FCS",
773                 "Dial Complete",
774                 "Ringer On",
775                 "Ringer Off",
776                 "Hook Transition Complete",
777                 "Bits Changed",
778                 "Pulse Start"
779 };
780
781 static struct {
782         int alarm;
783         char *name;
784 } alarms[] = {
785         { ZT_ALARM_RED, "Red Alarm" },
786         { ZT_ALARM_YELLOW, "Yellow Alarm" },
787         { ZT_ALARM_BLUE, "Blue Alarm" },
788         { ZT_ALARM_RECOVER, "Recovering" },
789         { ZT_ALARM_LOOPBACK, "Loopback" },
790         { ZT_ALARM_NOTOPEN, "Not Open" },
791         { ZT_ALARM_NONE, "None" },
792 };
793
794 static char *alarm2str(int alarm)
795 {
796         int x;
797         for (x=0;x<sizeof(alarms) / sizeof(alarms[0]); x++) {
798                 if (alarms[x].alarm & alarm)
799                         return alarms[x].name;
800         }
801         return alarm ? "Unknown Alarm" : "No Alarm";
802 }
803
804 static char *event2str(int event)
805 {
806         static char buf[256];
807         if ((event < 15) && (event > -1))
808                 return events[event];
809         sprintf(buf, "Event %d", event);
810         return buf;
811 }
812
813 #ifdef ZAPATA_R2
814 static int str2r2prot(char *swtype)
815 {
816     if (!strcasecmp(swtype, "ar"))
817         return MFCR2_PROT_ARGENTINA;
818     /*endif*/
819     if (!strcasecmp(swtype, "cn"))
820         return MFCR2_PROT_CHINA;
821     /*endif*/
822     if (!strcasecmp(swtype, "kr"))
823         return MFCR2_PROT_KOREA;
824     /*endif*/
825     return -1;
826 }
827 #endif
828
829 static char *sig2str(int sig)
830 {
831         static char buf[256];
832         switch(sig) {
833         case SIG_EM:
834                 return "E & M Immediate";
835         case SIG_EMWINK:
836                 return "E & M Wink";
837         case SIG_FEATD:
838                 return "Feature Group D (DTMF)";
839         case SIG_FEATDMF:
840                 return "Feature Group D (MF)";
841         case SIG_FEATB:
842                 return "Feature Group B (MF)";
843         case SIG_FXSLS:
844                 return "FXS Loopstart";
845         case SIG_FXSGS:
846                 return "FXS Groundstart";
847         case SIG_FXSKS:
848                 return "FXS Kewlstart";
849         case SIG_FXOLS:
850                 return "FXO Loopstart";
851         case SIG_FXOGS:
852                 return "FXO Groundstart";
853         case SIG_FXOKS:
854                 return "FXO Kewlstart";
855         case SIG_PRI:
856                 return "PRI Signalling";
857         case SIG_R2:
858                 return "R2 Signalling";
859         case SIG_SF:
860                 return "SF (Tone) Signalling Immediate";
861         case SIG_SFWINK:
862                 return "SF (Tone) Signalling Wink";
863         case SIG_SF_FEATD:
864                 return "SF (Tone) Signalling with Feature Group D (DTMF)";
865         case SIG_SF_FEATDMF:
866                 return "SF (Tone) Signallong with Feature Group D (MF)";
867         case SIG_SF_FEATB:
868                 return "SF (Tone) Signalling with Feature Group B (MF)";
869         case 0:
870                 return "Pseudo Signalling";
871         default:
872                 snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
873                 return buf;
874         }
875 }
876
877 static int conf_add(struct zt_pvt *p, struct zt_subchannel *c, int index, int slavechannel)
878 {
879         /* If the conference already exists, and we're already in it
880            don't bother doing anything */
881         ZT_CONFINFO zi;
882         
883         memset(&zi, 0, sizeof(zi));
884         zi.chan = 0;
885
886         if (slavechannel > 0) {
887                 /* If we have only one slave, do a digital mon */
888                 zi.confmode = ZT_CONF_DIGITALMON;
889                 zi.confno = slavechannel;
890         } else {
891                 if (!index) {
892                         /* Real-side and pseudo-side both participate in conference */
893                         zi.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER |
894                                                                 ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
895                 } else
896                         zi.confmode = ZT_CONF_CONF | ZT_CONF_TALKER | ZT_CONF_LISTENER;
897                 zi.confno = p->confno;
898         }
899         if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
900                 return 0;
901         if (c->zfd < 0)
902                 return 0;
903         if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
904                 ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d\n", c->zfd, zi.confmode, zi.confno);
905                 return -1;
906         }
907         if (slavechannel < 1) {
908                 p->confno = zi.confno;
909         }
910         memcpy(&c->curconf, &zi, sizeof(c->curconf));
911         ast_log(LOG_DEBUG, "Added %d to conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
912         return 0;
913 }
914
915 static int isourconf(struct zt_pvt *p, struct zt_subchannel *c)
916 {
917         /* If they're listening to our channel, they're ours */ 
918         if ((p->channel == c->curconf.confno) && (c->curconf.confmode == ZT_CONF_DIGITALMON))
919                 return 1;
920         /* If they're a talker on our (allocated) conference, they're ours */
921         if ((p->confno > 0) && (p->confno == c->curconf.confno) && (c->curconf.confmode & ZT_CONF_TALKER))
922                 return 1;
923         return 0;
924 }
925
926 static int conf_del(struct zt_pvt *p, struct zt_subchannel *c, int index)
927 {
928         ZT_CONFINFO zi;
929         if (/* Can't delete if there's no zfd */
930                 (c->zfd < 0) ||
931                 /* Don't delete from the conference if it's not our conference */
932                 !isourconf(p, c)
933                 /* Don't delete if we don't think it's conferenced at all (implied) */
934                 ) return 0;
935         memset(&zi, 0, sizeof(zi));
936         zi.chan = 0;
937         zi.confno = 0;
938         zi.confmode = 0;
939         if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
940                 ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
941                 return -1;
942         }
943         ast_log(LOG_DEBUG, "Removed %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
944         memcpy(&c->curconf, &zi, sizeof(c->curconf));
945         return 0;
946 }
947
948 static int isslavenative(struct zt_pvt *p, struct zt_pvt **out)
949 {
950         int x;
951         int useslavenative;
952         struct zt_pvt *slave = NULL;
953         /* Start out optimistic */
954         useslavenative = 1;
955         /* Update conference state in a stateless fashion */
956         for (x=0;x<3;x++) {
957                 /* Any three-way calling makes slave native mode *definitely* out
958                    of the question */
959                 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway)
960                         useslavenative = 0;
961         }
962         /* If we don't have any 3-way calls, check to see if we have
963            precisely one slave */
964         if (useslavenative) {
965                 for (x=0;x<MAX_SLAVES;x++) {
966                         if (p->slaves[x]) {
967                                 if (slave) {
968                                         /* Whoops already have a slave!  No 
969                                            slave native and stop right away */
970                                         slave = NULL;
971                                         useslavenative = 0;
972                                         break;
973                                 } else {
974                                         /* We have one slave so far */
975                                         slave = p->slaves[x];
976                                 }
977                         }
978                 }
979         }
980         /* If no slave, slave native definitely out */
981         if (!slave)
982                 useslavenative = 0;
983         else if (slave->law != p->law) {
984                 useslavenative = 0;
985                 slave = NULL;
986         }
987         if (out)
988                 *out = slave;
989         return useslavenative;
990 }
991
992 static int update_conf(struct zt_pvt *p)
993 {
994         int needconf = 0;
995         int x;
996         int useslavenative;
997         struct zt_pvt *slave = NULL;
998
999         useslavenative = isslavenative(p, &slave);
1000         /* Start with the obvious, general stuff */
1001         for (x=0;x<3;x++) {
1002                 /* Look for three way calls */
1003                 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway) {
1004                         conf_add(p, &p->subs[x], x, 0);
1005                         needconf++;
1006                 } else {
1007                         conf_del(p, &p->subs[x], x);
1008                 }
1009         }
1010         /* If we have a slave, add him to our conference now. or DAX
1011            if this is slave native */
1012         for (x=0;x<MAX_SLAVES;x++) {
1013                 if (p->slaves[x]) {
1014                         if (useslavenative)
1015                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, p->channel);
1016                         else {
1017                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
1018                                 needconf++;
1019                         }
1020                 }
1021         }
1022         /* If we're supposed to be in there, do so now */
1023         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
1024                 if (useslavenative)
1025                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, slave->channel);
1026                 else {
1027                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
1028                         needconf++;
1029                 }
1030         }
1031         /* If we have a master, add ourselves to his conference */
1032         if (p->master) {
1033                 if (isslavenative(p->master, NULL)) {
1034                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, p->master->channel);
1035                 } else {
1036                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
1037                 }
1038         }
1039         if (!needconf) {
1040                 /* Nobody is left (or should be left) in our conference.  
1041                    Kill it.  */
1042                 p->confno = -1;
1043         }
1044         ast_log(LOG_DEBUG, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
1045         return 0;
1046 }
1047
1048 static void zt_enable_ec(struct zt_pvt *p)
1049 {
1050         int x;
1051         int res;
1052         if (p->echocanon) {
1053                 ast_log(LOG_DEBUG, "Echo cancellation already on\n");
1054                 return;
1055         }
1056         if (p && p->echocancel) {
1057                 if (p->sig == SIG_PRI) {
1058                         x = 1;
1059                         res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x);
1060                         if (res)
1061                                 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1062                 }
1063                 x = p->echocancel;
1064                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1065                 if (res) 
1066                         ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1067                 else {
1068                         p->echocanon = 1;
1069                         ast_log(LOG_DEBUG, "Enabled echo cancellation on channel %d\n", p->channel);
1070                 }
1071         } else
1072                 ast_log(LOG_DEBUG, "No echocancellation requested\n");
1073 }
1074
1075 static void zt_train_ec(struct zt_pvt *p)
1076 {
1077         int x;
1078         int res;
1079         if (p && p->echocancel && p->echotraining) {
1080                 x = 400;
1081                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOTRAIN, &x);
1082                 if (res) 
1083                         ast_log(LOG_WARNING, "Unable to request echo training on channel %d\n", p->channel);
1084                 else {
1085                         ast_log(LOG_DEBUG, "Engaged echo training on channel %d\n", p->channel);
1086                 }
1087         } else
1088                 ast_log(LOG_DEBUG, "No echo training requested\n");
1089 }
1090
1091 static void zt_disable_ec(struct zt_pvt *p)
1092 {
1093         int x;
1094         int res;
1095         if (p->echocancel) {
1096                 x = 0;
1097                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1098                 if (res) 
1099                         ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d\n", p->channel);
1100                 else
1101                         ast_log(LOG_DEBUG, "disabled echo cancellation on channel %d\n", p->channel);
1102         }
1103         p->echocanon = 0;
1104 }
1105
1106 int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
1107 {
1108         struct  zt_gains g;
1109         float ltxgain;
1110         float lrxgain;
1111         int j,k;
1112         g.chan = chan;
1113         if ((rxgain != 0.0)  || (txgain != 0.0)) {
1114                 /* caluculate linear value of tx gain */
1115                 ltxgain = pow(10.0,txgain / 20.0);
1116                 /* caluculate linear value of rx gain */
1117                 lrxgain = pow(10.0,rxgain / 20.0);
1118                 if (law == ZT_LAW_ALAW) {
1119                         for (j=0;j<256;j++) {
1120                                 k = (int)(((float)AST_ALAW(j)) * lrxgain);
1121                                 if (k > 32767) k = 32767;
1122                                 if (k < -32767) k = -32767;
1123                                 g.rxgain[j] = AST_LIN2A(k);
1124                                 k = (int)(((float)AST_ALAW(j)) * ltxgain);
1125                                 if (k > 32767) k = 32767;
1126                                 if (k < -32767) k = -32767;
1127                                 g.txgain[j] = AST_LIN2A(k);
1128                         }
1129                 } else {
1130                         for (j=0;j<256;j++) {
1131                                 k = (int)(((float)AST_MULAW(j)) * lrxgain);
1132                                 if (k > 32767) k = 32767;
1133                                 if (k < -32767) k = -32767;
1134                                 g.rxgain[j] = AST_LIN2MU(k);
1135                                 k = (int)(((float)AST_MULAW(j)) * ltxgain);
1136                                 if (k > 32767) k = 32767;
1137                                 if (k < -32767) k = -32767;
1138                                 g.txgain[j] = AST_LIN2MU(k);
1139                         }
1140                 }
1141         } else {
1142                 for (j=0;j<256;j++) {
1143                         g.rxgain[j] = j;
1144                         g.txgain[j] = j;
1145                 }
1146         }
1147                 
1148           /* set 'em */
1149         return(ioctl(fd,ZT_SETGAINS,&g));
1150 }
1151
1152 static inline int zt_set_hook(int fd, int hs)
1153 {
1154         int x, res;
1155         x = hs;
1156         res = ioctl(fd, ZT_HOOK, &x);
1157         if (res < 0) 
1158         {
1159                 if (errno == EINPROGRESS) return 0;
1160                 ast_log(LOG_WARNING, "zt hook failed: %s\n", strerror(errno));
1161         }
1162         return res;
1163 }
1164
1165 static inline int zt_confmute(struct zt_pvt *p, int muted)
1166 {
1167         int x, y, res;
1168         x = muted;
1169         if (p->sig == SIG_PRI) {
1170                 y = 1;
1171                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &y);
1172                 if (res)
1173                         ast_log(LOG_WARNING, "Unable to set audio mode on '%d'\n", p->channel);
1174         }
1175         res = ioctl(p->subs[SUB_REAL].zfd, ZT_CONFMUTE, &x);
1176         if (res < 0) 
1177                 ast_log(LOG_WARNING, "zt confmute(%d) failed on channel %d: %s\n", muted, p->channel, strerror(errno));
1178         return res;
1179 }
1180
1181 static int save_conference(struct zt_pvt *p)
1182 {
1183         struct zt_confinfo c;
1184         int res;
1185         if (p->saveconf.confmode) {
1186                 ast_log(LOG_WARNING, "Can't save conference -- already in use\n");
1187                 return -1;
1188         }
1189         p->saveconf.chan = 0;
1190         res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &p->saveconf);
1191         if (res) {
1192                 ast_log(LOG_WARNING, "Unable to get conference info: %s\n", strerror(errno));
1193                 p->saveconf.confmode = 0;
1194                 return -1;
1195         }
1196         c.chan = 0;
1197         c.confno = 0;
1198         c.confmode = ZT_CONF_NORMAL;
1199         res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &c);
1200         if (res) {
1201                 ast_log(LOG_WARNING, "Unable to set conference info: %s\n", strerror(errno));
1202                 return -1;
1203         }
1204         if (option_debug)
1205                 ast_log(LOG_DEBUG, "Disabled conferencing\n");
1206         return 0;
1207 }
1208
1209 static int restore_conference(struct zt_pvt *p)
1210 {
1211         int res;
1212         if (p->saveconf.confmode) {
1213                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &p->saveconf);
1214                 p->saveconf.confmode = 0;
1215                 if (res) {
1216                         ast_log(LOG_WARNING, "Unable to restore conference info: %s\n", strerror(errno));
1217                         return -1;
1218                 }
1219         }
1220         if (option_debug)
1221                 ast_log(LOG_DEBUG, "Restored conferencing\n");
1222         return 0;
1223 }
1224
1225 static int send_callerid(struct zt_pvt *p);
1226
1227 int send_cwcidspill(struct zt_pvt *p)
1228 {
1229         p->callwaitcas = 0;
1230         p->cidcwexpire = 0;
1231         p->cidspill = malloc(MAX_CALLERID_SIZE);
1232         if (p->cidspill) {
1233                 memset(p->cidspill, 0x7f, MAX_CALLERID_SIZE);
1234                 p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, p->callwaitcid, AST_LAW(p));
1235                 /* Make sure we account for the end */
1236                 p->cidlen += READ_SIZE * 4;
1237                 p->cidpos = 0;
1238                 send_callerid(p);
1239                 if (option_verbose > 2)
1240                         ast_verbose(VERBOSE_PREFIX_3 "CPE supports Call Waiting Caller*ID.  Sending '%s'\n", p->callwaitcid);
1241         } else return -1;
1242         return 0;
1243 }
1244
1245 static int has_voicemail(struct zt_pvt *p)
1246 {
1247
1248         return ast_app_has_voicemail(p->mailbox);
1249 }
1250
1251 static int send_callerid(struct zt_pvt *p)
1252 {
1253         /* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */
1254         int res;
1255         /* Take out of linear mode if necessary */
1256         if (p->subs[SUB_REAL].linear) {
1257                 p->subs[SUB_REAL].linear = 0;
1258                 zt_setlinear(p->subs[SUB_REAL].zfd, 0);
1259         }
1260         while(p->cidpos < p->cidlen) {
1261                 res = write(p->subs[SUB_REAL].zfd, p->cidspill + p->cidpos, p->cidlen - p->cidpos);
1262                 if (res < 0) {
1263                         if (errno == EAGAIN)
1264                                 return 0;
1265                         else {
1266                                 ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
1267                                 return -1;
1268                         }
1269                 }
1270                 if (!res)
1271                         return 0;
1272                 p->cidpos += res;
1273         }
1274         free(p->cidspill);
1275         p->cidspill = NULL;
1276         if (p->callwaitcas) {
1277                 /* Wait for CID/CW to expire */
1278                 p->cidcwexpire = CIDCW_EXPIRE_SAMPLES;
1279         } else
1280                 restore_conference(p);
1281         return 0;
1282 }
1283
1284 static int zt_callwait(struct ast_channel *ast)
1285 {
1286         struct zt_pvt *p = ast->pvt->pvt;
1287         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1288         if (p->cidspill) {
1289                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1290                 free(p->cidspill);
1291         }
1292         p->cidspill = malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4);
1293         if (p->cidspill) {
1294                 save_conference(p);
1295                 /* Silence */
1296                 memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1297                 if (!p->callwaitrings && p->callwaitingcallerid) {
1298                         ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
1299                         p->callwaitcas = 1;
1300                         p->cidlen = 2400 + 680 + READ_SIZE * 4;
1301                 } else {
1302                         ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
1303                         p->callwaitcas = 0;
1304                         p->cidlen = 2400 + READ_SIZE * 4;
1305                 }
1306                 p->cidpos = 0;
1307                 send_callerid(p);
1308         } else {
1309                 ast_log(LOG_WARNING, "Unable to create SAS/CAS spill\n");
1310                 return -1;
1311         }
1312         return 0;
1313 }
1314
1315 static int zt_call(struct ast_channel *ast, char *rdest, int timeout)
1316 {
1317         struct zt_pvt *p = ast->pvt->pvt;
1318         int x, res, index;
1319         char *c, *n, *l;
1320 #ifdef ZAPATA_PRI
1321         char *s;
1322 #endif
1323         char callerid[256];
1324         char dest[256];
1325         strncpy(dest, rdest, sizeof(dest) - 1);
1326         if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1327                 ast_log(LOG_WARNING, "zt_call called on %s, neither down nor reserved\n", ast->name);
1328                 return -1;
1329         }
1330         p->dialednone = 0;
1331         if (p->radio)  /* if a radio channel, up immediately */
1332         {
1333                 /* Special pseudo -- automatically up */
1334                 ast_setstate(ast, AST_STATE_UP); 
1335                 return 0;
1336         }
1337         x = ZT_FLUSH_READ | ZT_FLUSH_WRITE;
1338         res = ioctl(p->subs[SUB_REAL].zfd, ZT_FLUSH, &x);
1339         if (res)
1340                 ast_log(LOG_WARNING, "Unable to flush input on channel %d\n", p->channel);
1341         p->outgoing = 1;
1342
1343         set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
1344
1345         switch(p->sig) {
1346         case SIG_FXOLS:
1347         case SIG_FXOGS:
1348         case SIG_FXOKS:
1349                 if (p->owner == ast) {
1350                         /* Normal ring, on hook */
1351                         
1352                         /* Don't send audio while on hook, until the call is answered */
1353                         p->dialing = 1;
1354                         if (p->use_callerid) {
1355                                 /* Generate the Caller-ID spill if desired */
1356                                 if (p->cidspill) {
1357                                         ast_log(LOG_WARNING, "cidspill already exists??\n");
1358                                         free(p->cidspill);
1359                                 }
1360                                 p->cidspill = malloc(MAX_CALLERID_SIZE);
1361                                 p->callwaitcas = 0;
1362                                 if (p->cidspill) {
1363                                         p->cidlen = ast_callerid_generate(p->cidspill, ast->callerid, AST_LAW(p));
1364                                         p->cidpos = 0;
1365                                         send_callerid(p);
1366                                 } else
1367                                         ast_log(LOG_WARNING, "Unable to generate CallerID spill\n");
1368                         }
1369                         /* Select proper cadence */
1370                         if ((p->distinctivering > 0) && (p->distinctivering <= NUM_CADENCE)) {
1371                                 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, &cadences[p->distinctivering-1]))
1372                                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s'\n", p->distinctivering, ast->name);
1373                                 p->cidrings = cidrings[p->distinctivering - 1];
1374                         } else {
1375                                 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, NULL))
1376                                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s'\n", ast->name);
1377                                 p->cidrings = DEFAULT_CIDRINGS;
1378                         }
1379
1380
1381                         /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */
1382                         c = strchr(dest, '/');
1383                         if (c)
1384                           c++;
1385                         if (c && (strlen(c) < p->stripmsd)) {
1386                           ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1387                           c = NULL;
1388                         }
1389                         if (c) {
1390                                 p->dop.op = ZT_DIAL_OP_REPLACE;
1391                                 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c);
1392                                 ast_log(LOG_DEBUG, "FXO: setup deferred dialstring: %s\n", c);
1393                         } else {
1394                                 strcpy(p->dop.dialstr, "");
1395                         }
1396                         x = ZT_RING;
1397                         if (ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x) && (errno != EINPROGRESS)) {
1398                                 ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
1399                                 return -1;
1400                         }
1401                         p->dialing = 1;
1402                 } else {
1403                         /* Call waiting call */
1404                         p->callwaitrings = 0;
1405                         if (ast->callerid)
1406                                 strncpy(p->callwaitcid, ast->callerid, sizeof(p->callwaitcid)-1);
1407                         else
1408                                 strcpy(p->callwaitcid, "");
1409                         /* Call waiting tone instead */
1410                         if (zt_callwait(ast))
1411                                 return -1;
1412                         /* Make ring-back */
1413                         if (tone_zone_play_tone(p->subs[SUB_CALLWAIT].zfd, ZT_TONE_RINGTONE))
1414                                 ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast->name);
1415                                 
1416                 }
1417                 if (ast->callerid) 
1418                         strncpy(callerid, ast->callerid, sizeof(callerid)-1);
1419                 else
1420                         strcpy(callerid, "");
1421                 ast_callerid_parse(callerid, &n, &l);
1422                 if (l) {
1423                         ast_shrink_phone_number(l);
1424                         if (!ast_isphonenumber(l))
1425                                 l = NULL;
1426                 }
1427                 if (l)
1428                         strcpy(p->lastcallerid, l);
1429                 else
1430                         strcpy(p->lastcallerid, "");
1431                 ast_setstate(ast, AST_STATE_RINGING);
1432                 index = zt_get_index(ast, p, 0);
1433                 if (index > -1) {
1434                         p->subs[index].needringing = 1;
1435                 }
1436                 break;
1437         case SIG_FXSLS:
1438         case SIG_FXSGS:
1439         case SIG_FXSKS:
1440         case SIG_EMWINK:
1441         case SIG_EM:
1442         case SIG_FEATD:
1443         case SIG_FEATDMF:
1444         case SIG_FEATB:
1445         case SIG_SFWINK:
1446         case SIG_SF:
1447         case SIG_SF_FEATD:
1448         case SIG_SF_FEATDMF:
1449         case SIG_SF_FEATB:
1450                 c = strchr(dest, '/');
1451                 if (c)
1452                         c++;
1453                 else
1454                         c = dest;
1455                 if (strlen(c) < p->stripmsd) {
1456                         ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1457                         return -1;
1458                 }
1459                 x = ZT_START;
1460                 /* Start the trunk */
1461                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
1462                 if (res < 0) {
1463                         if (errno != EINPROGRESS) {
1464                                 ast_log(LOG_WARNING, "Unable to start channel: %s\n", strerror(errno));
1465                                 return -1;
1466                         }
1467                 }
1468                 ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
1469                 p->dop.op = ZT_DIAL_OP_REPLACE;
1470                 if (p->sig == SIG_FEATD) {
1471                         if (ast->callerid) {
1472                                 strncpy(callerid, ast->callerid, sizeof(callerid)-1);
1473                                 ast_callerid_parse(callerid, &n, &l);
1474                                 if (l) {
1475                                         ast_shrink_phone_number(l);
1476                                         if (!ast_isphonenumber(l))
1477                                                 l = NULL;
1478                                 }
1479                         } else
1480                                 l = NULL;
1481                         if (l) 
1482                                 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c + p->stripmsd);
1483                         else
1484                                 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c + p->stripmsd);
1485                 } else 
1486                 if (p->sig == SIG_FEATDMF) {
1487                         if (ast->callerid) {
1488                                 strncpy(callerid, ast->callerid, sizeof(callerid)-1);
1489                                 ast_callerid_parse(callerid, &n, &l);
1490                                 if (l) {
1491                                         ast_shrink_phone_number(l);
1492                                         if (!ast_isphonenumber(l))
1493                                                 l = NULL;
1494                                 }
1495                         } else
1496                                 l = NULL;
1497                         if (l) 
1498                                 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c + p->stripmsd);
1499                         else
1500                                 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c + p->stripmsd);
1501                 } else 
1502                 if (p->sig == SIG_FEATB) {
1503                         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c + p->stripmsd);
1504                 } else 
1505                         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c + p->stripmsd);
1506                 if (strlen(p->dop.dialstr) > 4) {
1507                         strcpy(p->echorest, "w");
1508                         strcpy(p->echorest + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
1509                         p->echobreak = 1;
1510                         p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
1511                 } else
1512                         p->echobreak = 0;
1513                 if (!res) {
1514                         if (ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop)) {
1515                                 x = ZT_ONHOOK;
1516                                 ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
1517                                 ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
1518                                 return -1;
1519                         }
1520                 } else
1521                         ast_log(LOG_DEBUG, "Deferring dialing...\n");
1522                 p->dialing = 1;
1523                 if (strlen(c + p->stripmsd) < 1) p->dialednone = 1;
1524                 ast_setstate(ast, AST_STATE_DIALING);
1525                 break;
1526 #ifdef ZAPATA_PRI
1527         case SIG_PRI:
1528                 c = strchr(dest, '/');
1529                 if (c)
1530                         c++;
1531                 else
1532                         c = dest;
1533                 if (ast->callerid && !p->hidecallerid) {
1534                         strncpy(callerid, ast->callerid, sizeof(callerid)-1);
1535                         ast_callerid_parse(callerid, &n, &l);
1536                         if (l) {
1537                                 ast_shrink_phone_number(l);
1538                                 if (!ast_isphonenumber(l))
1539                                         l = NULL;
1540                         }
1541                 } else
1542                         l = NULL;
1543                 if (strlen(c) < p->stripmsd) {
1544                         ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1545                         return -1;
1546                 }
1547                 p->dop.op = ZT_DIAL_OP_REPLACE;
1548                 s = strchr(c + p->stripmsd, 'w');
1549                 if (s) {
1550                         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%s", s);
1551                         *s = '\0';
1552                 } else {
1553                         strcpy(p->dop.dialstr, "");
1554                 }
1555                 if (!(p->call = pri_new_call(p->pri->pri))) {
1556                         ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel);
1557                         return -1;
1558                 }
1559                 if (pri_call(p->pri->pri, p->call, p->digital ? PRI_TRANS_CAP_DIGITAL : PRI_TRANS_CAP_SPEECH, 
1560                         p->prioffset, p->pri->nodetype == PRI_NETWORK ? 0 : 1, 1, l, p->pri->dialplan - 1, n,
1561                         l ? (ast->restrictcid ? PRES_PROHIB_USER_NUMBER_PASSED_SCREEN : (p->use_callingpres ? ast->callingpres : PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN)) : PRES_NUMBER_NOT_AVAILABLE,
1562                         c + p->stripmsd, p->pri->dialplan - 1, 
1563                         ((p->law == ZT_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW))) {
1564                         ast_log(LOG_WARNING, "Unable to setup call to %s\n", c + p->stripmsd);
1565                         return -1;
1566                 }
1567                 ast_setstate(ast, AST_STATE_DIALING);
1568                 break;
1569 #endif          
1570         case 0:
1571                 /* Special pseudo -- automatically up*/
1572                 ast_setstate(ast, AST_STATE_UP);
1573                 break;          
1574         default:
1575                 ast_log(LOG_DEBUG, "not yet implemented\n");
1576                 return -1;
1577         }
1578         return 0;
1579 }
1580
1581 static int destroy_channel(struct zt_pvt *prev, struct zt_pvt *cur, int now)
1582 {
1583         int owned = 0;
1584         int i = 0;
1585
1586         if (!now) {
1587                 if (cur->owner) {
1588                         owned = 1;
1589                 }
1590
1591                 for (i = 0; i < 3; i++) {
1592                         if (cur->subs[i].owner) {
1593                                 owned = 1;
1594                         }
1595                 }
1596                 if (!owned) {
1597                         if (prev) {
1598                                 prev->next = cur->next;
1599                                 if (prev->next)
1600                                         prev->next->prev = prev;
1601                                 else
1602                                         ifend = prev;
1603                         } else {
1604                                 iflist = cur->next;
1605                                 if (iflist)
1606                                         iflist->prev = NULL;
1607                                 else
1608                                         ifend = NULL;
1609                         }
1610                         if (cur->subs[SUB_REAL].zfd > -1) {
1611                                 zt_close(cur->subs[SUB_REAL].zfd);
1612                         }
1613                         free(cur);
1614                 }
1615         } else {
1616                 if (prev) {
1617                         prev->next = cur->next;
1618                         if (prev->next)
1619                                 prev->next->prev = prev;
1620                         else
1621                                 ifend = prev;
1622                 } else {
1623                         iflist = cur->next;
1624                         if (iflist)
1625                                 iflist->prev = NULL;
1626                         else
1627                                 ifend = NULL;
1628                 }
1629                 if (cur->subs[SUB_REAL].zfd > -1) {
1630                         zt_close(cur->subs[SUB_REAL].zfd);
1631                 }
1632                 free(cur);
1633         }
1634         return 0;
1635 }
1636
1637
1638 static int zt_hangup(struct ast_channel *ast)
1639 {
1640         int res;
1641         int index,x, law;
1642         static int restore_gains(struct zt_pvt *p);
1643         struct zt_pvt *p = ast->pvt->pvt;
1644         struct zt_pvt *tmp = NULL;
1645         struct zt_pvt *prev = NULL;
1646         ZT_PARAMS par;
1647
1648         if (option_debug)
1649                 ast_log(LOG_DEBUG, "zt_hangup(%s)\n", ast->name);
1650         if (!ast->pvt->pvt) {
1651                 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
1652                 return 0;
1653         }
1654         
1655         ast_mutex_lock(&p->lock);
1656         
1657         index = zt_get_index(ast, p, 1);
1658
1659         if (p->sig == SIG_PRI) {
1660                 x = 1;
1661                 ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
1662         }
1663
1664         x = 0;
1665         zt_confmute(p, 0);
1666         restore_gains(p);
1667         
1668         if (p->dsp)
1669                 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);
1670
1671
1672         ast_log(LOG_DEBUG, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
1673                 p->channel, index, p->subs[SUB_REAL].zfd, p->subs[SUB_CALLWAIT].zfd, p->subs[SUB_THREEWAY].zfd);
1674         p->ignoredtmf = 0;
1675         
1676         if (index > -1) {
1677                 /* Real channel, do some fixup */
1678                 p->subs[index].owner = NULL;
1679                 p->subs[index].needanswer = 0;
1680                 p->subs[index].needringing = 0;
1681                 p->subs[index].linear = 0;
1682                 p->subs[index].needcallerid = 0;
1683                 zt_setlinear(p->subs[index].zfd, 0);
1684                 if (index == SUB_REAL) {
1685                         if ((p->subs[SUB_CALLWAIT].zfd > -1) && (p->subs[SUB_THREEWAY].zfd > -1)) {
1686                                 ast_log(LOG_DEBUG, "Normal call hung up with both three way call and a call waiting call in place?\n");
1687                                 if (p->subs[SUB_CALLWAIT].inthreeway) {
1688                                         /* We had flipped over to answer a callwait and now it's gone */
1689                                         ast_log(LOG_DEBUG, "We were flipped over to the callwait, moving back and unowning.\n");
1690                                         /* Move to the call-wait, but un-own us until they flip back. */
1691                                         swap_subs(p, SUB_CALLWAIT, SUB_REAL);
1692                                         unalloc_sub(p, SUB_CALLWAIT);
1693                                         p->owner = NULL;
1694                                 } else {
1695                                         /* The three way hung up, but we still have a call wait */
1696                                         ast_log(LOG_DEBUG, "We were in the threeway and have a callwait still.  Ditching the threeway.\n");
1697                                         swap_subs(p, SUB_THREEWAY, SUB_REAL);
1698                                         unalloc_sub(p, SUB_THREEWAY);
1699                                         if (p->subs[SUB_REAL].inthreeway) {
1700                                                 /* This was part of a three way call.  Immediately make way for
1701                                                    another call */
1702                                                 ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
1703                                                 p->owner = p->subs[SUB_REAL].owner;
1704                                         } else {
1705                                                 /* This call hasn't been completed yet...  Set owner to NULL */
1706                                                 ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
1707                                                 p->owner = NULL;
1708                                         }
1709                                         p->subs[SUB_REAL].inthreeway = 0;
1710                                 }
1711                         } else if (p->subs[SUB_CALLWAIT].zfd > -1) {
1712                                 /* Move to the call-wait and switch back to them. */
1713                                 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
1714                                 unalloc_sub(p, SUB_CALLWAIT);
1715                                 p->owner = p->subs[SUB_REAL].owner;
1716                                 if (p->subs[SUB_REAL].owner->bridge)
1717                                         ast_moh_stop(p->subs[SUB_REAL].owner->bridge);
1718                         } else if (p->subs[SUB_THREEWAY].zfd > -1) {
1719                                 swap_subs(p, SUB_THREEWAY, SUB_REAL);
1720                                 unalloc_sub(p, SUB_THREEWAY);
1721                                 if (p->subs[SUB_REAL].inthreeway) {
1722                                         /* This was part of a three way call.  Immediately make way for
1723                                            another call */
1724                                         ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
1725                                         p->owner = p->subs[SUB_REAL].owner;
1726                                 } else {
1727                                         /* This call hasn't been completed yet...  Set owner to NULL */
1728                                         ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
1729                                         p->owner = NULL;
1730                                 }
1731                                 p->subs[SUB_REAL].inthreeway = 0;
1732                         }
1733                 } else if (index == SUB_CALLWAIT) {
1734                         /* Ditch the holding callwait call, and immediately make it availabe */
1735                         if (p->subs[SUB_CALLWAIT].inthreeway) {
1736                                 /* This is actually part of a three way, placed on hold.  Place the third part
1737                                    on music on hold now */
1738                                 if (p->subs[SUB_THREEWAY].owner && p->subs[SUB_THREEWAY].owner->bridge)
1739                                         ast_moh_start(p->subs[SUB_THREEWAY].owner->bridge, NULL);
1740                                 p->subs[SUB_THREEWAY].inthreeway = 0;
1741                                 /* Make it the call wait now */
1742                                 swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
1743                                 unalloc_sub(p, SUB_THREEWAY);
1744                         } else
1745                                 unalloc_sub(p, SUB_CALLWAIT);
1746                 } else if (index == SUB_THREEWAY) {
1747                         if (p->subs[SUB_CALLWAIT].inthreeway) {
1748                                 /* The other party of the three way call is currently in a call-wait state.
1749                                    Start music on hold for them, and take the main guy out of the third call */
1750                                 if (p->subs[SUB_CALLWAIT].owner && p->subs[SUB_CALLWAIT].owner->bridge)
1751                                         ast_moh_start(p->subs[SUB_CALLWAIT].owner->bridge, NULL);
1752                                 p->subs[SUB_CALLWAIT].inthreeway = 0;
1753                         }
1754                         p->subs[SUB_REAL].inthreeway = 0;
1755                         /* If this was part of a three way call index, let us make
1756                            another three way call */
1757                         unalloc_sub(p, SUB_THREEWAY);
1758                 } else {
1759                         /* This wasn't any sort of call, but how are we an index? */
1760                         ast_log(LOG_WARNING, "Index found but not any type of call?\n");
1761                 }
1762         }
1763
1764
1765         if (!p->subs[SUB_REAL].owner && !p->subs[SUB_CALLWAIT].owner && !p->subs[SUB_THREEWAY].owner) {
1766                 p->owner = NULL;
1767                 p->ringt = 0;
1768                 p->distinctivering = 0;
1769                 p->confirmanswer = 0;
1770                 p->cidrings = 1;
1771                 p->outgoing = 0;
1772                 p->digital = 0;
1773                 p->faxhandled = 0;
1774                 p->pulsedial = 0;
1775                 p->onhooktime = time(NULL);
1776 #ifdef PRI_EVENT_PROCEEDING
1777                 p->proceeding = 0;
1778 #endif
1779 #ifdef PRI_EVENT_SETUP_ACK
1780                 p->setup_ack = 0;
1781 #endif
1782                 if (p->dsp) {
1783                         ast_dsp_free(p->dsp);
1784                         p->dsp = NULL;
1785                 }
1786
1787                 law = ZT_LAW_DEFAULT;
1788                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETLAW, &law);
1789                 if (res < 0) 
1790                         ast_log(LOG_WARNING, "Unable to set law on channel %d to default\n", p->channel);
1791                 /* Perform low level hangup if no owner left */
1792 #ifdef ZAPATA_PRI
1793                 if (p->sig == SIG_PRI) {
1794                         if (p->call) {
1795                                 if (!pri_grab(p, p->pri)) {
1796 #ifndef NEW_PRI_HANGUP
1797                                         if (!p->alreadyhungup) {
1798                                                 res = pri_disconnect(p->pri->pri, p->call, PRI_CAUSE_NORMAL_CLEARING);
1799                                         } else {
1800                                                 pri_release(p->pri->pri, p->call, -1);
1801                                                 p->call = NULL;
1802                                                 p->alreadyhungup = 0;
1803                                         }
1804 #else
1805 #ifndef PRI_HANGUP
1806 #error Please update libpri. The new hangup routines were implemented. You can debug then using "pri debug span <span_no>". If you dont want to update libpri code simply comment out OPTIONS += -DNEW_PRI_HANGUP in asterisk/Makefile
1807 #endif
1808                                         if (p->alreadyhungup) {
1809                                                 pri_hangup(p->pri->pri, p->call, -1);
1810                                                 p->call = NULL;
1811                                         } else {
1812                                                 char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE");
1813                                                 int icause = ast->hangupcause ? hangup_cause2pri(ast->hangupcause) : -1;
1814                                                 p->alreadyhungup = 1;
1815                                                 if (cause) {
1816                                                         if (atoi(cause))
1817                                                                 icause = atoi(cause);
1818                                                 }
1819                                                 pri_hangup(p->pri->pri, p->call, icause);
1820                                         }
1821 #endif
1822                                         if (res < 0) 
1823                                                 ast_log(LOG_WARNING, "pri_disconnect failed\n");
1824                                         pri_rel(p->pri);                        
1825                                 } else {
1826                                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
1827                                         res = -1;
1828                                 }
1829                         } else
1830                                 res = 0;
1831
1832                 } else 
1833 #endif
1834 #ifdef ZAPATA_R2
1835                 if (p->sig == SIG_R2) {
1836                         if (p->hasr2call) {
1837                                 mfcr2_DropCall(p->r2, NULL, UC_NORMAL_CLEARING);
1838                                 p->hasr2call = 0;
1839                                 res = 0;
1840                         } else
1841                                 res = 0;
1842
1843                 } else 
1844 #endif
1845                 if (p->sig)
1846                         res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_ONHOOK);
1847                 if (res < 0) {
1848                         ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name);
1849                 }
1850                 switch(p->sig) {
1851                 case SIG_FXOGS:
1852                 case SIG_FXOLS:
1853                 case SIG_FXOKS:
1854                         res = ioctl(p->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &par);
1855                         if (!res) {
1856 #if 0
1857                                 ast_log(LOG_DEBUG, "Hanging up channel %d, offhook = %d\n", p->channel, par.rxisoffhook);
1858 #endif
1859                                 /* If they're off hook, try playing congestion */
1860                                 if (par.rxisoffhook)
1861                                         tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_CONGESTION);
1862                                 else
1863                                         tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
1864                         }
1865                         break;
1866                 default:
1867                         tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
1868                 }
1869                 if (p->cidspill)
1870                         free(p->cidspill);
1871                 if (p->sig)
1872                         zt_disable_ec(p);
1873                 x = 0;
1874                 ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0);
1875                 ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0);
1876                 p->didtdd = 0;
1877                 p->cidspill = NULL;
1878                 p->callwaitcas = 0;
1879                 p->callwaiting = p->permcallwaiting;
1880                 p->hidecallerid = p->permhidecallerid;
1881                 p->dialing = 0;
1882                 strcpy(p->rdnis, "");
1883                 update_conf(p);
1884                 /* Restore data mode */
1885                 if (p->sig == SIG_PRI) {
1886                         x = 0;
1887                         ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
1888                 }
1889
1890                 restart_monitor();
1891         }
1892
1893
1894         p->callwaitingrepeat = 0;
1895         p->cidcwexpire = 0;
1896         ast->pvt->pvt = NULL;
1897         ast_mutex_unlock(&p->lock);
1898         ast_mutex_lock(&usecnt_lock);
1899         usecnt--;
1900         if (usecnt < 0) 
1901                 ast_log(LOG_WARNING, "Usecnt < 0???\n");
1902         ast_mutex_unlock(&usecnt_lock);
1903         ast_update_use_count();
1904         if (option_verbose > 2) 
1905                 ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);
1906
1907         ast_mutex_lock(&iflock);
1908         tmp = iflist;
1909         prev = NULL;
1910         if (p->destroy) {
1911                 while (tmp) {
1912                         if (tmp == p) {
1913                                 destroy_channel(prev, tmp, 0);
1914                                 break;
1915                         } else {
1916                                 prev = tmp;
1917                                 tmp = tmp->next;
1918                         }
1919                 }
1920         }
1921         ast_mutex_unlock(&iflock);
1922         return 0;
1923 }
1924
1925 static int zt_answer(struct ast_channel *ast)
1926 {
1927         struct zt_pvt *p = ast->pvt->pvt;
1928         int res=0;
1929         int index;
1930         int oldstate = ast->_state;
1931         ast_setstate(ast, AST_STATE_UP);
1932         ast_mutex_lock(&p->lock);
1933         index = zt_get_index(ast, p, 0);
1934         if (index < 0)
1935                 index = SUB_REAL;
1936         /* nothing to do if a radio channel */
1937         if (p->radio) {
1938                 ast_mutex_unlock(&p->lock);
1939                 return 0;
1940         }
1941         switch(p->sig) {
1942         case SIG_FXSLS:
1943         case SIG_FXSGS:
1944         case SIG_FXSKS:
1945                 p->ringt = 0;
1946                 /* Fall through */
1947         case SIG_EM:
1948         case SIG_EMWINK:
1949         case SIG_FEATD:
1950         case SIG_FEATDMF:
1951         case SIG_FEATB:
1952         case SIG_SF:
1953         case SIG_SFWINK:
1954         case SIG_SF_FEATD:
1955         case SIG_SF_FEATDMF:
1956         case SIG_SF_FEATB:
1957         case SIG_FXOLS:
1958         case SIG_FXOGS:
1959         case SIG_FXOKS:
1960                 /* Pick up the line */
1961                 ast_log(LOG_DEBUG, "Took %s off hook\n", ast->name);
1962                 res =  zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
1963                 tone_zone_play_tone(p->subs[index].zfd, -1);
1964                 p->dialing = 0;
1965                 if ((index == SUB_REAL) && p->subs[SUB_THREEWAY].inthreeway) {
1966                         if (oldstate == AST_STATE_RINGING) {
1967                                 ast_log(LOG_DEBUG, "Finally swapping real and threeway\n");
1968                                 tone_zone_play_tone(p->subs[SUB_THREEWAY].zfd, -1);
1969                                 swap_subs(p, SUB_THREEWAY, SUB_REAL);
1970                                 p->owner = p->subs[SUB_REAL].owner;
1971                         }
1972                 }
1973                 break;
1974 #ifdef ZAPATA_PRI
1975         case SIG_PRI:
1976                 /* Send a pri acknowledge */
1977                 if (!pri_grab(p, p->pri)) {
1978                         res = pri_answer(p->pri->pri, p->call, 0, 1);
1979                         pri_rel(p->pri);
1980                 } else {
1981                         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
1982                         res= -1;
1983                 }
1984                 break;
1985 #endif
1986 #ifdef ZAPATA_R2
1987         case SIG_R2:
1988                 res = mfcr2_AnswerCall(p->r2, NULL);
1989                 if (res)
1990                         ast_log(LOG_WARNING, "R2 Answer call failed :( on %s\n", ast->name);
1991                 break;
1992 #endif                  
1993         case 0:
1994                 ast_mutex_unlock(&p->lock);
1995                 return 0;
1996         default:
1997                 ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
1998                 res = -1;
1999         }
2000         ast_mutex_unlock(&p->lock);
2001         return res;
2002 }
2003
2004 static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen)
2005 {
2006 char    *cp;
2007 int     x;
2008
2009         struct zt_pvt *p = chan->pvt->pvt;
2010
2011         
2012         if ((option != AST_OPTION_TONE_VERIFY) && (option != AST_OPTION_AUDIO_MODE) &&
2013                 (option != AST_OPTION_TDD) && (option != AST_OPTION_RELAXDTMF))
2014            {
2015                 errno = ENOSYS;
2016                 return -1;
2017            }
2018         cp = (char *)data;
2019         if ((!cp) || (datalen < 1))
2020            {
2021                 errno = EINVAL;
2022                 return -1;
2023            }
2024         switch(option) {
2025             case AST_OPTION_TONE_VERIFY:
2026                 if (!p->dsp)
2027                         break;
2028                 switch(*cp) {
2029                     case 1:
2030                                 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF(1) on %s\n",chan->name);
2031                                 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | p->dtmfrelax);  /* set mute mode if desired */
2032                         break;
2033                     case 2:
2034                                 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF/MAX(2) on %s\n",chan->name);
2035                                 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX | p->dtmfrelax);  /* set mute mode if desired */
2036                         break;
2037                     default:
2038                                 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: OFF(0) on %s\n",chan->name);
2039                                 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);  /* set mute mode if desired */
2040                         break;
2041                 }
2042                 break;
2043             case AST_OPTION_TDD:  /* turn on or off TDD */
2044                 if (!*cp) { /* turn it off */
2045                         ast_log(LOG_DEBUG, "Set option TDD MODE, value: OFF(0) on %s\n",chan->name);
2046                         if (p->tdd) tdd_free(p->tdd);
2047                         p->tdd = 0;
2048                         p->mate = 0;
2049                         break;
2050                 }
2051                 if (*cp == 2)
2052                         ast_log(LOG_DEBUG, "Set option TDD MODE, value: MATE(2) on %s\n",chan->name);
2053                 else ast_log(LOG_DEBUG, "Set option TDD MODE, value: ON(1) on %s\n",chan->name);
2054                 p->mate = 0;
2055                 zt_disable_ec(p);
2056                 /* otherwise, turn it on */
2057                 if (!p->didtdd) { /* if havent done it yet */
2058                         unsigned char mybuf[41000],*buf;
2059                         int size,res,fd,len;
2060                         int index;
2061                         fd_set wfds,efds;
2062                         buf = mybuf;
2063                         memset(buf,0x7f,sizeof(mybuf)); /* set to silence */
2064                         ast_tdd_gen_ecdisa(buf + 16000,16000);  /* put in tone */
2065                         len = 40000;
2066                         index = zt_get_index(chan, p, 0);
2067                         if (index < 0) {
2068                                 ast_log(LOG_WARNING, "No index in TDD?\n");
2069                                 return -1;
2070                         }
2071                         fd = p->subs[index].zfd;
2072                         while(len) {
2073                                 if (ast_check_hangup(chan)) return -1;
2074                                 size = len;
2075                                 if (size > READ_SIZE)
2076                                         size = READ_SIZE;
2077                                 FD_ZERO(&wfds);
2078                                 FD_ZERO(&efds);
2079                                 FD_SET(fd,&wfds);
2080                                 FD_SET(fd,&efds);                       
2081                                 res = ast_select(fd + 1,NULL,&wfds,&efds,NULL);
2082                                 if (!res) {
2083                                         ast_log(LOG_DEBUG, "select (for write) ret. 0 on channel %d\n", p->channel);
2084                                         continue;
2085                                 }
2086                                   /* if got exception */
2087                                 if (FD_ISSET(fd,&efds)) return -1;
2088                                 if (!FD_ISSET(fd,&wfds)) {
2089                                         ast_log(LOG_DEBUG, "write fd not ready on channel %d\n", p->channel);
2090                                         continue;
2091                                 }
2092                                 res = write(fd, buf, size);
2093                                 if (res != size) {
2094                                         if (res == -1) return -1;
2095                                         ast_log(LOG_DEBUG, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
2096                                         break;
2097                                 }
2098                                 len -= size;
2099                                 buf += size;
2100                         }
2101                         p->didtdd = 1; /* set to have done it now */            
2102                 }
2103                 if (*cp == 2) { /* Mate mode */
2104                         if (p->tdd) tdd_free(p->tdd);
2105                         p->tdd = 0;
2106                         p->mate = 1;
2107                         break;
2108                         }               
2109                 if (!p->tdd) { /* if we dont have one yet */
2110                         p->tdd = tdd_new(); /* allocate one */
2111                 }               
2112                 break;
2113             case AST_OPTION_RELAXDTMF:  /* Relax DTMF decoding (or not) */
2114                 if (!*cp)
2115                 {               
2116                         ast_log(LOG_DEBUG, "Set option RELAX DTMF, value: OFF(0) on %s\n",chan->name);
2117                         x = 0;
2118                 }
2119                 else
2120                 {               
2121                         ast_log(LOG_DEBUG, "Set option RELAX DTMF, value: ON(1) on %s\n",chan->name);
2122                         x = 1;
2123                 }
2124                 ast_dsp_digitmode(p->dsp,x ? DSP_DIGITMODE_RELAXDTMF : DSP_DIGITMODE_DTMF | p->dtmfrelax);
2125                 break;
2126             case AST_OPTION_AUDIO_MODE:  /* Set AUDIO mode (or not) */
2127                 if (!*cp)
2128                 {               
2129                         ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: OFF(0) on %s\n",chan->name);
2130                         x = 0;
2131                         zt_disable_ec(p);
2132                 }
2133                 else
2134                 {               
2135                         ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: ON(1) on %s\n",chan->name);
2136                         x = 1;
2137                 }
2138                 if (ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x) == -1)
2139                         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d\n", p->channel, x);
2140                 break;
2141         }
2142         errno = 0;
2143         return 0;
2144 }
2145
2146 static void zt_unlink(struct zt_pvt *slave, struct zt_pvt *master)
2147 {
2148         /* Unlink a specific slave or all slaves/masters from a given master */
2149         int x;
2150         int hasslaves;
2151         if (!master)
2152                 return;
2153         hasslaves = 0;
2154         for (x=0;x<MAX_SLAVES;x++) {
2155                 if (master->slaves[x]) {
2156                         if (!slave || (master->slaves[x] == slave)) {
2157                                 /* Take slave out of the conference */
2158                                 ast_log(LOG_DEBUG, "Unlinking slave %d from %d\n", master->slaves[x]->channel, master->channel);
2159                                 conf_del(master, &master->slaves[x]->subs[SUB_REAL], SUB_REAL);
2160                                 conf_del(master->slaves[x], &master->subs[SUB_REAL], SUB_REAL);
2161                                 master->slaves[x]->master = NULL;
2162                                 master->slaves[x] = NULL;
2163                         } else
2164                                 hasslaves = 1;
2165                 }
2166                 if (!hasslaves)
2167                         master->inconference = 0;
2168         }
2169         if (!slave) {
2170                 if (master->master) {
2171                         /* Take master out of the conference */
2172                         conf_del(master->master, &master->subs[SUB_REAL], SUB_REAL);
2173                         conf_del(master, &master->master->subs[SUB_REAL], SUB_REAL);
2174                         hasslaves = 0;
2175                         for (x=0;x<MAX_SLAVES;x++) {
2176                                 if (master->master->slaves[x] == master)
2177                                         master->master->slaves[x] = NULL;
2178                                 else if (master->master->slaves[x])
2179                                         hasslaves = 1;
2180                         }
2181                         if (!hasslaves)
2182                                 master->master->inconference = 0;
2183                 }
2184                 master->master = NULL;
2185         }
2186         update_conf(master);
2187 }
2188
2189 static void zt_link(struct zt_pvt *slave, struct zt_pvt *master) {
2190         int x;
2191         if (!slave || !master) {
2192                 ast_log(LOG_WARNING, "Tried to link to/from NULL??\n");
2193                 return;
2194         }
2195         for (x=0;x<MAX_SLAVES;x++) {
2196                 if (!master->slaves[x]) {
2197                         master->slaves[x] = slave;
2198                         break;
2199                 }
2200         }
2201         if (x >= MAX_SLAVES) {
2202                 ast_log(LOG_WARNING, "Replacing slave %d with new slave, %d\n", master->slaves[MAX_SLAVES - 1]->channel, slave->channel);
2203                 master->slaves[MAX_SLAVES - 1] = slave;
2204         }
2205         if (slave->master) 
2206                 ast_log(LOG_WARNING, "Replacing master %d with new master, %d\n", slave->master->channel, master->channel);
2207         slave->master = master;
2208         
2209         ast_log(LOG_DEBUG, "Making %d slave to master %d at %d\n", slave->channel, master->channel, x);
2210 }
2211
2212 static int zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
2213 {
2214         struct ast_channel *who = NULL, *cs[3];
2215         struct zt_pvt *p0, *p1, *op0, *op1;
2216         struct zt_pvt *master=NULL, *slave=NULL;
2217         struct ast_frame *f;
2218         int to;
2219         int inconf = 0;
2220         int nothingok = 0;
2221         int ofd1, ofd2;
2222         int oi1, oi2, i1 = -1, i2 = -1, t1, t2;
2223         int os1 = -1, os2 = -1;
2224         struct ast_channel *oc1, *oc2;
2225
2226         /* if need DTMF, cant native bridge */
2227         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
2228                 return -2;
2229                 
2230         ast_mutex_lock(&c0->lock);
2231         ast_mutex_lock(&c1->lock);
2232
2233         p0 = c0->pvt->pvt;
2234         p1 = c1->pvt->pvt;
2235         /* cant do pseudo-channels here */
2236         if (!p0 || (!p0->sig) || !p1 || (!p1->sig)) {
2237                 ast_mutex_unlock(&c0->lock);
2238                 ast_mutex_unlock(&c1->lock);
2239                 return -2;
2240         }
2241
2242         op0 = p0 = c0->pvt->pvt;
2243         op1 = p1 = c1->pvt->pvt;
2244         ofd1 = c0->fds[0];
2245         ofd2 = c1->fds[0];
2246         oi1 = zt_get_index(c0, p0, 0);
2247         oi2 = zt_get_index(c1, p1, 0);
2248         oc1 = p0->owner;
2249         oc2 = p1->owner;
2250         if ((oi1 < 0) || (oi2 < 0))
2251                 return -1;
2252
2253
2254
2255         ast_mutex_lock(&p0->lock);
2256         if (ast_mutex_trylock(&p1->lock)) {
2257                 /* Don't block, due to potential for deadlock */
2258                 ast_mutex_unlock(&p0->lock);
2259                 ast_mutex_unlock(&c0->lock);
2260                 ast_mutex_unlock(&c1->lock);
2261                 ast_log(LOG_NOTICE, "Avoiding deadlock...\n");
2262                 return -3;
2263         }
2264         if ((oi1 == SUB_REAL) && (oi2 == SUB_REAL)) {
2265                 if (!p0->owner || !p1->owner) {
2266                         /* Currently unowned -- Do nothing.  */
2267                         nothingok = 1;
2268                 } else {
2269                         /* If we don't have a call-wait in a 3-way, and we aren't in a 3-way, we can be master */
2270                         if (!p0->subs[SUB_CALLWAIT].inthreeway && !p1->subs[SUB_REAL].inthreeway) {
2271                                 master = p0;
2272                                 slave = p1;
2273                                 inconf = 1;
2274                         } else if (!p1->subs[SUB_CALLWAIT].inthreeway && !p0->subs[SUB_REAL].inthreeway) {
2275                                 master = p1;
2276                                 slave = p0;
2277                                 inconf = 1;
2278                         } else {
2279                                 ast_log(LOG_WARNING, "Huh?  Both calls are callwaits or 3-ways?  That's clever...?\n");
2280                                 ast_log(LOG_WARNING, "p0: chan %d/%d/CW%d/3W%d, p1: chan %d/%d/CW%d/3W%d\n", p0->channel, oi1, (p0->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0, p0->subs[SUB_REAL].inthreeway,
2281                                                 p0->channel, oi1, (p1->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0, p1->subs[SUB_REAL].inthreeway);
2282                         }
2283                 }
2284         } else if ((oi1 == SUB_REAL) && (oi2 == SUB_THREEWAY)) {
2285                 if (p1->subs[SUB_THREEWAY].inthreeway) {
2286                         master = p1;
2287                         slave = p0;
2288                 } else {
2289                         nothingok = 1;
2290                 }
2291         } else if ((oi1 == SUB_THREEWAY) && (oi2 == SUB_REAL)) {
2292                 if (p0->subs[SUB_THREEWAY].inthreeway) {
2293                         master = p0;
2294                         slave = p1;
2295                 } else {
2296                         nothingok  = 1;
2297                 }
2298         } else if ((oi1 == SUB_REAL) && (oi2 == SUB_CALLWAIT)) {
2299                 /* We have a real and a call wait.  If we're in a three way call, put us in it, otherwise, 
2300                    don't put us in anything */
2301                 if (p1->subs[SUB_CALLWAIT].inthreeway) {
2302                         master = p1;
2303                         slave = p0;
2304                 } else {
2305                         nothingok = 1;
2306                 }
2307         } else if ((oi1 == SUB_CALLWAIT) && (oi2 == SUB_REAL)) {
2308                 /* Same as previous */
2309                 if (p0->subs[SUB_CALLWAIT].inthreeway) {
2310                         master = p0;
2311                         slave = p1;
2312                 } else {
2313                         nothingok = 1;
2314                 }
2315         }
2316         ast_log(LOG_DEBUG, "master: %d, slave: %d, nothingok: %d\n",
2317                 master ? master->channel : 0, slave ? slave->channel : 0, nothingok);
2318         if (master && slave) {
2319                 /* Stop any tones, or play ringtone as appropriate.  If they're bridged
2320                    in an active threeway call with a channel that is ringing, we should
2321                    indicate ringing. */
2322                 if ((oi2 == SUB_THREEWAY) && 
2323                         p1->subs[SUB_THREEWAY].inthreeway && 
2324                         p1->subs[SUB_REAL].owner && 
2325                         p1->subs[SUB_REAL].inthreeway && 
2326                         (p1->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
2327                                 ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c0->name, c1->name);
2328                                 tone_zone_play_tone(p0->subs[oi1].zfd, ZT_TONE_RINGTONE);
2329                                 os2 = p1->subs[SUB_REAL].owner->_state;
2330                 } else {
2331                                 ast_log(LOG_DEBUG, "Stoping tones on %d/%d talking to %d/%d\n", p0->channel, oi1, p1->channel, oi2);
2332                                 tone_zone_play_tone(p0->subs[oi1].zfd, -1);
2333                 }
2334                 if ((oi1 == SUB_THREEWAY) && 
2335                         p0->subs[SUB_THREEWAY].inthreeway && 
2336                         p0->subs[SUB_REAL].owner && 
2337                         p0->subs[SUB_REAL].inthreeway && 
2338                         (p0->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
2339                                 ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c1->name, c0->name);
2340                                 tone_zone_play_tone(p1->subs[oi2].zfd, ZT_TONE_RINGTONE);
2341                                 os1 = p0->subs[SUB_REAL].owner->_state;
2342                 } else {
2343                                 ast_log(LOG_DEBUG, "Stoping tones on %d/%d talking to %d/%d\n", p1->channel, oi2, p0->channel, oi1);
2344                                 tone_zone_play_tone(p1->subs[oi1].zfd, -1);
2345                 }
2346                 if ((oi1 == SUB_REAL) && (oi2 == SUB_REAL)) {
2347                         if (!p0->echocanbridged || !p1->echocanbridged) {
2348                                 /* Disable echo cancellation if appropriate */
2349                                 zt_disable_ec(p0);
2350                                 zt_disable_ec(p1);
2351                         }
2352                 }
2353                 zt_link(slave, master);
2354                 master->inconference = inconf;
2355         } else if (!nothingok)
2356                 ast_log(LOG_WARNING, "Can't link %d/%s with %d/%s\n", p0->channel, subnames[oi1], p1->channel, subnames[oi2]);
2357
2358         update_conf(p0);
2359         update_conf(p1);
2360         t1 = p0->subs[SUB_REAL].inthreeway;
2361         t2 = p1->subs[SUB_REAL].inthreeway;
2362
2363         ast_mutex_unlock(&p0->lock);
2364         ast_mutex_unlock(&p1->lock);
2365
2366         ast_mutex_unlock(&c0->lock);
2367         ast_mutex_unlock(&c1->lock);
2368
2369         /* Native bridge failed */
2370         if ((!master || !slave) && !nothingok) {
2371                 if (op0 == p0)
2372                         zt_enable_ec(p0);
2373                 if (op1 == p1)
2374                         zt_enable_ec(p1);
2375                 return -1;
2376         }
2377         
2378         cs[0] = c0;
2379         cs[1] = c1;
2380         cs[2] = NULL;
2381         for (;;) {
2382                 /* Here's our main loop...  Start by locking things, looking for private parts, 
2383                    and then balking if anything is wrong */
2384                 ast_mutex_lock(&c0->lock);
2385                 ast_mutex_lock(&c1->lock);
2386                 p0 = c0->pvt->pvt;
2387                 p1 = c1->pvt->pvt;
2388                 if (op0 == p0)
2389                         i1 = zt_get_index(c0, p0, 1);
2390                 if (op1 == p1)
2391                         i2 = zt_get_index(c1, p1, 1);
2392                 ast_mutex_unlock(&c0->lock);
2393                 ast_mutex_unlock(&c1->lock);
2394                 if ((op0 != p0) || (op1 != p1) || 
2395                     (ofd1 != c0->fds[0]) || 
2396                         (ofd2 != c1->fds[0]) ||
2397                     (p0->subs[SUB_REAL].owner && (os1 > -1) && (os1 != p0->subs[SUB_REAL].owner->_state)) || 
2398                     (p1->subs[SUB_REAL].owner && (os2 > -1) && (os2 != p1->subs[SUB_REAL].owner->_state)) || 
2399                     (oc1 != p0->owner) || 
2400                         (oc2 != p1->owner) ||
2401                         (t1 != p0->subs[SUB_REAL].inthreeway) ||
2402                         (t2 != p1->subs[SUB_REAL].inthreeway) ||
2403                         (oi1 != i1) ||
2404                         (oi2 != i2)) {
2405                         if (slave && master)
2406                                 zt_unlink(slave, master);
2407                         ast_log(LOG_DEBUG, "Something changed out on %d/%d to %d/%d, returning -3 to restart\n",
2408                                                                         op0->channel, oi1, op1->channel, oi2);
2409                         if (op0 == p0)
2410                                 zt_enable_ec(p0);
2411                         if (op1 == p1)
2412                                 zt_enable_ec(p1);
2413                         return -3;
2414                 }
2415                 to = -1;
2416                 who = ast_waitfor_n(cs, 2, &to);
2417                 if (!who) {
2418                         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
2419                         continue;
2420                 }
2421                 if (who->pvt->pvt == op0) 
2422                         op0->ignoredtmf = 1;
2423                 else if (who->pvt->pvt == op1)
2424                         op1->ignoredtmf = 1;
2425                 f = ast_read(who);
2426                 if (who->pvt->pvt == op0) 
2427                         op0->ignoredtmf = 0;
2428                 else if (who->pvt->pvt == op1)
2429                         op1->ignoredtmf = 0;
2430                 if (!f) {
2431                         *fo = NULL;
2432                         *rc = who;
2433                         if (slave && master)
2434                                 zt_unlink(slave, master);
2435                         if (op0 == p0)
2436                                 zt_enable_ec(p0);
2437                         if (op1 == p1)
2438                                 zt_enable_ec(p1);
2439                         return 0;
2440                 }
2441                 if (f->frametype == AST_FRAME_DTMF) {
2442                         if (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) || 
2443                             ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))) {
2444                                 *fo = f;
2445                                 *rc = who;
2446                                 if (slave && master)
2447                                         zt_unlink(slave, master);
2448                                 return 0;
2449                         } else if ((who == c0) && p0->pulsedial) {
2450                                 ast_write(c1, f);
2451                         } else if ((who == c1) && p1->pulsedial) {
2452                                 ast_write(c0, f);
2453                         }
2454                 }
2455                 ast_frfree(f);
2456
2457                 /* Swap who gets priority */
2458                 cs[2] = cs[0];
2459                 cs[0] = cs[1];
2460                 cs[1] = cs[2];
2461         }
2462 }
2463
2464 static int zt_indicate(struct ast_channel *chan, int condition);
2465
2466 static int zt_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
2467 {
2468         struct zt_pvt *p = newchan->pvt->pvt;
2469         int x;
2470         ast_log(LOG_DEBUG, "New owner for channel %d is %s\n", p->channel, newchan->name);
2471         if (p->owner == oldchan)
2472                 p->owner = newchan;
2473         for (x=0;x<3;x++)
2474                 if (p->subs[x].owner == oldchan) {
2475                         if (!x)
2476                                 zt_unlink(NULL, p);
2477                         p->subs[x].owner = newchan;
2478                 }
2479         if (newchan->_state == AST_STATE_RINGING) 
2480                 zt_indicate(newchan, AST_CONTROL_RINGING);
2481         update_conf(p);
2482         return 0;
2483 }
2484
2485 static int zt_ring_phone(struct zt_pvt *p)
2486 {
2487         int x;
2488         int res;
2489         /* Make sure our transmit state is on hook */
2490         x = 0;
2491         x = ZT_ONHOOK;
2492         res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2493         do {
2494                 x = ZT_RING;
2495                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2496 #if 0
2497                 printf("Res: %d, error: %s\n", res, strerror(errno));
2498 #endif                                          
2499                 if (res) {
2500                         switch(errno) {
2501                         case EBUSY:
2502                         case EINTR:
2503                                 /* Wait just in case */
2504                                 usleep(10000);
2505                                 continue;
2506                         case EINPROGRESS:
2507                                 res = 0;
2508                                 break;
2509                         default:
2510                                 ast_log(LOG_WARNING, "Couldn't ring the phone: %s\n", strerror(errno));
2511                                 res = 0;
2512                         }
2513                 }
2514         } while (res);
2515         return res;
2516 }
2517
2518 static void *ss_thread(void *data);
2519
2520 static struct ast_channel *zt_new(struct zt_pvt *, int, int, int, int, int);
2521
2522 static int attempt_transfer(struct zt_pvt *p)
2523 {
2524         /* In order to transfer, we need at least one of the channels to
2525            actually be in a call bridge.  We can't conference two applications
2526            together (but then, why would we want to?) */
2527         if (p->subs[SUB_REAL].owner->bridge) {
2528                 /* The three-way person we're about to transfer to could still be in MOH, so
2529                    stop if now if appropriate */
2530                 if (p->subs[SUB_THREEWAY].owner->bridge)
2531                         ast_moh_stop(p->subs[SUB_THREEWAY].owner->bridge);
2532                 if (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_RINGING) {
2533                         ast_indicate(p->subs[SUB_REAL].owner->bridge, AST_CONTROL_RINGING);
2534                 }
2535                 if (ast_channel_masquerade(p->subs[SUB_THREEWAY].owner, p->subs[SUB_REAL].owner->bridge)) {
2536                         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
2537                                         p->subs[SUB_REAL].owner->bridge->name, p->subs[SUB_THREEWAY].owner->name);
2538                         return -1;
2539                 }
2540                 /* Orphan the channel */
2541                 unalloc_sub(p, SUB_THREEWAY);
2542         } else if (p->subs[SUB_THREEWAY].owner->bridge) {
2543                 if (p->subs[SUB_REAL].owner->_state == AST_STATE_RINGING) {
2544                         ast_indicate(p->subs[SUB_THREEWAY].owner->bridge, AST_CONTROL_RINGING);
2545                 }
2546                 ast_moh_stop(p->subs[SUB_THREEWAY].owner->bridge);
2547                 if (ast_channel_masquerade(p->subs[SUB_REAL].owner, p->subs[SUB_THREEWAY].owner->bridge)) {
2548                         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
2549                                         p->subs[SUB_THREEWAY].owner->bridge->name, p->subs[SUB_REAL].owner->name);
2550                         return -1;
2551                 }
2552                 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2553                 unalloc_sub(p, SUB_THREEWAY);
2554                 /* Tell the caller not to hangup */
2555                 return 1;
2556         } else {
2557                 ast_log(LOG_DEBUG, "Neither %s nor %s are in a bridge, nothing to transfer\n",
2558                                         p->subs[SUB_REAL].owner->name, p->subs[SUB_THREEWAY].owner->name);
2559                 p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
2560         }
2561         return 0;
2562 }
2563
2564 #ifdef ZAPATA_R2
2565 static struct ast_frame *handle_r2_event(struct zt_pvt *p, mfcr2_event_t *e, int index)
2566 {
2567         struct ast_frame *f;
2568         f = &p->subs[index].f;
2569         if (!p->r2) {
2570                 ast_log(LOG_WARNING, "Huh?  No R2 structure :(\n");
2571                 return NULL;
2572         }
2573         switch(e->e) {
2574         case MFCR2_EVENT_BLOCKED:
2575                 if (option_verbose > 2)
2576                         ast_verbose(VERBOSE_PREFIX_3 "Channel %d blocked\n", p->channel);
2577                 break;
2578         case MFCR2_EVENT_UNBLOCKED:
2579                 if (option_verbose > 2)
2580                         ast_verbose(VERBOSE_PREFIX_3 "Channel %d unblocked\n", p->channel);
2581                 break;
2582         case MFCR2_EVENT_CONFIG_ERR:
2583                 if (option_verbose > 2)
2584                         ast_verbose(VERBOSE_PREFIX_3 "Config error on channel %d\n", p->channel);
2585                 break;
2586         case MFCR2_EVENT_RING:
2587                 if (option_verbose > 2)
2588                         ast_verbose(VERBOSE_PREFIX_3 "Ring on channel %d\n", p->channel);
2589                 break;
2590         case MFCR2_EVENT_HANGUP:
2591                 if (option_verbose > 2)
2592                         ast_verbose(VERBOSE_PREFIX_3 "Hangup on channel %d\n", p->channel);
2593                 break;
2594         case MFCR2_EVENT_RINGING:
2595                 if (option_verbose > 2)
2596                         ast_verbose(VERBOSE_PREFIX_3 "Ringing on channel %d\n", p->channel);
2597                 break;
2598         case MFCR2_EVENT_ANSWER:
2599                 if (option_verbose > 2)
2600                         ast_verbose(VERBOSE_PREFIX_3 "Answer on channel %d\n", p->channel);
2601                 break;
2602         case MFCR2_EVENT_HANGUP_ACK:
2603                 if (option_verbose > 2)
2604                         ast_verbose(VERBOSE_PREFIX_3 "Hangup ACK on channel %d\n", p->channel);
2605                 break;
2606         case MFCR2_EVENT_IDLE:
2607                 if (option_verbose > 2)
2608                         ast_verbose(VERBOSE_PREFIX_3 "Idle on channel %d\n", p->channel);
2609                 break;
2610         default:
2611                 ast_log(LOG_WARNING, "Unknown MFC/R2 event %d\n", e->e);
2612                 break;
2613         }
2614         return f;
2615 }
2616
2617 static mfcr2_event_t *r2_get_event_bits(struct zt_pvt *p)
2618 {
2619         int x;
2620         int res;
2621         mfcr2_event_t *e;
2622         res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETRXBITS, &x);
2623         if (res) {
2624                 ast_log(LOG_WARNING, "Unable to check received bits\n");
2625                 return NULL;
2626         }
2627         if (!p->r2) {
2628                 ast_log(LOG_WARNING, "Odd, no R2 structure on channel %d\n", p->channel);
2629                 return NULL;
2630         }
2631         e = mfcr2_cas_signaling_event(p->r2, x);
2632         return e;
2633 }
2634 #endif
2635
2636 static int check_for_conference(struct zt_pvt *p)
2637 {
2638         ZT_CONFINFO ci;
2639         /* Fine if we already have a master, etc */
2640         if (p->master || (p->confno > -1))
2641                 return 0;
2642         memset(&ci, 0, sizeof(ci));
2643         if (ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &ci)) {
2644                 ast_log(LOG_WARNING, "Failed to get conference info on channel %d\n", p->channel);
2645                 return 0;
2646         }
2647         /* If we have no master and don't have a confno, then 
2648            if we're in a conference, it's probably a MeetMe room or
2649            some such, so don't let us 3-way out! */
2650         if ((p->subs[SUB_REAL].curconf.confno != ci.confno) || (p->subs[SUB_REAL].curconf.confmode != ci.confmode)) {
2651                 if (option_verbose > 2) 
2652                         ast_verbose(VERBOSE_PREFIX_3 "Avoiding 3-way call when in an external conference\n");
2653                 return 1;
2654         }
2655         return 0;
2656 }
2657
2658 static int get_alarms(struct zt_pvt *p)
2659 {
2660         int res;
2661         ZT_SPANINFO zi;
2662         memset(&zi, 0, sizeof(zi));
2663         zi.spanno = p->span;
2664         res = ioctl(p->subs[SUB_REAL].zfd, ZT_SPANSTAT, &zi);
2665         if (res < 0) {
2666                 ast_log(LOG_WARNING, "Unable to determine alarm on channel %d\n", p->channel);
2667                 return 0;
2668         }
2669         return zi.alarms;
2670 }
2671                         
2672 static struct ast_frame *zt_handle_event(struct ast_channel *ast)
2673 {
2674         int res,x;
2675         int index;
2676         struct zt_pvt *p = ast->pvt->pvt;
2677         pthread_t threadid;
2678         pthread_attr_t attr;
2679         struct ast_channel *chan;
2680         pthread_attr_init(&attr);
2681         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2682         index = zt_get_index(ast, p, 0);
2683         p->subs[index].f.frametype = AST_FRAME_NULL;
2684         p->subs[index].f.datalen = 0;
2685         p->subs[index].f.samples = 0;
2686         p->subs[index].f.mallocd = 0;
2687         p->subs[index].f.offset = 0;
2688         p->subs[index].f.src = "zt_handle_event";
2689         p->subs[index].f.data = NULL;
2690         if (index < 0)
2691                 return &p->subs[index].f;
2692         if (p->fake_event) {
2693                 res = p->fake_event;
2694                 p->fake_event = 0;
2695         } else
2696                 res = zt_get_event(p->subs[index].zfd);
2697         ast_log(LOG_DEBUG, "Got event %s(%d) on channel %d (index %d)\n", event2str(res), res, p->channel, index);
2698         if (res & (ZT_EVENT_PULSEDIGIT | ZT_EVENT_DTMFDIGIT)) {
2699                 if (res & ZT_EVENT_PULSEDIGIT)
2700                         p->pulsedial = 1;
2701                 else
2702                         p->pulsedial = 0;
2703                 ast_log(LOG_DEBUG, "Pulse dial '%c'\n", res & 0xff);
2704                 p->subs[index].f.frametype = AST_FRAME_DTMF;
2705                 p->subs[index].f.subclass = res & 0xff;
2706                 /* Return the captured digit */
2707                 return &p->subs[index].f;
2708         }
2709         switch(res) {
2710                 case ZT_EVENT_BITSCHANGED:
2711                         if (p->sig == SIG_R2) {
2712 #ifdef ZAPATA_R2
2713                                 struct ast_frame  *f = &p->subs[index].f;
2714                                 mfcr2_event_t *e;
2715                                 e = r2_get_event_bits(p);
2716                                 if (e)
2717                                         f = handle_r2_event(p, e, index);
2718                                 return f;
2719 #else                           
2720                                 break;
2721 #endif
2722                         }
2723                         ast_log(LOG_WARNING, "Recieved bits changed on %s signalling?\n", sig2str(p->sig));
2724                 case ZT_EVENT_PULSE_START:
2725                         /* Stop tone if there's a pulse start and the PBX isn't started */
2726                         if (!ast->pbx)
2727                                 tone_zone_play_tone(p->subs[index].zfd, -1);
2728                         break;  
2729                 case ZT_EVENT_DIALCOMPLETE:
2730                         if (p->inalarm) break;
2731                         if (p->radio) break;
2732                         if (ioctl(p->subs[index].zfd,ZT_DIALING,&x) == -1) {
2733                                 ast_log(LOG_DEBUG, "ZT_DIALING ioctl failed on %s\n",ast->name);
2734                                 return NULL;
2735                         }
2736                         if (!x) { /* if not still dialing in driver */
2737                                 zt_enable_ec(p);
2738                                 if (p->echobreak) {
2739                                         zt_train_ec(p);
2740                                         strcpy(p->dop.dialstr, p->echorest);
2741                                         p->dop.op = ZT_DIAL_OP_REPLACE;
2742                                         res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
2743                                         p->echobreak = 0;
2744                                 } else {
2745                                         p->dialing = 0;
2746                                         if (ast->_state == AST_STATE_DIALING) {
2747                                                 if (p->callprogress && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
2748                                                         ast_log(LOG_DEBUG, "Done dialing, but waiting for progress detection before doing more...\n");
2749                                                 } else if (p->confirmanswer || (!p->dialednone && ((p->sig == SIG_EM) || (p->sig == SIG_EMWINK) || (p->sig == SIG_FEATD) || (p->sig == SIG_FEATDMF) || (p->sig == SIG_FEATB) || (p->sig == SIG_SF) || (p->sig == SIG_SFWINK) || (p->sig == SIG_SF_FEATD) || (p->sig == SIG_SF_FEATDMF) || (p->sig == SIG_SF_FEATB)))) {
2750                                                         ast_setstate(ast, AST_STATE_RINGING);
2751                                                 } else {
2752                                                         ast_setstate(ast, AST_STATE_UP);
2753                                                         p->subs[index].f.frametype = AST_FRAME_CONTROL;
2754                                                         p->subs[index].f.subclass = AST_CONTROL_ANSWER;
2755                                                 }
2756                                         }
2757                                 }
2758                         }
2759                         break;
2760                 case ZT_EVENT_ALARM:
2761 #ifdef ZAPATA_PRI
2762 #ifdef PRI_DESTROYCALL
2763                         if (p->call) {
2764                                 if (p->pri && p->pri->pri) {
2765                                         pri_hangup(p->pri->pri, p->call, -1);
2766                                         pri_destroycall(p->pri->pri, p->call);
2767                                 } else
2768                                         ast_log(LOG_WARNING, "The PRI Call have not been destroyed\n");
2769                         }
2770                         if (p->owner)
2771                                 p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
2772                         p->call = NULL;
2773 #else
2774 #error Please "cvs update" and recompile libpri
2775 #endif
2776 #endif
2777                         p->inalarm = 1;
2778                         res = get_alarms(p);
2779                         ast_log(LOG_WARNING, "Detected alarm on channel %d: %s\n", p->channel, alarm2str(res));
2780                         manager_event(EVENT_FLAG_SYSTEM, "Alarm",
2781                                                                 "Alarm: %s\r\n"
2782                                                                 "Channel: %d\r\n",
2783                                                                 alarm2str(res), p->channel);
2784                         /* fall through intentionally */
2785                 case ZT_EVENT_ONHOOK:
2786                         if (p->radio)
2787                         {
2788                                 p->subs[index].f.frametype = AST_FRAME_CONTROL;
2789                                 p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY;
2790                                 break;
2791                         }
2792                         switch(p->sig) {
2793                         case SIG_FXOLS:
2794                         case SIG_FXOGS:
2795                         case SIG_FXOKS:
2796                                 p->onhooktime = time(NULL);
2797                                 p->msgstate = -1;
2798                                 /* Check for some special conditions regarding call waiting */
2799                                 if (index == SUB_REAL) {
2800                                         /* The normal line was hung up */
2801                                         if (p->subs[SUB_CALLWAIT].owner) {
2802                                                 /* There's a call waiting call, so ring the phone, but make it unowned in the mean time */
2803                                                 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
2804                                                 if (option_verbose > 2) 
2805                                                         ast_verbose(VERBOSE_PREFIX_3 "Channel %d still has (callwait) call, ringing phone\n", p->channel);
2806                                                 unalloc_sub(p, SUB_CALLWAIT);   
2807 #if 0
2808                                                 p->subs[index].needanswer = 0;
2809                                                 p->subs[index].needringing = 0;
2810 #endif                                          
2811                                                 p->callwaitingrepeat = 0;
2812                                                 p->cidcwexpire = 0;
2813                                                 p->owner = NULL;
2814                                                 zt_ring_phone(p);
2815                                         } else if (p->subs[SUB_THREEWAY].owner) {
2816                                                 struct timeval tv;
2817                                                 unsigned int mssinceflash;
2818                                                 gettimeofday(&tv, NULL);
2819                                                 mssinceflash = (tv.tv_sec - p->flashtime.tv_sec) * 1000 + (tv.tv_usec - p->flashtime.tv_usec) / 1000;
2820                                                 ast_log(LOG_DEBUG, "Last flash was %d ms ago\n", mssinceflash);
2821                                                 if (mssinceflash < MIN_MS_SINCE_FLASH) {
2822                                                         /* It hasn't been long enough since the last flashook.  This is probably a bounce on 
2823                                                            hanging up.  Hangup both channels now */
2824                                                         if (p->subs[SUB_THREEWAY].owner)
2825                                                                 ast_queue_hangup(p->subs[SUB_THREEWAY].owner, 0);
2826                                                         p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
2827                                                         ast_log(LOG_DEBUG, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
2828                                                 } else if ((ast->pbx) ||
2829                                                         (ast->_state == AST_STATE_UP)) {
2830                                                         if (p->transfer) {
2831                                                                 /* In any case this isn't a threeway call anymore */
2832                                                                 p->subs[SUB_REAL].inthreeway = 0;
2833                                                                 p->subs[SUB_THREEWAY].inthreeway = 0;
2834                                                                 if ((res = attempt_transfer(p)) < 0)
2835                                                                         p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
2836                                                                 else if (res) {
2837                                                                         /* Don't actually hang up at this point */
2838                                                                         break;
2839                                                                 }
2840                                                         } else
2841                                                                 p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
2842                                                 } else {
2843                                                         /* Swap subs and dis-own channel */
2844                                                         swap_subs(p, SUB_THREEWAY, SUB_REAL);
2845                                                         p->owner = NULL;
2846                                                         /* Ring the phone */
2847                                                         zt_ring_phone(p);
2848                                                 }
2849                                         }
2850                                 } else {
2851                                         ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", index);
2852                                 }
2853                                 /* Fall through */
2854                         default:
2855                                 zt_disable_ec(p);
2856                                 return NULL;
2857                         }
2858                         break;
2859                 case ZT_EVENT_RINGOFFHOOK:
2860                         if (p->inalarm) break;
2861                         if (p->radio)
2862                         {
2863                                 p->subs[index].f.frametype = AST_FRAME_CONTROL;
2864                                 p->subs[index].f.subclass = AST_CONTROL_RADIO_KEY;
2865                                 break;
2866                         }
2867                         switch(p->sig) {
2868                         case SIG_FXOLS:
2869                         case SIG_FXOGS:
2870                         case SIG_FXOKS:
2871                                 switch(ast->_state) {
2872                                 case AST_STATE_RINGING:
2873                                         zt_enable_ec(p);
2874                                         zt_train_ec(p);
2875                                         p->subs[index].f.frametype = AST_FRAME_CONTROL;
2876                                         p->subs[index].f.subclass = AST_CONTROL_ANSWER;
2877                                         /* Make sure it stops ringing */
2878                                         zt_set_hook(p->subs[index].zfd, ZT_OFFHOOK);
2879                                         ast_log(LOG_DEBUG, "channel %d answered\n", p->channel);
2880                                         if (p->cidspill) {
2881                                                 /* Cancel any running CallerID spill */
2882                                                 free(p->cidspill);
2883                                                 p->cidspill = NULL;
2884                                         }
2885                                         p->dialing = 0;
2886                                         p->callwaitcas = 0;
2887                                         if (p->confirmanswer) {
2888                                                 /* Ignore answer if "confirm answer" is selected */
2889                                                 p->subs[index].f.frametype = AST_FRAME_NULL;
2890                                                 p->subs[index].f.subclass = 0;
2891                                         } else if (strlen(p->dop.dialstr)) {
2892                                                 /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */
2893                                                 res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
2894                                                 if (res < 0) {
2895                                                   ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d\n", p->channel);
2896                                                   p->dop.dialstr[0] = '\0';
2897                                                   return NULL;
2898                                                 } else {
2899                                                   ast_log(LOG_DEBUG, "Sent FXO deferred digit string: %s\n", p->dop.dialstr);
2900                                                   p->subs[index].f.frametype = AST_FRAME_NULL;
2901                                                   p->subs[index].f.subclass = 0;
2902                                                   p->dialing = 1;
2903                                                 }
2904                                                 p->dop.dialstr[0] = '\0';
2905                                            ast_setstate(ast, AST_STATE_DIALING);
2906                                         } else
2907                                            ast_setstate(ast, AST_STATE_UP);
2908                                         return &p->subs[index].f;
2909                                 case AST_STATE_DOWN:
2910                                         ast_setstate(ast, AST_STATE_RING);