2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2006, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
21 * \brief Zaptel Pseudo TDM interface
23 * \author Mark Spencer <markster@digium.com>
25 * Connects to the zaptel telephony library as well as
26 * libpri. Libpri is optional and needed only if you are
27 * going to use ISDN connections.
29 * You need to install libraries before you attempt to compile
30 * and install the zaptel channel.
33 * \arg \ref Config_zap
35 * \ingroup channel_drivers
37 * \todo Deprecate the "musiconhold" configuration option post 1.4
41 <depend>zaptel</depend>
42 <depend>tonezone</depend>
49 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
57 #include <sys/signal.h>
61 #if !defined(SOLARIS) && !defined(__FreeBSD__)
65 #include <sys/ioctl.h>
68 #include <zaptel/zaptel.h>
69 #include <zaptel/tonezone.h>
79 #include "asterisk/lock.h"
80 #include "asterisk/channel.h"
81 #include "asterisk/config.h"
82 #include "asterisk/logger.h"
83 #include "asterisk/module.h"
84 #include "asterisk/pbx.h"
85 #include "asterisk/options.h"
86 #include "asterisk/file.h"
87 #include "asterisk/ulaw.h"
88 #include "asterisk/alaw.h"
89 #include "asterisk/callerid.h"
90 #include "asterisk/adsi.h"
91 #include "asterisk/cli.h"
92 #include "asterisk/cdr.h"
93 #include "asterisk/features.h"
94 #include "asterisk/musiconhold.h"
95 #include "asterisk/say.h"
96 #include "asterisk/tdd.h"
97 #include "asterisk/app.h"
98 #include "asterisk/dsp.h"
99 #include "asterisk/astdb.h"
100 #include "asterisk/manager.h"
101 #include "asterisk/causes.h"
102 #include "asterisk/term.h"
103 #include "asterisk/utils.h"
104 #include "asterisk/transcap.h"
105 #include "asterisk/stringfields.h"
106 #include "asterisk/abstract_jb.h"
107 #include "asterisk/smdi.h"
108 #include "asterisk/astobj.h"
109 #define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */
111 /*! Global jitterbuffer configuration - by default, jb is disabled */
112 static struct ast_jb_conf default_jbconf =
116 .resync_threshold = -1,
119 static struct ast_jb_conf global_jbconf;
121 #if !defined(ZT_SIG_EM_E1) || (defined(HAVE_PRI) && !defined(ZT_SIG_HARDHDLC))
122 #error "Your zaptel is too old. Please update"
125 #ifndef ZT_TONEDETECT
126 /* Work around older code with no tone detect */
127 #define ZT_EVENT_DTMFDOWN 0
128 #define ZT_EVENT_DTMFUP 0
131 /* define this to send PRI user-user information elements */
132 #undef SUPPORT_USERUSER
135 * \note Define ZHONE_HACK to cause us to go off hook and then back on hook when
136 * the user hangs up to reset the state machine so ring works properly.
137 * This is used to be able to support kewlstart by putting the zhone in
138 * groundstart mode since their forward disconnect supervision is entirely
139 * broken even though their documentation says it isn't and their support
140 * is entirely unwilling to provide any assistance with their channel banks
141 * even though their web site says they support their products for life.
143 /* #define ZHONE_HACK */
146 * Define if you want to check the hook state for an FXO (FXS signalled) interface
147 * before dialing on it. Certain FXO interfaces always think they're out of
148 * service with this method however.
150 /* #define ZAP_CHECK_HOOKSTATE */
152 /*! \brief Typically, how many rings before we should send Caller*ID */
153 #define DEFAULT_CIDRINGS 1
155 #define CHANNEL_PSEUDO -12
157 #define AST_LAW(p) (((p)->law == ZT_LAW_ALAW) ? AST_FORMAT_ALAW : AST_FORMAT_ULAW)
159 /*! \brief Signaling types that need to use MF detection should be placed in this macro */
160 #define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
162 static const char tdesc[] = "Zapata Telephony Driver"
171 static const char config[] = "zapata.conf";
173 #define SIG_EM ZT_SIG_EM
174 #define SIG_EMWINK (0x0100000 | ZT_SIG_EM)
175 #define SIG_FEATD (0x0200000 | ZT_SIG_EM)
176 #define SIG_FEATDMF (0x0400000 | ZT_SIG_EM)
177 #define SIG_FEATB (0x0800000 | ZT_SIG_EM)
178 #define SIG_E911 (0x1000000 | ZT_SIG_EM)
179 #define SIG_FEATDMF_TA (0x2000000 | ZT_SIG_EM)
180 #define SIG_FGC_CAMA (0x4000000 | ZT_SIG_EM)
181 #define SIG_FGC_CAMAMF (0x8000000 | ZT_SIG_EM)
182 #define SIG_FXSLS ZT_SIG_FXSLS
183 #define SIG_FXSGS ZT_SIG_FXSGS
184 #define SIG_FXSKS ZT_SIG_FXSKS
185 #define SIG_FXOLS ZT_SIG_FXOLS
186 #define SIG_FXOGS ZT_SIG_FXOGS
187 #define SIG_FXOKS ZT_SIG_FXOKS
188 #define SIG_PRI ZT_SIG_CLEAR
189 #define SIG_SS7 (0x1000000 | ZT_SIG_CLEAR)
190 #define SIG_SF ZT_SIG_SF
191 #define SIG_SFWINK (0x0100000 | ZT_SIG_SF)
192 #define SIG_SF_FEATD (0x0200000 | ZT_SIG_SF)
193 #define SIG_SF_FEATDMF (0x0400000 | ZT_SIG_SF)
194 #define SIG_SF_FEATB (0x0800000 | ZT_SIG_SF)
195 #define SIG_EM_E1 ZT_SIG_EM_E1
196 #define SIG_GR303FXOKS (0x0100000 | ZT_SIG_FXOKS)
197 #define SIG_GR303FXSKS (0x0100000 | ZT_SIG_FXSKS)
200 #define NUM_DCHANS 4 /*!< No more than 4 d-channels */
201 #define MAX_CHANNELS 672 /*!< No more than a DS3 per trunk group */
203 #define CHAN_PSEUDO -2
205 #define DCHAN_PROVISIONED (1 << 0)
206 #define DCHAN_NOTINALARM (1 << 1)
207 #define DCHAN_UP (1 << 2)
209 #define DCHAN_AVAILABLE (DCHAN_PROVISIONED | DCHAN_NOTINALARM | DCHAN_UP)
211 static char context[AST_MAX_CONTEXT] = "default";
212 static char cid_num[256] = "";
213 static char cid_name[256] = "";
214 static char defaultcic[64] = "";
215 static char defaultozz[64] = "";
217 static char language[MAX_LANGUAGE] = "";
218 static char mohinterpret[MAX_MUSICCLASS] = "default";
219 static char mohsuggest[MAX_MUSICCLASS] = "";
220 static char progzone[10] = "";
222 static int usedistinctiveringdetection = 0;
223 static int distinctiveringaftercid = 0;
225 static int transfertobusy = 1;
227 static int use_callerid = 1;
228 static int cid_signalling = CID_SIG_BELL;
229 static int cid_start = CID_START_RING;
230 static int zaptrcallerid = 0;
231 static int cur_radio = 0;
232 static int cur_signalling = -1;
233 static int cur_outsignalling = -1;
235 static ast_group_t cur_group = 0;
236 static ast_group_t cur_callergroup = 0;
237 static ast_group_t cur_pickupgroup = 0;
238 static int relaxdtmf = 0;
240 static int immediate = 0;
242 static int stripmsd = 0;
244 static int callwaiting = 0;
246 static int callwaitingcallerid = 0;
248 static int hidecallerid = 0;
250 static int restrictcid = 0;
252 static int use_callingpres = 0;
254 static int callreturn = 0;
256 static int threewaycalling = 0;
258 static int transfer = 0;
260 static int canpark = 0;
262 static int cancallforward = 0;
264 static float rxgain = 0.0;
266 static float txgain = 0.0;
268 static int tonezone = -1;
270 static int echocancel;
272 static int echotraining;
276 static int echocanbridged = 0;
278 static int busydetect = 0;
280 static int busycount = 3;
281 static int busy_tonelength = 0;
282 static int busy_quietlength = 0;
284 static int callprogress = 0;
286 static char accountcode[AST_MAX_ACCOUNT_CODE] = "";
288 static char mailbox[AST_MAX_EXTENSION];
290 static int amaflags = 0;
293 static int use_smdi = 0;
294 static char smdi_port[SMDI_MAX_FILENAME_LEN] = "/dev/ttyS0";
295 static int numbufs = 4;
297 static int cur_prewink = -1;
298 static int cur_preflash = -1;
299 static int cur_wink = -1;
300 static int cur_flash = -1;
301 static int cur_start = -1;
302 static int cur_rxwink = -1;
303 static int cur_rxflash = -1;
304 static int cur_debounce = -1;
305 static int cur_priexclusive = 0;
307 static int priindication_oob = 0;
310 static int minunused = 2;
311 static int minidle = 0;
312 static char idleext[AST_MAX_EXTENSION];
313 static char idledial[AST_MAX_EXTENSION];
314 static int overlapdial = 0;
315 static int facilityenable = 0;
316 static char internationalprefix[10] = "";
317 static char nationalprefix[10] = "";
318 static char localprefix[20] = "";
319 static char privateprefix[20] = "";
320 static char unknownprefix[20] = "";
321 static long resetinterval = 3600; /*!< How often (in seconds) to reset unused channels. Default 1 hour. */
322 static struct ast_channel inuse;
323 #ifdef PRI_GETSET_TIMERS
324 static int pritimers[PRI_MAX_TIMERS];
326 static int pridebugfd = -1;
327 static char pridebugfilename[1024] = "";
330 /*! \brief Wait up to 16 seconds for first digit (FXO logic) */
331 static int firstdigittimeout = 16000;
333 /*! \brief How long to wait for following digits (FXO logic) */
334 static int gendigittimeout = 8000;
336 /*! \brief How long to wait for an extra digit, if there is an ambiguous match */
337 static int matchdigittimeout = 3000;
339 static int usecnt = 0;
341 /*! \brief Protect the interface list (of zt_pvt's) */
342 AST_MUTEX_DEFINE_STATIC(iflock);
345 static int ifcount = 0;
348 AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
351 /*! \brief Whether we answer on a Polarity Switch event */
352 static int answeronpolarityswitch = 0;
354 /*! \brief Whether we hang up on a Polarity Switch event */
355 static int hanguponpolarityswitch = 0;
357 /*! \brief How long (ms) to ignore Polarity Switch events after we answer a call */
358 static int polarityonanswerdelay = 600;
360 /*! \brief When to send the CallerID signals (rings) */
361 static int sendcalleridafter = DEFAULT_CIDRINGS;
363 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
364 when it's doing something critical. */
365 AST_MUTEX_DEFINE_STATIC(monlock);
367 /*! \brief This is the thread for the monitor which checks for input on the channels
368 which are not currently in use. */
369 static pthread_t monitor_thread = AST_PTHREADT_NULL;
371 static int restart_monitor(void);
373 static enum ast_bridge_result zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
375 static int zt_sendtext(struct ast_channel *c, const char *text);
377 /*! \brief Avoid the silly zt_getevent which ignores a bunch of events */
378 static inline int zt_get_event(int fd)
381 if (ioctl(fd, ZT_GETEVENT, &j) == -1)
386 /*! \brief Avoid the silly zt_waitevent which ignores a bunch of events */
387 static inline int zt_wait_event(int fd)
390 i = ZT_IOMUX_SIGEVENT;
391 if (ioctl(fd, ZT_IOMUX, &i) == -1)
393 if (ioctl(fd, ZT_GETEVENT, &j) == -1)
398 /*! Chunk size to read -- we use 20ms chunks to make things happy. */
399 #define READ_SIZE 160
401 #define MASK_AVAIL (1 << 0) /*!< Channel available for PRI use */
402 #define MASK_INUSE (1 << 1) /*!< Channel currently in use */
404 #define CALLWAITING_SILENT_SAMPLES ( (300 * 8) / READ_SIZE) /*!< 300 ms */
405 #define CALLWAITING_REPEAT_SAMPLES ( (10000 * 8) / READ_SIZE) /*!< 300 ms */
406 #define CIDCW_EXPIRE_SAMPLES ( (500 * 8) / READ_SIZE) /*!< 500 ms */
407 #define MIN_MS_SINCE_FLASH ( (2000) ) /*!< 2000 ms */
408 #define DEFAULT_RINGT ( (8000 * 8) / READ_SIZE)
412 static int ringt_base = DEFAULT_RINGT;
416 #define LINKSTATE_INALARM (1 << 0)
417 #define LINKSTATE_STARTING (1 << 1)
418 #define LINKSTATE_UP (1 << 2)
419 #define LINKSTATE_DOWN (1 << 3)
422 pthread_t master; /*!< Thread of master */
426 int linkstate[NUM_DCHANS];
430 struct zt_pvt *pvts[MAX_CHANNELS]; /*!< Member channel pvt structs */
433 static struct zt_ss7 linksets[NUM_SPANS];
435 static int cur_ss7type = -1;
436 static int cur_linkset = -1;
437 static int cur_pointcode = -1;
438 static int cur_cicbeginswith = -1;
439 static int cur_adjpointcode = -1;
440 static int cur_networkindicator = -1;
441 static int cur_defaultdpc = -1;
442 #endif /* HAVE_SS7 */
446 #define PVT_TO_CHANNEL(p) (((p)->prioffset) | ((p)->logicalspan << 8) | (p->pri->mastertrunkgroup ? 0x10000 : 0))
447 #define PRI_CHANNEL(p) ((p) & 0xff)
448 #define PRI_SPAN(p) (((p) >> 8) & 0xff)
449 #define PRI_EXPLICIT(p) (((p) >> 16) & 0x01)
452 pthread_t master; /*!< Thread of master */
453 ast_mutex_t lock; /*!< Mutex */
454 char idleext[AST_MAX_EXTENSION]; /*!< Where to idle extra calls */
455 char idlecontext[AST_MAX_CONTEXT]; /*!< What context to use for idle */
456 char idledial[AST_MAX_EXTENSION]; /*!< What to dial before dumping */
457 int minunused; /*!< Min # of channels to keep empty */
458 int minidle; /*!< Min # of "idling" calls to keep active */
459 int nodetype; /*!< Node type */
460 int switchtype; /*!< Type of switch to emulate */
461 int nsf; /*!< Network-Specific Facilities */
462 int dialplan; /*!< Dialing plan */
463 int localdialplan; /*!< Local dialing plan */
464 char internationalprefix[10]; /*!< country access code ('00' for european dialplans) */
465 char nationalprefix[10]; /*!< area access code ('0' for european dialplans) */
466 char localprefix[20]; /*!< area access code + area code ('0'+area code for european dialplans) */
467 char privateprefix[20]; /*!< for private dialplans */
468 char unknownprefix[20]; /*!< for unknown dialplans */
469 int dchannels[NUM_DCHANS]; /*!< What channel are the dchannels on */
470 int trunkgroup; /*!< What our trunkgroup is */
471 int mastertrunkgroup; /*!< What trunk group is our master */
472 int prilogicalspan; /*!< Logical span number within trunk group */
473 int numchans; /*!< Num of channels we represent */
474 int overlapdial; /*!< In overlap dialing mode */
475 int facilityenable; /*!< Enable facility IEs */
476 struct pri *dchans[NUM_DCHANS]; /*!< Actual d-channels */
477 int dchanavail[NUM_DCHANS]; /*!< Whether each channel is available */
478 struct pri *pri; /*!< Currently active D-channel */
480 int fds[NUM_DCHANS]; /*!< FD's for d-channels */
485 time_t lastreset; /*!< time when unused channels were last reset */
486 long resetinterval; /*!< Interval (in seconds) for resetting unused channels */
487 struct zt_pvt *pvts[MAX_CHANNELS]; /*!< Member channel pvt structs */
488 struct zt_pvt *crvs; /*!< Member CRV structs */
489 struct zt_pvt *crvend; /*!< Pointer to end of CRV structs */
493 static struct zt_pri pris[NUM_SPANS];
495 static int pritype = PRI_CPE;
498 #define DEFAULT_PRI_DEBUG (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE)
500 #define DEFAULT_PRI_DEBUG 0
503 static inline void pri_rel(struct zt_pri *pri)
505 ast_mutex_unlock(&pri->lock);
508 static int switchtype = PRI_SWITCH_NI2;
509 static int nsf = PRI_NSF_NONE;
510 static int dialplan = PRI_NATIONAL_ISDN + 1;
511 static int localdialplan = PRI_NATIONAL_ISDN + 1;
514 /*! Shut up the compiler */
518 #define SUB_REAL 0 /*!< Active call */
519 #define SUB_CALLWAIT 1 /*!< Call-Waiting call on hold */
520 #define SUB_THREEWAY 2 /*!< Three-way call */
522 /* Polarity states */
523 #define POLARITY_IDLE 0
524 #define POLARITY_REV 1
527 static struct zt_distRings drings;
529 struct distRingData {
532 struct ringContextData {
533 char contextData[AST_MAX_CONTEXT];
535 struct zt_distRings {
536 struct distRingData ringnum[3];
537 struct ringContextData ringContext[3];
540 static char *subnames[] = {
546 struct zt_subchannel {
548 struct ast_channel *owner;
550 short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
551 struct ast_frame f; /*!< One frame for each channel. How did this ever work before? */
552 unsigned int needringing:1;
553 unsigned int needbusy:1;
554 unsigned int needcongestion:1;
555 unsigned int needcallerid:1;
556 unsigned int needanswer:1;
557 unsigned int needflash:1;
558 unsigned int needhold:1;
559 unsigned int needunhold:1;
560 unsigned int linear:1;
561 unsigned int inthreeway:1;
565 #define CONF_USER_REAL (1 << 0)
566 #define CONF_USER_THIRDCALL (1 << 1)
570 static struct zt_pvt {
572 struct ast_channel *owner; /*!< Our current active owner (if applicable) */
573 /*!< Up to three channels can be associated with this call */
575 struct zt_subchannel sub_unused; /*!< Just a safety precaution */
576 struct zt_subchannel subs[3]; /*!< Sub-channels */
577 struct zt_confinfo saveconf; /*!< Saved conference info */
579 struct zt_pvt *slaves[MAX_SLAVES]; /*!< Slave to us (follows our conferencing) */
580 struct zt_pvt *master; /*!< Master to us (we follow their conferencing) */
581 int inconference; /*!< If our real should be in the conference */
583 int sig; /*!< Signalling style */
584 int radio; /*!< radio type */
585 int outsigmod; /*!< Outbound Signalling style (modifier) */
586 int oprmode; /*!< "Operator Services" mode */
587 struct zt_pvt *oprpeer; /*!< "Operator Services" peer tech_pvt ptr */
590 int tonezone; /*!< tone zone for this chan, or -1 for default */
591 struct zt_pvt *next; /*!< Next channel in list */
592 struct zt_pvt *prev; /*!< Prev channel in list */
596 unsigned int answeronpolarityswitch:1;
597 unsigned int busydetect:1;
598 unsigned int callreturn:1;
599 unsigned int callwaiting:1;
600 unsigned int callwaitingcallerid:1;
601 unsigned int cancallforward:1;
602 unsigned int canpark:1;
603 unsigned int confirmanswer:1; /*!< Wait for '#' to confirm answer */
604 unsigned int destroy:1;
605 unsigned int didtdd:1; /*!< flag to say its done it once */
606 unsigned int dialednone:1;
607 unsigned int dialing:1;
608 unsigned int digital:1;
610 unsigned int echobreak:1;
611 unsigned int echocanbridged:1;
612 unsigned int echocanon:1;
613 unsigned int faxhandled:1; /*!< Has a fax tone already been handled? */
614 unsigned int firstradio:1;
615 unsigned int hanguponpolarityswitch:1;
616 unsigned int hardwaredtmf:1;
617 unsigned int hidecallerid;
618 unsigned int ignoredtmf:1;
619 unsigned int immediate:1; /*!< Answer before getting digits? */
620 unsigned int inalarm:1;
621 unsigned int mate:1; /*!< flag to say its in MATE mode */
622 unsigned int outgoing:1;
623 unsigned int overlapdial:1;
624 unsigned int permcallwaiting:1;
625 unsigned int permhidecallerid:1; /*!< Whether to hide our outgoing caller ID or not */
626 unsigned int priindication_oob:1;
627 unsigned int priexclusive:1;
628 unsigned int pulse:1;
629 unsigned int pulsedial:1; /*!< whether a pulse dial phone is detected */
630 unsigned int restrictcid:1; /*!< Whether restrict the callerid -> only send ANI */
631 unsigned int threewaycalling:1;
632 unsigned int transfer:1;
633 unsigned int use_callerid:1; /*!< Whether or not to use caller id on this channel */
634 unsigned int use_callingpres:1; /*!< Whether to use the callingpres the calling switch sends */
635 unsigned int usedistinctiveringdetection:1;
636 unsigned int zaptrcallerid:1; /*!< should we use the callerid from incoming call on zap transfer or not */
637 unsigned int transfertobusy:1; /*!< allow flash-transfers to busy channels */
638 #if defined(HAVE_PRI)
639 unsigned int alerting:1;
640 unsigned int alreadyhungup:1;
641 unsigned int isidlecall:1;
642 unsigned int proceeding:1;
643 unsigned int progress:1;
644 unsigned int resetting:1;
645 unsigned int setup_ack:1;
647 #if defined(HAVE_SS7)
648 unsigned int blocked:1;
650 unsigned int use_smdi:1; /* Whether to use SMDI on this channel */
651 struct ast_smdi_interface *smdi_iface; /* The serial port to listen for SMDI data on */
653 struct zt_distRings drings;
655 char context[AST_MAX_CONTEXT];
656 char defcontext[AST_MAX_CONTEXT];
657 char exten[AST_MAX_EXTENSION];
658 char language[MAX_LANGUAGE];
659 char mohinterpret[MAX_MUSICCLASS];
660 char mohsuggest[MAX_MUSICCLASS];
662 char cid_ani[AST_MAX_EXTENSION];
664 char cid_num[AST_MAX_EXTENSION];
665 int cid_ton; /*!< Type Of Number (TON) */
666 char cid_name[AST_MAX_EXTENSION];
667 char lastcid_num[AST_MAX_EXTENSION];
668 char lastcid_name[AST_MAX_EXTENSION];
669 char *origcid_num; /*!< malloced original callerid */
670 char *origcid_name; /*!< malloced original callerid */
671 char callwait_num[AST_MAX_EXTENSION];
672 char callwait_name[AST_MAX_EXTENSION];
673 char rdnis[AST_MAX_EXTENSION];
674 char dnid[AST_MAX_EXTENSION];
677 int confno; /*!< Our conference */
678 int confusers; /*!< Who is using our conference */
679 int propconfno; /*!< Propagated conference number */
680 ast_group_t callgroup;
681 ast_group_t pickupgroup;
682 int channel; /*!< Channel Number or CRV */
683 int span; /*!< Span number */
684 time_t guardtime; /*!< Must wait this much time before using for new call */
685 int cid_signalling; /*!< CID signalling type bell202 or v23 */
686 int cid_start; /*!< CID start indicator, polarity or ring */
687 int callingpres; /*!< The value of callling presentation that we're going to use when placing a PRI call */
688 int callwaitingrepeat; /*!< How many samples to wait before repeating call waiting */
689 int cidcwexpire; /*!< When to expire our muting for CID/CW */
690 unsigned char *cidspill;
703 int busy_quietlength;
705 struct timeval flashtime; /*!< Last flash-hook time */
707 int cref; /*!< Call reference number */
708 ZT_DIAL_OPERATION dop;
709 int whichwink; /*!< SIG_FEATDMF_TA Which wink are we on? */
711 char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
712 int amaflags; /*!< AMA Flags */
713 struct tdd_state *tdd; /*!< TDD flag */
714 char call_forward[AST_MAX_EXTENSION];
715 char mailbox[AST_MAX_EXTENSION];
719 int distinctivering; /*!< Which distinctivering to use */
720 int cidrings; /*!< Which ring to deliver CID on */
721 int dtmfrelax; /*!< whether to run in relaxed DTMF mode */
723 int polarityonanswerdelay;
724 struct timeval polaritydelaytv;
725 int sendcalleridafter;
728 struct zt_pvt *bearer;
729 struct zt_pvt *realcall;
738 struct isup_call *ss7call;
740 int cic; /*!< CIC associated with channel */
743 } *iflist = NULL, *ifend = NULL;
745 static struct ast_channel *zt_request(const char *type, int format, void *data, int *cause);
746 static int zt_digit_begin(struct ast_channel *ast, char digit);
747 static int zt_digit_end(struct ast_channel *ast, char digit);
748 static int zt_sendtext(struct ast_channel *c, const char *text);
749 static int zt_call(struct ast_channel *ast, char *rdest, int timeout);
750 static int zt_hangup(struct ast_channel *ast);
751 static int zt_answer(struct ast_channel *ast);
752 static struct ast_frame *zt_read(struct ast_channel *ast);
753 static int zt_write(struct ast_channel *ast, struct ast_frame *frame);
754 static struct ast_frame *zt_exception(struct ast_channel *ast);
755 static int zt_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
756 static int zt_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
757 static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen);
758 static int zt_func_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len);
760 static const struct ast_channel_tech zap_tech = {
762 .description = tdesc,
763 .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
764 .requester = zt_request,
765 .send_digit_begin = zt_digit_begin,
766 .send_digit_end = zt_digit_end,
767 .send_text = zt_sendtext,
774 .exception = zt_exception,
775 .indicate = zt_indicate,
777 .setoption = zt_setoption,
778 .func_channel_read = zt_func_read,
782 #define GET_CHANNEL(p) ((p)->bearer ? (p)->bearer->channel : p->channel)
784 #define GET_CHANNEL(p) ((p)->channel)
787 struct zt_pvt *round_robin[32];
790 static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri)
793 /* Grab the lock first */
795 res = ast_mutex_trylock(&pri->lock);
797 ast_mutex_unlock(&pvt->lock);
798 /* Release the lock and try again */
800 ast_mutex_lock(&pvt->lock);
803 /* Then break the poll */
804 pthread_kill(pri->master, SIGURG);
810 static inline void ss7_rel(struct zt_ss7 *ss7)
812 ast_mutex_unlock(&ss7->lock);
815 static inline int ss7_grab(struct zt_pvt *pvt, struct zt_ss7 *pri)
818 /* Grab the lock first */
820 res = ast_mutex_trylock(&pri->lock);
822 ast_mutex_unlock(&pvt->lock);
823 /* Release the lock and try again */
825 ast_mutex_lock(&pvt->lock);
828 /* Then break the poll */
829 pthread_kill(pri->master, SIGURG);
833 #define NUM_CADENCE_MAX 25
834 static int num_cadence = 4;
835 static int user_has_defined_cadences = 0;
837 static struct zt_ring_cadence cadences[NUM_CADENCE_MAX] = {
838 { { 125, 125, 2000, 4000 } }, /*!< Quick chirp followed by normal ring */
839 { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /*!< British style ring */
840 { { 125, 125, 125, 125, 125, 4000 } }, /*!< Three short bursts */
841 { { 1000, 500, 2500, 5000 } }, /*!< Long ring */
844 /*! \brief cidrings says in which pause to transmit the cid information, where the first pause
845 * is 1, the second pause is 2 and so on.
848 static int cidrings[NUM_CADENCE_MAX] = {
849 2, /*!< Right after first long ring */
850 4, /*!< Right after long part */
851 3, /*!< After third chirp */
852 2, /*!< Second spell */
855 #define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
856 (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
858 #define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
859 #define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
861 static int zt_get_index(struct ast_channel *ast, struct zt_pvt *p, int nullok)
864 if (p->subs[0].owner == ast)
866 else if (p->subs[1].owner == ast)
868 else if (p->subs[2].owner == ast)
873 ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n");
879 static void wakeup_sub(struct zt_pvt *p, int a, struct zt_pri *pri)
881 static void wakeup_sub(struct zt_pvt *p, int a, void *pri)
886 ast_mutex_unlock(&pri->lock);
889 if (p->subs[a].owner) {
890 if (ast_mutex_trylock(&p->subs[a].owner->lock)) {
891 ast_mutex_unlock(&p->lock);
893 ast_mutex_lock(&p->lock);
895 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
896 ast_mutex_unlock(&p->subs[a].owner->lock);
904 ast_mutex_lock(&pri->lock);
908 static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, void *data)
911 struct zt_pri *pri = (struct zt_pri*) data;
914 struct zt_ss7 *ss7 = (struct zt_ss7*) data;
916 /* We must unlock the PRI to avoid the possibility of a deadlock */
917 #if defined(HAVE_PRI) || defined(HAVE_SS7)
922 ast_mutex_unlock(&pri->lock);
927 ast_mutex_unlock(&ss7->lock);
937 if (ast_mutex_trylock(&p->owner->lock)) {
938 ast_mutex_unlock(&p->lock);
940 ast_mutex_lock(&p->lock);
942 ast_queue_frame(p->owner, f);
943 ast_mutex_unlock(&p->owner->lock);
949 #if defined(HAVE_PRI) || defined(HAVE_SS7)
954 ast_mutex_lock(&pri->lock);
959 ast_mutex_lock(&ss7->lock);
970 static int restore_gains(struct zt_pvt *p);
972 static void swap_subs(struct zt_pvt *p, int a, int b)
976 struct ast_channel *towner;
978 ast_log(LOG_DEBUG, "Swapping %d and %d\n", a, b);
980 tchan = p->subs[a].chan;
981 towner = p->subs[a].owner;
982 tinthreeway = p->subs[a].inthreeway;
984 p->subs[a].chan = p->subs[b].chan;
985 p->subs[a].owner = p->subs[b].owner;
986 p->subs[a].inthreeway = p->subs[b].inthreeway;
988 p->subs[b].chan = tchan;
989 p->subs[b].owner = towner;
990 p->subs[b].inthreeway = tinthreeway;
992 if (p->subs[a].owner)
993 p->subs[a].owner->fds[0] = p->subs[a].zfd;
994 if (p->subs[b].owner)
995 p->subs[b].owner->fds[0] = p->subs[b].zfd;
996 wakeup_sub(p, a, NULL);
997 wakeup_sub(p, b, NULL);
1000 static int zt_open(char *fn)
1008 for (x = 0; x < strlen(fn); x++) {
1009 if (!isdigit(fn[x])) {
1017 ast_log(LOG_WARNING, "Invalid channel number '%s'\n", fn);
1020 fn = "/dev/zap/channel";
1022 fd = open(fn, O_RDWR | O_NONBLOCK);
1024 ast_log(LOG_WARNING, "Unable to open '%s': %s\n", fn, strerror(errno));
1028 if (ioctl(fd, ZT_SPECIFY, &chan)) {
1032 ast_log(LOG_WARNING, "Unable to specify channel %d: %s\n", chan, strerror(errno));
1037 if (ioctl(fd, ZT_SET_BLOCKSIZE, &bs) == -1) return -1;
1041 static void zt_close(int fd)
1047 static int zt_setlinear(int zfd, int linear)
1050 res = ioctl(zfd, ZT_SETLINEAR, &linear);
1057 static int alloc_sub(struct zt_pvt *p, int x)
1061 if (p->subs[x].zfd < 0) {
1062 p->subs[x].zfd = zt_open("/dev/zap/pseudo");
1063 if (p->subs[x].zfd > -1) {
1064 res = ioctl(p->subs[x].zfd, ZT_GET_BUFINFO, &bi);
1066 bi.txbufpolicy = ZT_POLICY_IMMEDIATE;
1067 bi.rxbufpolicy = ZT_POLICY_IMMEDIATE;
1068 bi.numbufs = numbufs;
1069 res = ioctl(p->subs[x].zfd, ZT_SET_BUFINFO, &bi);
1071 ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d\n", x);
1074 ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d\n", x);
1075 if (ioctl(p->subs[x].zfd, ZT_CHANNO, &p->subs[x].chan) == 1) {
1076 ast_log(LOG_WARNING, "Unable to get channel number for pseudo channel on FD %d\n", p->subs[x].zfd);
1077 zt_close(p->subs[x].zfd);
1078 p->subs[x].zfd = -1;
1082 ast_log(LOG_DEBUG, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].zfd, p->subs[x].chan);
1085 ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
1088 ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
1092 static int unalloc_sub(struct zt_pvt *p, int x)
1095 ast_log(LOG_WARNING, "Trying to unalloc the real channel %d?!?\n", p->channel);
1098 ast_log(LOG_DEBUG, "Released sub %d of channel %d\n", x, p->channel);
1099 if (p->subs[x].zfd > -1) {
1100 zt_close(p->subs[x].zfd);
1102 p->subs[x].zfd = -1;
1103 p->subs[x].linear = 0;
1104 p->subs[x].chan = 0;
1105 p->subs[x].owner = NULL;
1106 p->subs[x].inthreeway = 0;
1107 p->polarity = POLARITY_IDLE;
1108 memset(&p->subs[x].curconf, 0, sizeof(p->subs[x].curconf));
1112 static int digit_to_dtmfindex(char digit)
1115 return ZT_TONE_DTMF_BASE + (digit - '0');
1116 else if (digit >= 'A' && digit <= 'D')
1117 return ZT_TONE_DTMF_A + (digit - 'A');
1118 else if (digit >= 'a' && digit <= 'd')
1119 return ZT_TONE_DTMF_A + (digit - 'a');
1120 else if (digit == '*')
1121 return ZT_TONE_DTMF_s;
1122 else if (digit == '#')
1123 return ZT_TONE_DTMF_p;
1128 static int zt_digit_begin(struct ast_channel *chan, char digit)
1134 pvt = chan->tech_pvt;
1136 ast_mutex_lock(&pvt->lock);
1138 index = zt_get_index(chan, pvt, 0);
1140 if ((index != SUB_REAL) || !pvt->owner)
1144 if ((pvt->sig == SIG_PRI) && (chan->_state == AST_STATE_DIALING) && !pvt->proceeding) {
1145 if (pvt->setup_ack) {
1146 if (!pri_grab(pvt, pvt->pri)) {
1147 pri_information(pvt->pri->pri, pvt->call, digit);
1150 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", pvt->span);
1151 } else if (strlen(pvt->dialdest) < sizeof(pvt->dialdest) - 1) {
1153 ast_log(LOG_DEBUG, "Queueing digit '%c' since setup_ack not yet received\n", digit);
1154 res = strlen(pvt->dialdest);
1155 pvt->dialdest[res++] = digit;
1156 pvt->dialdest[res] = '\0';
1161 if ((dtmf = digit_to_dtmfindex(digit)) == -1)
1164 if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].zfd, ZT_SENDTONE, &dtmf)) {
1166 ZT_DIAL_OPERATION zo = {
1167 .op = ZT_DIAL_OP_APPEND,
1169 .dialstr[1] = digit,
1172 if ((res = ioctl(pvt->subs[SUB_REAL].zfd, ZT_DIAL, &zo)))
1173 ast_log(LOG_WARNING, "Couldn't dial digit %c\n", digit);
1177 ast_log(LOG_DEBUG, "Started VLDTMF digit '%c'\n", digit);
1179 pvt->begindigit = digit;
1183 ast_mutex_unlock(&pvt->lock);
1185 return 0; /* Tell Asterisk not to generate inband indications */
1188 static int zt_digit_end(struct ast_channel *chan, char digit)
1195 pvt = chan->tech_pvt;
1197 ast_mutex_lock(&pvt->lock);
1199 index = zt_get_index(chan, pvt, 0);
1201 if ((index != SUB_REAL) || !pvt->owner || pvt->pulse)
1205 /* This means that the digit was already sent via PRI signalling */
1206 if (pvt->sig == SIG_PRI && !pvt->begindigit)
1210 if (pvt->begindigit) {
1212 ast_log(LOG_DEBUG, "Ending VLDTMF digit '%c'\n", digit);
1213 res = ioctl(pvt->subs[SUB_REAL].zfd, ZT_SENDTONE, &x);
1215 pvt->begindigit = 0;
1219 ast_mutex_unlock(&pvt->lock);
1224 static char *events[] = {
1237 "Hook Transition Complete",
1242 "Polarity Reversal",
1250 { ZT_ALARM_RED, "Red Alarm" },
1251 { ZT_ALARM_YELLOW, "Yellow Alarm" },
1252 { ZT_ALARM_BLUE, "Blue Alarm" },
1253 { ZT_ALARM_RECOVER, "Recovering" },
1254 { ZT_ALARM_LOOPBACK, "Loopback" },
1255 { ZT_ALARM_NOTOPEN, "Not Open" },
1256 { ZT_ALARM_NONE, "None" },
1259 static char *alarm2str(int alarm)
1262 for (x = 0; x < sizeof(alarms) / sizeof(alarms[0]); x++) {
1263 if (alarms[x].alarm & alarm)
1264 return alarms[x].name;
1266 return alarm ? "Unknown Alarm" : "No Alarm";
1269 static char *event2str(int event)
1271 static char buf[256];
1272 if ((event < (sizeof(events) / sizeof(events[0]))) && (event > -1))
1273 return events[event];
1274 sprintf(buf, "Event %d", event); /* safe */
1279 static char *dialplan2str(int dialplan)
1281 if (dialplan == -1) {
1282 return("Dynamically set dialplan in ISDN");
1284 return (pri_plan2str(dialplan));
1288 static char *zap_sig2str(int sig)
1290 static char buf[256];
1293 return "E & M Immediate";
1295 return "E & M Wink";
1299 return "Feature Group D (DTMF)";
1301 return "Feature Group D (MF)";
1302 case SIG_FEATDMF_TA:
1303 return "Feature Groud D (MF) Tandem Access";
1305 return "Feature Group B (MF)";
1309 return "FGC/CAMA (Dialpulse)";
1310 case SIG_FGC_CAMAMF:
1311 return "FGC/CAMA (MF)";
1313 return "FXS Loopstart";
1315 return "FXS Groundstart";
1317 return "FXS Kewlstart";
1319 return "FXO Loopstart";
1321 return "FXO Groundstart";
1323 return "FXO Kewlstart";
1325 return "PRI Signalling";
1327 return "SS7 Signalling";
1329 return "SF (Tone) Signalling Immediate";
1331 return "SF (Tone) Signalling Wink";
1333 return "SF (Tone) Signalling with Feature Group D (DTMF)";
1334 case SIG_SF_FEATDMF:
1335 return "SF (Tone) Signalling with Feature Group D (MF)";
1337 return "SF (Tone) Signalling with Feature Group B (MF)";
1338 case SIG_GR303FXOKS:
1339 return "GR-303 Signalling with FXOKS";
1340 case SIG_GR303FXSKS:
1341 return "GR-303 Signalling with FXSKS";
1343 return "Pseudo Signalling";
1345 snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
1350 #define sig2str zap_sig2str
1352 static int conf_add(struct zt_pvt *p, struct zt_subchannel *c, int index, int slavechannel)
1354 /* If the conference already exists, and we're already in it
1355 don't bother doing anything */
1358 memset(&zi, 0, sizeof(zi));
1361 if (slavechannel > 0) {
1362 /* If we have only one slave, do a digital mon */
1363 zi.confmode = ZT_CONF_DIGITALMON;
1364 zi.confno = slavechannel;
1367 /* Real-side and pseudo-side both participate in conference */
1368 zi.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER |
1369 ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
1371 zi.confmode = ZT_CONF_CONF | ZT_CONF_TALKER | ZT_CONF_LISTENER;
1372 zi.confno = p->confno;
1374 if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
1378 if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
1379 ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d\n", c->zfd, zi.confmode, zi.confno);
1382 if (slavechannel < 1) {
1383 p->confno = zi.confno;
1385 memcpy(&c->curconf, &zi, sizeof(c->curconf));
1386 ast_log(LOG_DEBUG, "Added %d to conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1390 static int isourconf(struct zt_pvt *p, struct zt_subchannel *c)
1392 /* If they're listening to our channel, they're ours */
1393 if ((p->channel == c->curconf.confno) && (c->curconf.confmode == ZT_CONF_DIGITALMON))
1395 /* If they're a talker on our (allocated) conference, they're ours */
1396 if ((p->confno > 0) && (p->confno == c->curconf.confno) && (c->curconf.confmode & ZT_CONF_TALKER))
1401 static int conf_del(struct zt_pvt *p, struct zt_subchannel *c, int index)
1404 if (/* Can't delete if there's no zfd */
1406 /* Don't delete from the conference if it's not our conference */
1408 /* Don't delete if we don't think it's conferenced at all (implied) */
1410 memset(&zi, 0, sizeof(zi));
1414 if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
1415 ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1418 ast_log(LOG_DEBUG, "Removed %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1419 memcpy(&c->curconf, &zi, sizeof(c->curconf));
1423 static int isslavenative(struct zt_pvt *p, struct zt_pvt **out)
1427 struct zt_pvt *slave = NULL;
1428 /* Start out optimistic */
1430 /* Update conference state in a stateless fashion */
1431 for (x = 0; x < 3; x++) {
1432 /* Any three-way calling makes slave native mode *definitely* out
1434 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway)
1437 /* If we don't have any 3-way calls, check to see if we have
1438 precisely one slave */
1439 if (useslavenative) {
1440 for (x = 0; x < MAX_SLAVES; x++) {
1443 /* Whoops already have a slave! No
1444 slave native and stop right away */
1449 /* We have one slave so far */
1450 slave = p->slaves[x];
1455 /* If no slave, slave native definitely out */
1458 else if (slave->law != p->law) {
1464 return useslavenative;
1467 static int reset_conf(struct zt_pvt *p)
1470 memset(&zi, 0, sizeof(zi));
1472 memset(&p->subs[SUB_REAL].curconf, 0, sizeof(p->subs[SUB_REAL].curconf));
1473 if (p->subs[SUB_REAL].zfd > -1) {
1474 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &zi))
1475 ast_log(LOG_WARNING, "Failed to reset conferencing on channel %d!\n", p->channel);
1480 static int update_conf(struct zt_pvt *p)
1485 struct zt_pvt *slave = NULL;
1487 useslavenative = isslavenative(p, &slave);
1488 /* Start with the obvious, general stuff */
1489 for (x = 0; x < 3; x++) {
1490 /* Look for three way calls */
1491 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway) {
1492 conf_add(p, &p->subs[x], x, 0);
1495 conf_del(p, &p->subs[x], x);
1498 /* If we have a slave, add him to our conference now. or DAX
1499 if this is slave native */
1500 for (x = 0; x < MAX_SLAVES; x++) {
1503 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
1505 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
1510 /* If we're supposed to be in there, do so now */
1511 if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
1513 conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
1515 conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
1519 /* If we have a master, add ourselves to his conference */
1521 if (isslavenative(p->master, NULL)) {
1522 conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
1524 conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
1528 /* Nobody is left (or should be left) in our conference.
1532 ast_log(LOG_DEBUG, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
1536 static void zt_enable_ec(struct zt_pvt *p)
1543 ast_log(LOG_DEBUG, "Echo cancellation already on\n");
1547 ast_log(LOG_DEBUG, "Echo cancellation isn't required on digital connection\n");
1550 if (p->echocancel) {
1551 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
1553 res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x);
1555 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1558 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1560 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1563 ast_log(LOG_DEBUG, "Enabled echo cancellation on channel %d\n", p->channel);
1566 ast_log(LOG_DEBUG, "No echo cancellation requested\n");
1569 static void zt_train_ec(struct zt_pvt *p)
1573 if (p && p->echocancel && p->echotraining) {
1574 x = p->echotraining;
1575 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOTRAIN, &x);
1577 ast_log(LOG_WARNING, "Unable to request echo training on channel %d\n", p->channel);
1579 ast_log(LOG_DEBUG, "Engaged echo training on channel %d\n", p->channel);
1582 ast_log(LOG_DEBUG, "No echo training requested\n");
1585 static void zt_disable_ec(struct zt_pvt *p)
1589 if (p->echocancel) {
1591 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1593 ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d\n", p->channel);
1595 ast_log(LOG_DEBUG, "disabled echo cancellation on channel %d\n", p->channel);
1600 static void fill_txgain(struct zt_gains *g, float gain, int law)
1604 float linear_gain = pow(10.0, gain / 20.0);
1608 for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
1610 k = (int) (((float) AST_ALAW(j)) * linear_gain);
1611 if (k > 32767) k = 32767;
1612 if (k < -32767) k = -32767;
1613 g->txgain[j] = AST_LIN2A(k);
1620 for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
1622 k = (int) (((float) AST_MULAW(j)) * linear_gain);
1623 if (k > 32767) k = 32767;
1624 if (k < -32767) k = -32767;
1625 g->txgain[j] = AST_LIN2MU(k);
1634 static void fill_rxgain(struct zt_gains *g, float gain, int law)
1638 float linear_gain = pow(10.0, gain / 20.0);
1642 for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
1644 k = (int) (((float) AST_ALAW(j)) * linear_gain);
1645 if (k > 32767) k = 32767;
1646 if (k < -32767) k = -32767;
1647 g->rxgain[j] = AST_LIN2A(k);
1654 for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
1656 k = (int) (((float) AST_MULAW(j)) * linear_gain);
1657 if (k > 32767) k = 32767;
1658 if (k < -32767) k = -32767;
1659 g->rxgain[j] = AST_LIN2MU(k);
1668 static int set_actual_txgain(int fd, int chan, float gain, int law)
1673 memset(&g, 0, sizeof(g));
1675 res = ioctl(fd, ZT_GETGAINS, &g);
1677 ast_log(LOG_DEBUG, "Failed to read gains: %s\n", strerror(errno));
1681 fill_txgain(&g, gain, law);
1683 return ioctl(fd, ZT_SETGAINS, &g);
1686 static int set_actual_rxgain(int fd, int chan, float gain, int law)
1691 memset(&g, 0, sizeof(g));
1693 res = ioctl(fd, ZT_GETGAINS, &g);
1695 ast_log(LOG_DEBUG, "Failed to read gains: %s\n", strerror(errno));
1699 fill_rxgain(&g, gain, law);
1701 return ioctl(fd, ZT_SETGAINS, &g);
1704 static int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
1706 return set_actual_txgain(fd, chan, txgain, law) | set_actual_rxgain(fd, chan, rxgain, law);
1709 static int bump_gains(struct zt_pvt *p)
1713 /* Bump receive gain by 5.0db */
1714 res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain + 5.0, p->txgain, p->law);
1716 ast_log(LOG_WARNING, "Unable to bump gain: %s\n", strerror(errno));
1723 static int restore_gains(struct zt_pvt *p)
1727 res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
1729 ast_log(LOG_WARNING, "Unable to restore gains: %s\n", strerror(errno));
1736 static inline int zt_set_hook(int fd, int hs)
1740 res = ioctl(fd, ZT_HOOK, &x);
1743 if (errno == EINPROGRESS) return 0;
1744 ast_log(LOG_WARNING, "zt hook failed: %s\n", strerror(errno));
1749 static inline int zt_confmute(struct zt_pvt *p, int muted)
1753 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
1755 res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &y);
1757 ast_log(LOG_WARNING, "Unable to set audio mode on '%d'\n", p->channel);
1759 res = ioctl(p->subs[SUB_REAL].zfd, ZT_CONFMUTE, &x);
1761 ast_log(LOG_WARNING, "zt confmute(%d) failed on channel %d: %s\n", muted, p->channel, strerror(errno));
1765 static int save_conference(struct zt_pvt *p)
1767 struct zt_confinfo c;
1769 if (p->saveconf.confmode) {
1770 ast_log(LOG_WARNING, "Can't save conference -- already in use\n");
1773 p->saveconf.chan = 0;
1774 res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &p->saveconf);
1776 ast_log(LOG_WARNING, "Unable to get conference info: %s\n", strerror(errno));
1777 p->saveconf.confmode = 0;
1782 c.confmode = ZT_CONF_NORMAL;
1783 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &c);
1785 ast_log(LOG_WARNING, "Unable to set conference info: %s\n", strerror(errno));
1789 ast_log(LOG_DEBUG, "Disabled conferencing\n");
1793 static int restore_conference(struct zt_pvt *p)
1796 if (p->saveconf.confmode) {
1797 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &p->saveconf);
1798 p->saveconf.confmode = 0;
1800 ast_log(LOG_WARNING, "Unable to restore conference info: %s\n", strerror(errno));
1805 ast_log(LOG_DEBUG, "Restored conferencing\n");
1809 static int send_callerid(struct zt_pvt *p);
1811 static int send_cwcidspill(struct zt_pvt *p)
1815 if (!(p->cidspill = ast_malloc(MAX_CALLERID_SIZE)))
1817 p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, p->callwait_name, p->callwait_num, AST_LAW(p));
1818 /* Make sure we account for the end */
1819 p->cidlen += READ_SIZE * 4;
1822 if (option_verbose > 2)
1823 ast_verbose(VERBOSE_PREFIX_3 "CPE supports Call Waiting Caller*ID. Sending '%s/%s'\n", p->callwait_name, p->callwait_num);
1827 static int has_voicemail(struct zt_pvt *p)
1830 return ast_app_has_voicemail(p->mailbox, NULL);
1833 static int send_callerid(struct zt_pvt *p)
1835 /* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */
1837 /* Take out of linear mode if necessary */
1838 if (p->subs[SUB_REAL].linear) {
1839 p->subs[SUB_REAL].linear = 0;
1840 zt_setlinear(p->subs[SUB_REAL].zfd, 0);
1842 while (p->cidpos < p->cidlen) {
1843 res = write(p->subs[SUB_REAL].zfd, p->cidspill + p->cidpos, p->cidlen - p->cidpos);
1845 if (errno == EAGAIN)
1848 ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
1858 if (p->callwaitcas) {
1859 /* Wait for CID/CW to expire */
1860 p->cidcwexpire = CIDCW_EXPIRE_SAMPLES;
1862 restore_conference(p);
1866 static int zt_callwait(struct ast_channel *ast)
1868 struct zt_pvt *p = ast->tech_pvt;
1869 p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1871 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1874 if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1878 memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1879 if (!p->callwaitrings && p->callwaitingcallerid) {
1880 ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
1882 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1884 ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
1886 p->cidlen = 2400 + READ_SIZE * 4;
1894 static int zt_call(struct ast_channel *ast, char *rdest, int timeout)
1896 struct zt_pvt *p = ast->tech_pvt;
1897 int x, res, index,mysig;
1902 char dest[256]; /* must be same length as p->dialdest */
1903 ast_mutex_lock(&p->lock);
1904 ast_copy_string(dest, rdest, sizeof(dest));
1905 ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));
1906 if ((ast->_state == AST_STATE_BUSY)) {
1907 p->subs[SUB_REAL].needbusy = 1;
1908 ast_mutex_unlock(&p->lock);
1911 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1912 ast_log(LOG_WARNING, "zt_call called on %s, neither down nor reserved\n", ast->name);
1913 ast_mutex_unlock(&p->lock);
1917 if ((p->radio || (p->oprmode < 0))) /* if a radio channel, up immediately */
1919 /* Special pseudo -- automatically up */
1920 ast_setstate(ast, AST_STATE_UP);
1921 ast_mutex_unlock(&p->lock);
1924 x = ZT_FLUSH_READ | ZT_FLUSH_WRITE;
1925 res = ioctl(p->subs[SUB_REAL].zfd, ZT_FLUSH, &x);
1927 ast_log(LOG_WARNING, "Unable to flush input on channel %d\n", p->channel);
1930 set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
1933 if (p->outsigmod > -1)
1934 mysig = p->outsigmod;
1940 if (p->owner == ast) {
1941 /* Normal ring, on hook */
1943 /* Don't send audio while on hook, until the call is answered */
1945 if (p->use_callerid) {
1946 /* Generate the Caller-ID spill if desired */
1948 ast_log(LOG_WARNING, "cidspill already exists??\n");
1952 if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1953 p->cidlen = ast_callerid_generate(p->cidspill, ast->cid.cid_name, ast->cid.cid_num, AST_LAW(p));
1958 /* Choose proper cadence */
1959 if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
1960 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, &cadences[p->distinctivering - 1]))
1961 ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s'\n", p->distinctivering, ast->name);
1962 p->cidrings = cidrings[p->distinctivering - 1];
1964 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, NULL))
1965 ast_log(LOG_WARNING, "Unable to reset default ring on '%s'\n", ast->name);
1966 p->cidrings = p->sendcalleridafter;
1969 /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */
1970 c = strchr(dest, '/');
1973 if (c && (strlen(c) < p->stripmsd)) {
1974 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1978 p->dop.op = ZT_DIAL_OP_REPLACE;
1979 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c);
1980 ast_log(LOG_DEBUG, "FXO: setup deferred dialstring: %s\n", c);
1982 p->dop.dialstr[0] = '\0';
1985 if (ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x) && (errno != EINPROGRESS)) {
1986 ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
1987 ast_mutex_unlock(&p->lock);
1992 /* Call waiting call */
1993 p->callwaitrings = 0;
1994 if (ast->cid.cid_num)
1995 ast_copy_string(p->callwait_num, ast->cid.cid_num, sizeof(p->callwait_num));
1997 p->callwait_num[0] = '\0';
1998 if (ast->cid.cid_name)
1999 ast_copy_string(p->callwait_name, ast->cid.cid_name, sizeof(p->callwait_name));
2001 p->callwait_name[0] = '\0';
2002 /* Call waiting tone instead */
2003 if (zt_callwait(ast)) {
2004 ast_mutex_unlock(&p->lock);
2007 /* Make ring-back */
2008 if (tone_zone_play_tone(p->subs[SUB_CALLWAIT].zfd, ZT_TONE_RINGTONE))
2009 ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast->name);
2012 n = ast->cid.cid_name;
2013 l = ast->cid.cid_num;
2015 ast_copy_string(p->lastcid_num, l, sizeof(p->lastcid_num));
2017 p->lastcid_num[0] = '\0';
2019 ast_copy_string(p->lastcid_name, n, sizeof(p->lastcid_name));
2021 p->lastcid_name[0] = '\0';
2022 ast_setstate(ast, AST_STATE_RINGING);
2023 index = zt_get_index(ast, p, 0);
2025 p->subs[index].needringing = 1;
2038 case SIG_FGC_CAMAMF:
2043 case SIG_SF_FEATDMF:
2044 case SIG_FEATDMF_TA:
2046 c = strchr(dest, '/');
2051 if (strlen(c) < p->stripmsd) {
2052 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
2053 ast_mutex_unlock(&p->lock);
2057 /* Start the trunk, if not GR-303 */
2061 res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2063 if (errno != EINPROGRESS) {
2064 ast_log(LOG_WARNING, "Unable to start channel: %s\n", strerror(errno));
2065 ast_mutex_unlock(&p->lock);
2072 ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
2073 p->dop.op = ZT_DIAL_OP_REPLACE;
2079 l = ast->cid.cid_num;
2081 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c);
2083 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c);
2086 l = ast->cid.cid_num;
2088 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c);
2090 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c);
2092 case SIG_FEATDMF_TA:
2094 const char *cic, *ozz;
2096 /* If you have to go through a Tandem Access point you need to use this */
2097 ozz = pbx_builtin_getvar_helper(p->owner, "FEATDMF_OZZ");
2100 cic = pbx_builtin_getvar_helper(p->owner, "FEATDMF_CIC");
2104 ast_log(LOG_WARNING, "Unable to dial channel of type feature group D MF tandem access without CIC or OZZ set\n");
2105 ast_mutex_unlock(&p->lock);
2108 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s%s#", ozz, cic);
2109 snprintf(p->finaldial, sizeof(p->finaldial), "M*%s#", c);
2114 ast_copy_string(p->dop.dialstr, "M*911#", sizeof(p->dop.dialstr));
2117 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%s", c);
2119 case SIG_FGC_CAMAMF:
2121 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c);
2125 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%sw", c);
2127 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c);
2131 if (p->echotraining && (strlen(p->dop.dialstr) > 4)) {
2132 memset(p->echorest, 'w', sizeof(p->echorest) - 1);
2133 strcpy(p->echorest + (p->echotraining / 400) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
2134 p->echorest[sizeof(p->echorest) - 1] = '\0';
2136 p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
2140 if (ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop)) {
2142 ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2143 ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
2144 ast_mutex_unlock(&p->lock);
2148 ast_log(LOG_DEBUG, "Deferring dialing...\n");
2150 if (ast_strlen_zero(c))
2152 ast_setstate(ast, AST_STATE_DIALING);
2155 /* Special pseudo -- automatically up*/
2156 ast_setstate(ast, AST_STATE_UP);
2160 /* We'll get it in a moment -- but use dialdest to store pre-setup_ack digits */
2161 p->dialdest[0] = '\0';
2164 ast_log(LOG_DEBUG, "not yet implemented\n");
2165 ast_mutex_unlock(&p->lock);
2170 c = strchr(dest, '/');
2176 if (!p->hidecallerid) {
2177 l = ast->cid.cid_num;
2182 ss7_grab(p, p->ss7);
2183 p->digital = IS_DIGITAL(ast->transfercapability);
2184 p->ss7call = isup_new_call(p->ss7->ss7);
2188 ast_mutex_unlock(&p->lock);
2189 ast_log(LOG_ERROR, "Unable to allocate new SS7 call!\n");
2193 isup_init_call(p->ss7->ss7, p->ss7call, p->cic, c + p->stripmsd, l);
2195 isup_iam(p->ss7->ss7, p->ss7call);
2198 #endif /* HAVE_SS7 */
2202 #ifdef SUPPORT_USERUSER
2203 const char *useruser;
2207 int prilocaldialplan;
2211 int redirect_reason;
2213 c = strchr(dest, '/');
2218 if (!p->hidecallerid) {
2219 l = ast->cid.cid_num;
2220 n = ast->cid.cid_name;
2225 if (strlen(c) < p->stripmsd) {
2226 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
2227 ast_mutex_unlock(&p->lock);
2230 if (mysig != SIG_FXSKS) {
2231 p->dop.op = ZT_DIAL_OP_REPLACE;
2232 s = strchr(c + p->stripmsd, 'w');
2235 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%s", s);
2237 p->dop.dialstr[0] = '\0';
2240 p->dop.dialstr[0] = '\0';
2243 if (pri_grab(p, p->pri)) {
2244 ast_log(LOG_WARNING, "Failed to grab PRI!\n");
2245 ast_mutex_unlock(&p->lock);
2248 if (!(p->call = pri_new_call(p->pri->pri))) {
2249 ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel);
2251 ast_mutex_unlock(&p->lock);
2254 if (!(sr = pri_sr_new())) {
2255 ast_log(LOG_WARNING, "Failed to allocate setup request channel %d\n", p->channel);
2257 ast_mutex_unlock(&p->lock);
2259 if (p->bearer || (mysig == SIG_FXSKS)) {
2261 ast_log(LOG_DEBUG, "Oooh, I have a bearer on %d (%d:%d)\n", PVT_TO_CHANNEL(p->bearer), p->bearer->logicalspan, p->bearer->channel);
2262 p->bearer->call = p->call;
2264 ast_log(LOG_DEBUG, "I'm being setup with no bearer right now...\n");
2265 pri_set_crv(p->pri->pri, p->call, p->channel, 0);
2267 p->digital = IS_DIGITAL(ast->transfercapability);
2268 /* Add support for exclusive override */
2269 if (p->priexclusive)
2272 /* otherwise, traditional behavior */
2273 if (p->pri->nodetype == PRI_NETWORK)
2279 pri_sr_set_channel(sr, p->bearer ? PVT_TO_CHANNEL(p->bearer) : PVT_TO_CHANNEL(p), exclusive, 1);
2280 pri_sr_set_bearer(sr, p->digital ? PRI_TRANS_CAP_DIGITAL : ast->transfercapability,
2282 ((p->law == ZT_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW)));
2283 if (p->pri->facilityenable)
2284 pri_facility_enable(p->pri->pri);
2286 if (option_verbose > 2)
2287 ast_verbose(VERBOSE_PREFIX_3 "Requested transfer capability: 0x%.2x - %s\n", ast->transfercapability, ast_transfercapability2str(ast->transfercapability));
2289 pridialplan = p->pri->dialplan - 1;
2290 if (pridialplan == -2) { /* compute dynamically */
2291 if (strncmp(c + p->stripmsd, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
2292 dp_strip = strlen(p->pri->internationalprefix);
2293 pridialplan = PRI_INTERNATIONAL_ISDN;
2294 } else if (strncmp(c + p->stripmsd, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
2295 dp_strip = strlen(p->pri->nationalprefix);
2296 pridialplan = PRI_NATIONAL_ISDN;
2298 pridialplan = PRI_LOCAL_ISDN;
2301 pri_sr_set_called(sr, c + p->stripmsd + dp_strip, pridialplan, s ? 1 : 0);
2304 prilocaldialplan = p->pri->localdialplan - 1;
2305 if ((l != NULL) && (prilocaldialplan == -2)) { /* compute dynamically */
2306 if (strncmp(l, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
2307 ldp_strip = strlen(p->pri->internationalprefix);
2308 prilocaldialplan = PRI_INTERNATIONAL_ISDN;
2309 } else if (strncmp(l, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
2310 ldp_strip = strlen(p->pri->nationalprefix);
2311 prilocaldialplan = PRI_NATIONAL_ISDN;
2313 prilocaldialplan = PRI_LOCAL_ISDN;
2316 pri_sr_set_caller(sr, l ? (l + ldp_strip) : NULL, n, prilocaldialplan,
2317 p->use_callingpres ? ast->cid.cid_pres : (l ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_NUMBER_NOT_AVAILABLE));
2318 if ((rr_str = pbx_builtin_getvar_helper(ast, "PRIREDIRECTREASON"))) {
2319 if (!strcasecmp(rr_str, "UNKNOWN"))
2320 redirect_reason = 0;
2321 else if (!strcasecmp(rr_str, "BUSY"))
2322 redirect_reason = 1;
2323 else if (!strcasecmp(rr_str, "NO_REPLY"))
2324 redirect_reason = 2;
2325 else if (!strcasecmp(rr_str, "UNCONDITIONAL"))
2326 redirect_reason = 15;
2328 redirect_reason = PRI_REDIR_UNCONDITIONAL;
2330 redirect_reason = PRI_REDIR_UNCONDITIONAL;
2331 pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, redirect_reason);
2333 #ifdef SUPPORT_USERUSER
2334 /* User-user info */
2335 useruser = pbx_builtin_getvar_helper(p->owner, "USERUSERINFO");
2338 pri_sr_set_useruser(sr, useruser);
2341 if (pri_setup(p->pri->pri, p->call, sr)) {
2342 ast_log(LOG_WARNING, "Unable to setup call to %s (using %s)\n",
2343 c + p->stripmsd + dp_strip, dialplan2str(p->pri->dialplan));
2345 ast_mutex_unlock(&p->lock);
2350 ast_setstate(ast, AST_STATE_DIALING);
2354 ast_mutex_unlock(&p->lock);
2358 static void destroy_zt_pvt(struct zt_pvt **pvt)
2360 struct zt_pvt *p = *pvt;
2361 /* Remove channel from the list */
2363 p->prev->next = p->next;
2365 p->next->prev = p->prev;
2367 ASTOBJ_UNREF(p->smdi_iface, ast_smdi_interface_destroy);
2368 ast_mutex_destroy(&p->lock);
2373 static int destroy_channel(struct zt_pvt *prev, struct zt_pvt *cur, int now)
2383 for (i = 0; i < 3; i++) {
2384 if (cur->subs[i].owner) {
2390 prev->next = cur->next;
2392 prev->next->prev = prev;
2398 iflist->prev = NULL;
2402 if (cur->subs[SUB_REAL].zfd > -1) {
2403 zt_close(cur->subs[SUB_REAL].zfd);
2405 destroy_zt_pvt(&cur);
2409 prev->next = cur->next;
2411 prev->next->prev = prev;
2417 iflist->prev = NULL;
2421 if (cur->subs[SUB_REAL].zfd > -1) {
2422 zt_close(cur->subs[SUB_REAL].zfd);
2424 destroy_zt_pvt(&cur);
2430 static char *zap_send_keypad_facility_app = "ZapSendKeypadFacility";
2432 static char *zap_send_keypad_facility_synopsis = "Send digits out of band over a PRI";
2434 static char *zap_send_keypad_facility_descrip =
2435 " ZapSendKeypadFacility(): This application will send the given string of digits in a Keypad Facility\n"
2436 " IE over the current channel.\n";
2438 static int zap_send_keypad_facility_exec(struct ast_channel *chan, void *data)
2440 /* Data will be our digit string */
2442 char *digits = (char *) data;
2444 if (ast_strlen_zero(digits)) {
2445 ast_log(LOG_DEBUG, "No digit string sent to application!\n");
2449 p = (struct zt_pvt *)chan->tech_pvt;
2452 ast_log(LOG_DEBUG, "Unable to find technology private\n");
2456 ast_mutex_lock(&p->lock);
2458 if (!p->pri || !p->call) {
2459 ast_log(LOG_DEBUG, "Unable to find pri or call on channel!\n");
2460 ast_mutex_unlock(&p->lock);
2464 if (!pri_grab(p, p->pri)) {
2465 pri_keypad_facility(p->pri->pri, p->call, digits);
2468 ast_log(LOG_DEBUG, "Unable to grab pri to send keypad facility!\n");
2469 ast_mutex_unlock(&p->lock);
2473 ast_mutex_unlock(&p->lock);
2478 static int pri_is_up(struct zt_pri *pri)
2481 for (x = 0; x < NUM_DCHANS; x++) {
2482 if (pri->dchanavail[x] == DCHAN_AVAILABLE)
2488 static int pri_assign_bearer(struct zt_pvt *crv, struct zt_pri *pri, struct zt_pvt *bearer)
2490 bearer->owner = &inuse;
2491 bearer->realcall = crv;
2492 crv->subs[SUB_REAL].zfd = bearer->subs[SUB_REAL].zfd;
2493 if (crv->subs[SUB_REAL].owner)
2494 crv->subs[SUB_REAL].owner->fds[0] = crv->subs[SUB_REAL].zfd;
2495 crv->bearer = bearer;
2496 crv->call = bearer->call;
2501 static char *pri_order(int level)
2511 return "Quaternary";
2517 /* Returns fd of the active dchan */
2518 static int pri_active_dchan_fd(struct zt_pri *pri)
2522 for (x = 0; x < NUM_DCHANS; x++) {
2523 if ((pri->dchans[x] == pri->pri))
2530 static int pri_find_dchan(struct zt_pri *pri)
2537 for (x = 0; x < NUM_DCHANS; x++) {
2538 if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
2540 if (pri->dchans[x] == old) {
2546 ast_log(LOG_WARNING, "No D-channels available! Using Primary channel %d as D-channel anyway!\n",
2547 pri->dchannels[newslot]);
2549 if (old && (oldslot != newslot))
2550 ast_log(LOG_NOTICE, "Switching from from d-channel %d to channel %d!\n",
2551 pri->dchannels[oldslot], pri->dchannels[newslot]);
2552 pri->pri = pri->dchans[newslot];
2557 static int zt_hangup(struct ast_channel *ast)
2561 /*static int restore_gains(struct zt_pvt *p);*/
2562 struct zt_pvt *p = ast->tech_pvt;
2563 struct zt_pvt *tmp = NULL;
2564 struct zt_pvt *prev = NULL;
2568 ast_log(LOG_DEBUG, "zt_hangup(%s)\n", ast->name);
2569 if (!ast->tech_pvt) {
2570 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
2574 ast_mutex_lock(&p->lock);
2576 index = zt_get_index(ast, p, 1);
2578 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
2580 ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
2586 if (p->origcid_num) {
2587 ast_copy_string(p->cid_num, p->origcid_num, sizeof(p->cid_num));
2588 free(p->origcid_num);
2589 p->origcid_num = NULL;
2591 if (p->origcid_name) {
2592 ast_copy_string(p->cid_name, p->origcid_name, sizeof(p->cid_name));
2593 free(p->origcid_name);
2594 p->origcid_name = NULL;
2597 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);
2601 ast_log(LOG_DEBUG, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
2602 p->channel, index, p->subs[SUB_REAL].zfd, p->subs[SUB_CALLWAIT].zfd, p->subs[SUB_THREEWAY].zfd);
2606 /* Real channel, do some fixup */
2607 p->subs[index].owner = NULL;
2608 p->subs[index].needanswer = 0;
2609 p->subs[index].needflash = 0;
2610 p->subs[index].needringing = 0;
2611 p->subs[index].needbusy = 0;
2612 p->subs[index].needcongestion = 0;
2613 p->subs[index].linear = 0;
2614 p->subs[index].needcallerid = 0;
2615 p->polarity = POLARITY_IDLE;
2616 zt_setlinear(p->subs[index].zfd, 0);
2617 if (index == SUB_REAL) {
2618 if ((p->subs[SUB_CALLWAIT].zfd > -1) && (p->subs[SUB_THREEWAY].zfd > -1)) {
2619 ast_log(LOG_DEBUG, "Normal call hung up with both three way call and a call waiting call in place?\n");
2620 if (p->subs[SUB_CALLWAIT].inthreeway) {
2621 /* We had flipped over to answer a callwait and now it's gone */
2622 ast_log(LOG_DEBUG, "We were flipped over to the callwait, moving back and unowning.\n");
2623 /* Move to the call-wait, but un-own us until they flip back. */
2624 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
2625 unalloc_sub(p, SUB_CALLWAIT);
2628 /* The three way hung up, but we still have a call wait */
2629 ast_log(LOG_DEBUG, "We were in the threeway and have a callwait still. Ditching the threeway.\n");
2630 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2631 unalloc_sub(p, SUB_THREEWAY);
2632 if (p->subs[SUB_REAL].inthreeway) {
2633 /* This was part of a three way call. Immediately make way for
2635 ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
2636 p->owner = p->subs[SUB_REAL].owner;
2638 /* This call hasn't been completed yet... Set owner to NULL */
2639 ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
2642 p->subs[SUB_REAL].inthreeway = 0;
2644 } else if (p->subs[SUB_CALLWAIT].zfd > -1) {
2645 /* Move to the call-wait and switch back to them. */
2646 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
2647 unalloc_sub(p, SUB_CALLWAIT);
2648 p->owner = p->subs[SUB_REAL].owner;
2649 if (p->owner->_state != AST_STATE_UP)
2650 p->subs[SUB_REAL].needanswer = 1;
2651 if (ast_bridged_channel(p->subs[SUB_REAL].owner))
2652 ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD);
2653 } else if (p->subs[SUB_THREEWAY].zfd > -1) {
2654 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2655 unalloc_sub(p, SUB_THREEWAY);
2656 if (p->subs[SUB_REAL].inthreeway) {
2657 /* This was part of a three way call. Immediately make way for
2659 ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
2660 p->owner = p->subs[SUB_REAL].owner;
2662 /* This call hasn't been completed yet... Set owner to NULL */
2663 ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
2666 p->subs[SUB_REAL].inthreeway = 0;
2668 } else if (index == SUB_CALLWAIT) {
2669 /* Ditch the holding callwait call, and immediately make it availabe */
2670 if (p->subs[SUB_CALLWAIT].inthreeway) {
2671 /* This is actually part of a three way, placed on hold. Place the third part
2672 on music on hold now */
2673 if (p->subs[SUB_THREEWAY].owner && ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) {
2674 ast_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD,
2675 S_OR(p->mohsuggest, NULL),
2676 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
2678 p->subs[SUB_THREEWAY].inthreeway = 0;
2679 /* Make it the call wait now */
2680 swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
2681 unalloc_sub(p, SUB_THREEWAY);
2683 unalloc_sub(p, SUB_CALLWAIT);
2684 } else if (index == SUB_THREEWAY) {
2685 if (p->subs[SUB_CALLWAIT].inthreeway) {
2686 /* The other party of the three way call is currently in a call-wait state.
2687 Start music on hold for them, and take the main guy out of the third call */
2688 if (p->subs[SUB_CALLWAIT].owner && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) {
2689 ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD,
2690 S_OR(p->mohsuggest, NULL),
2691 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
2693 p->subs[SUB_CALLWAIT].inthreeway = 0;
2695 p->subs[SUB_REAL].inthreeway = 0;
2696 /* If this was part of a three way call index, let us make
2697 another three way call */
2698 unalloc_sub(p, SUB_THREEWAY);
2700 /* This wasn't any sort of call, but how are we an index? */
2701 ast_log(LOG_WARNING, "Index found but not any type of call?\n");
2705 if (!p->subs[SUB_REAL].owner && !p->subs[SUB_CALLWAIT].owner && !p->subs[SUB_THREEWAY].owner) {
2708 p->distinctivering = 0;
2709 p->confirmanswer = 0;
2715 p->onhooktime = time(NULL);
2723 ast_dsp_free(p->dsp);
2727 law = ZT_LAW_DEFAULT;
2728 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETLAW, &law);
2730 ast_log(LOG_WARNING, "Unable to set law on channel %d to default\n", p->channel);
2731 /* Perform low level hangup if no owner left */
2735 if (!ss7_grab(p, p->ss7)) {
2736 if (!p->alreadyhungup) {
2737 isup_rel(p->ss7->ss7, p->ss7call, ast->hangupcause ? ast->hangupcause : -1);
2739 p->alreadyhungup = 1;
2741 ast_log(LOG_WARNING, "Trying to hangup twice!\n");
2743 ast_log(LOG_WARNING, "Unable to grab SS7 on CIC %d\n", p->cic);
2751 #ifdef SUPPORT_USERUSER
2752 const char *useruser = pbx_builtin_getvar_helper(ast,"USERUSERINFO");
2755 /* Make sure we have a call (or REALLY have a call in the case of a PRI) */
2756 if (p->call && (!p->bearer || (p->bearer->call == p->call))) {
2757 if (!pri_grab(p, p->pri)) {
2758 if (p->alreadyhungup) {
2759 ast_log(LOG_DEBUG, "Already hungup... Calling hangup once, and clearing call\n");
2761 #ifdef SUPPORT_USERUSER
2762 pri_call_set_useruser(p->call, useruser);
2765 pri_hangup(p->pri->pri, p->call, -1);
2768 p->bearer->call = NULL;
2770 const char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE");
2771 int icause = ast->hangupcause ? ast->hangupcause : -1;
2772 ast_log(LOG_DEBUG, "Not yet hungup... Calling hangup once with icause, and clearing call\n");
2774 #ifdef SUPPORT_USERUSER
2775 pri_call_set_useruser(p->call, useruser);
2778 p->alreadyhungup = 1;
2780 p->bearer->alreadyhungup = 1;
2783 icause = atoi(cause);
2785 pri_hangup(p->pri->pri, p->call, icause);
2788 ast_log(LOG_WARNING, "pri_disconnect failed\n");
2791 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
2796 ast_log(LOG_DEBUG, "Bearer call is %p, while ours is still %p\n", p->bearer->call, p->call);
2802 if (p->sig && ((p->sig != SIG_PRI) && (p->sig != SIG_SS7)))
2803 res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_ONHOOK);
2805 ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name);
2811 res = ioctl(p->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &par);
2814 ast_log(LOG_DEBUG, "Hanging up channel %d, offhook = %d\n", p->channel, par.rxisoffhook);
2816 /* If they're off hook, try playing congestion */
2817 if ((par.rxisoffhook) && (!(p->radio || (p->oprmode < 0))))
2818 tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_CONGESTION);
2820 tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
2826 /* Make sure we're not made available for at least two seconds assuming
2827 we were actually used for an inbound or outbound call. */
2828 if (ast->_state != AST_STATE_RESERVED) {
2829 time(&p->guardtime);
2834 tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
2841 ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0);
2842 ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0);
2846 p->callwaiting = p->permcallwaiting;
2847 p->hidecallerid = p->permhidecallerid;
2852 /* Restore data mode */
2853 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
2855 ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
2859 ast_log(LOG_DEBUG, "Freeing up bearer channel %d\n", p->bearer->channel);
2860 /* Free up the bearer channel as well, and
2861 don't use its file descriptor anymore */
2862 update_conf(p->bearer);
2863 reset_conf(p->bearer);
2864 p->bearer->owner = NULL;
2865 p->bearer->realcall = NULL;
2867 p->subs[SUB_REAL].zfd = -1;
2874 p->callwaitingrepeat = 0;
2877 ast->tech_pvt = NULL;
2878 ast_mutex_unlock(&p->lock);
2879 ast_atomic_fetchadd_int(&usecnt, -1);
2880 ast_update_use_count();
2881 if (option_verbose > 2)
2882 ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);
2884 ast_mutex_lock(&iflock);
2890 destroy_channel(prev, tmp, 0);
2898 ast_mutex_unlock(&iflock);
2902 static int zt_answer(struct ast_channel *ast)
2904 struct zt_pvt *p = ast->tech_pvt;
2907 int oldstate = ast->_state;
2908 ast_setstate(ast, AST_STATE_UP);
2909 ast_mutex_lock(&p->lock);
2910 index = zt_get_index(ast, p, 0);
2913 /* nothing to do if a radio channel */
2914 if ((p->radio || (p->oprmode < 0))) {
2915 ast_mutex_unlock(&p->lock);
2929 case SIG_FEATDMF_TA:
2932 case SIG_FGC_CAMAMF:
2937 case SIG_SF_FEATDMF:
2942 /* Pick up the line */
2943 ast_log(LOG_DEBUG, "Took %s off hook\n", ast->name);
2944 if (p->hanguponpolarityswitch) {
2945 gettimeofday(&p->polaritydelaytv, NULL);
2947 res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
2948 tone_zone_play_tone(p->subs[index].zfd, -1);
2950 if ((index == SUB_REAL) && p->subs[SUB_THREEWAY].inthreeway) {
2951 if (oldstate == AST_STATE_RINGING) {
2952 ast_log(LOG_DEBUG, "Finally swapping real and threeway\n");
2953 tone_zone_play_tone(p->subs[SUB_THREEWAY].zfd, -1);
2954 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2955 p->owner = p->subs[SUB_REAL].owner;
2958 if (p->sig & __ZT_SIG_FXS) {
2965 /* Send a pri acknowledge */
2966 if (!pri_grab(p, p->pri)) {
2968 res = pri_answer(p->pri->pri, p->call, 0, !p->digital);
2971 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
2978 if (!ss7_grab(p, p->ss7)) {
2980 res = isup_anm(p->ss7->ss7, p->ss7call);
2983 ast_log(LOG_WARNING, "Unable to grab SS7 on span %d\n", p->span);
2989 ast_mutex_unlock(&p->lock);
2992 ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
2995 ast_mutex_unlock(&p->lock);
2999 static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen)
3005 struct zt_pvt *p = chan->tech_pvt, *pp;
3006 struct oprmode *oprmode;
3009 /* all supported options require data */
3010 if (!data || (datalen < 1)) {
3016 case AST_OPTION_TXGAIN:
3017 scp = (signed char *) data;
3018 index = zt_get_index(chan, p, 0);
3020 ast_log(LOG_WARNING, "No index in TXGAIN?\n");
3023 ast_log(LOG_DEBUG, "Setting actual tx gain on %s to %f\n", chan->name, p->txgain + (float) *scp);
3024 return set_actual_txgain(p->subs[index].zfd, 0, p->txgain + (float) *scp, p->law);
3025 case AST_OPTION_RXGAIN:
3026 scp = (signed char *) data;
3027 index = zt_get_index(chan, p, 0);
3029 ast_log(LOG_WARNING, "No index in RXGAIN?\n");
3032 ast_log(LOG_DEBUG, "Setting actual rx gain on %s to %f\n", chan->name, p->rxgain + (float) *scp);
3033 return set_actual_rxgain(p->subs[index].zfd, 0, p->rxgain + (float) *scp, p->law);
3034 case AST_OPTION_TONE_VERIFY:
3040 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF(1) on %s\n",chan->name);
3041 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | p->dtmfrelax); /* set mute mode if desired */
3044 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF/MAX(2) on %s\n",chan->name);
3045 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX | p->dtmfrelax); /* set mute mode if desired */
3048 ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: OFF(0) on %s\n",chan->name);
3049 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax); /* set mute mode if desired */
3053 case AST_OPTION_TDD:
3054 /* turn on or off TDD */
3057 if (!*cp) { /* turn it off */
3058 ast_log(LOG_DEBUG, "Set option TDD MODE, value: OFF(0) on %s\n",chan->name);
3064 ast_log(LOG_DEBUG, "Set option TDD MODE, value: %s(%d) on %s\n",
3065 (*cp == 2) ? "MATE" : "ON", (int) *cp, chan->name);
3067 /* otherwise, turn it on */
3068 if (!p->didtdd) { /* if havent done it yet */
3069 unsigned char mybuf[41000], *buf;
3070 int size, res, fd, len;
3071 struct pollfd fds[1];
3074 memset(buf, 0x7f, sizeof(mybuf)); /* set to silence */
3075 ast_tdd_gen_ecdisa(buf + 16000, 16000); /* put in tone */
3077 index = zt_get_index(chan, p, 0);
3079 ast_log(LOG_WARNING, "No index in TDD?\n");
3082 fd = p->subs[index].zfd;
3084 if (ast_check_hangup(chan))
3087 if (size > READ_SIZE)
3090 fds[0].events = POLLPRI | POLLOUT;
3092 res = poll(fds, 1, -1);
3094 ast_log(LOG_DEBUG, "poll (for write) ret. 0 on channel %d\n", p->channel);
3097 /* if got exception */
3098 if (fds[0].revents & POLLPRI)
3100 if (!(fds[0].revents & POLLOUT)) {
3101 ast_log(LOG_DEBUG, "write fd not ready on channel %d\n", p->channel);
3104 res = write(fd, buf, size);
3106 if (res == -1) return -1;
3107 ast_log(LOG_DEBUG, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
3113 p->didtdd = 1; /* set to have done it now */
3115 if (*cp == 2) { /* Mate mode */
3122 if (!p->tdd) { /* if we dont have one yet */
3123 p->tdd = tdd_new(); /* allocate one */
3126 case AST_OPTION_RELAXDTMF: /* Relax DTMF decoding (or not) */
3130 ast_log(LOG_DEBUG, "Set option RELAX DTMF, value: %s(%d) on %s\n",
3131 *cp ? "ON" : "OFF", (int) *cp, chan->name);
3132 ast_dsp_digitmode(p->dsp, ((*cp) ? DSP_DIGITMODE_RELAXDTMF : DSP_DIGITMODE_DTMF) | p->dtmfrelax);
3134 case AST_OPTION_AUDIO_MODE: /* Set AUDIO mode (or not) */
3137 ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: OFF(0) on %s\n", chan->name);
3141 ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: ON(1) on %s\n", chan->name);
3144 if (ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x) == -1)
3145 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d\n", p->channel, x);
3147 case AST_OPTION_OPRMODE: /* Operator services mode */
3148 oprmode = (struct oprmode *) data;
3149 pp = oprmode->peer->tech_pvt;
3150 p->oprmode = pp->oprmode = 0;
3154 /* setup modes, if any */
3157 pp->oprmode = oprmode->mode;
3158 p->oprmode = -oprmode->mode;
3160 ast_log(LOG_DEBUG, "Set Operator Services mode, value: %d on %s/%s\n",
3161 oprmode->mode, chan->name,oprmode->peer->name);;
3163 case AST_OPTION_ECHOCAN:
3166 ast_log(LOG_DEBUG, "Enabling echo cancelation on %s\n", chan->name);
3169 ast_log(LOG_DEBUG, "Disabling echo cancelation on %s\n", chan->name);
3179 static int zt_func_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
3181 struct zt_pvt *p = chan->tech_pvt;
3183 if (!strcasecmp(data, "rxgain")) {
3184 ast_mutex_lock(&p->lock);
3185 snprintf(buf, len, "%f", p->rxgain);
3186 ast_mutex_unlock(&p->lock);
3187 } else if (!strcasecmp(data, "txgain")) {
3188 ast_mutex_lock(&p->lock);
3189 snprintf(buf, len, "%f", p->txgain);
3190 ast_mutex_unlock(&p->lock);
3192 ast_copy_string(buf, "", len);
3198 static void zt_unlink(struct zt_pvt *slave, struct zt_pvt *master, int needlock)
3200 /* Unlink a specific slave or all slaves/masters from a given master */
3206 ast_mutex_lock(&master->lock);
3208 while (ast_mutex_trylock(&slave->lock)) {
3209 ast_mutex_unlock(&master->lock);
3211 ast_mutex_lock(&master->lock);
3216 for (x = 0; x < MAX_SLAVES; x++) {
3217 if (master->slaves[x]) {
3218 if (!slave || (master->slaves[x] == slave)) {
3219 /* Take slave out of the conference */
3220 ast_log(LOG_DEBUG, "Unlinking slave %d from %d\n", master->slaves[x]->channel, master->channel);
3221 conf_del(master, &master->slaves[x]->subs[SUB_REAL], SUB_REAL);
3222 conf_del(master->slaves[x], &master->subs[SUB_REAL], SUB_REAL);
3223 master->slaves[x]->master = NULL;
3224 master->slaves[x] = NULL;
3229 master->inconference = 0;
3232 if (master->master) {
3233 /* Take master out of the conference */
3234 conf_del(master->master, &master->subs[SUB_REAL], SUB_REAL);
3235 conf_del(master, &master->master->subs[SUB_REAL], SUB_REAL);
3237 for (x = 0; x < MAX_SLAVES; x++) {
3238 if (master->master->slaves[x] == master)
3239 master->master->slaves[x] = NULL;
3240 else if (master->master->slaves[x])
3244 master->master->inconference = 0;
3246 master->master = NULL;
3248 update_conf(master);
3251 ast_mutex_unlock(&slave->lock);
3252 ast_mutex_unlock(&master->lock);
3256 static void zt_link(struct zt_pvt *slave, struct zt_pvt *master) {
3258 if (!slave || !master) {
3259 ast_log(LOG_WARNING, "Tried to link to/from NULL??\n");
3262 for (x = 0; x < MAX_SLAVES; x++) {
3263 if (!master->slaves[x]) {
3264 master->slaves[x] = slave;
3268 if (x >= MAX_SLAVES) {
3269 ast_log(LOG_WARNING, "Replacing slave %d with new slave, %d\n", master->slaves[MAX_SLAVES - 1]->channel, slave->channel);
3270 master->slaves[MAX_SLAVES - 1] = slave;
3273 ast_log(LOG_WARNING, "Replacing master %d with new master, %d\n", slave->master->channel, master->channel);
3274 slave->master = master;
3276 ast_log(LOG_DEBUG, "Making %d slave to master %d at %d\n", slave->channel, master->channel, x);
3279 static void disable_dtmf_detect(struct zt_pvt *p)
3281 #ifdef ZT_TONEDETECT
3287 #ifdef ZT_TONEDETECT
3289 ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
3291 if (!p->hardwaredtmf && p->dsp) {
3292 p->dsp_features &= ~DSP_FEATURE_DTMF_DETECT;
3293 ast_dsp_set_features(p->dsp, p->dsp_features);
3297 static void enable_dtmf_detect(struct zt_pvt *p)
3299 #ifdef ZT_TONEDETECT
3303 if (p->channel == CHAN_PSEUDO)
3308 #ifdef ZT_TONEDETECT
3309 val = ZT_TONEDETECT_ON | ZT_TONEDETECT_MUTE;
3310 ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
3312 if (!p->hardwaredtmf && p->dsp) {
3313 p->dsp_features |= DSP_FEATURE_DTMF_DETECT;
3314 ast_dsp_set_features(p->dsp, p->dsp_features);
3318 static enum ast_bridge_result zt_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms)
3320 struct ast_channel *who;
3321 struct zt_pvt *p0, *p1, *op0, *op1;
3322 struct zt_pvt *master = NULL, *slave = NULL;
3323 struct ast_frame *f;
3327 int oi0, oi1, i0 = -1, i1 = -1, t0, t1;
3328 int os0 = -1, os1 = -1;
3330 struct ast_channel *oc0, *oc1;
3331 enum ast_bridge_result res;
3334 int triedtopribridge = 0;
3335 q931_call *q931c0 = NULL, *q931c1 = NULL;
3338 /* For now, don't attempt to native bridge if either channel needs DTMF detection.
3339 There is code below to handle it properly until DTMF is actually seen,
3340 but due to currently unresolved issues it's ignored...
3343 if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
3344 return AST_BRIDGE_FAILED_NOWARN;
3346 ast_mutex_lock(&c0->lock);
3347 ast_mutex_lock(&c1->lock);
3351 /* cant do pseudo-channels here */
3352 if (!p0 || (!p0->sig) || !p1 || (!p1->sig)) {
3353 ast_mutex_unlock(&c0->lock);
3354 ast_mutex_unlock(&c1->lock);
3355 return AST_BRIDGE_FAILED_NOWARN;
3358 oi0 = zt_get_index(c0, p0, 0);
3359 oi1 = zt_get_index(c1, p1, 0);
3360 if ((oi0 < 0) || (oi1 < 0)) {
3361 ast_mutex_unlock(&c0->lock);
3362 ast_mutex_unlock(&c1->lock);
3363 return AST_BRIDGE_FAILED;
3366 op0 = p0 = c0->tech_pvt;
3367 op1 = p1 = c1->tech_pvt;
3373 if (ast_mutex_trylock(&p0->lock)) {
3374 /* Don't block, due to potential for deadlock */
3375 ast_mutex_unlock(&c0->lock);
3376 ast_mutex_unlock(&c1->lock);
3377 ast_log(LOG_NOTICE, "Avoiding deadlock...\n");
3378 return AST_BRIDGE_RETRY;
3380 if (ast_mutex_trylock(&p1->lock)) {
3381 /* Don't block, due to potential for deadlock */
3382 ast_mutex_unlock(&p0->lock);
3383 ast_mutex_unlock(&c0->lock);
3384 ast_mutex_unlock(&c1->lock);
3385 ast_log(LOG_NOTICE, "Avoiding deadlock...\n");
3386 return AST_BRIDGE_RETRY;
3389 if ((oi0 == SUB_REAL) && (oi1 == SUB_REAL)) {
3390 if (p0->owner && p1->owner) {
3391 /* If we don't have a call-wait in a 3-way, and we aren't in a 3-way, we can be master */
3392 if (!p0->subs[SUB_CALLWAIT].inthreeway && !p1->subs[SUB_REAL].inthreeway) {
3396 } else if (!p1->subs[SUB_CALLWAIT].inthreeway && !p0->subs[SUB_REAL].inthreeway) {
3401 ast_log(LOG_WARNING, "Huh? Both calls are callwaits or 3-ways? That's clever...?\n");
3402 ast_log(LOG_WARNING, "p0: chan %d/%d/CW%d/3W%d, p1: chan %d/%d/CW%d/3W%d\n",
3404 oi0, (p0->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0,
3405 p0->subs[SUB_REAL].inthreeway, p0->channel,
3406 oi0, (p1->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0,
3407 p1->subs[SUB_REAL].inthreeway);
3411 } else if ((oi0 == SUB_REAL) && (oi1 == SUB_THREEWAY)) {
3412 if (p1->subs[SUB_THREEWAY].inthreeway) {
3417 } else if ((oi0 == SUB_THREEWAY) && (oi1 == SUB_REAL)) {
3418 if (p0->subs[SUB_THREEWAY].inthreeway) {
3423 } else if ((oi0 == SUB_REAL) && (oi1 == SUB_CALLWAIT)) {
3424 /* We have a real and a call wait. If we're in a three way call, put us in it, otherwise,
3425 don't put us in anything */
3426 if (p1->subs[SUB_CALLWAIT].inthreeway) {
3431 } else if ((oi0 == SUB_CALLWAIT) && (oi1 == SUB_REAL)) {
3432 /* Same as previous */
3433 if (p0->subs[SUB_CALLWAIT].inthreeway) {
3439 ast_log(LOG_DEBUG, "master: %d, slave: %d, nothingok: %d\n",
3440 master ? master->channel : 0, slave ? slave->channel : 0, nothingok);
3441 if (master && slave) {
3442 /* Stop any tones, or play ringtone as appropriate. If they're bridged
3443 in an active threeway call with a channel that is ringing, we should
3444 indicate ringing. */
3445 if ((oi1 == SUB_THREEWAY) &&
3446 p1->subs[SUB_THREEWAY].inthreeway &&
3447 p1->subs[SUB_REAL].owner &&
3448 p1->subs[SUB_REAL].inthreeway &&
3449 (p1->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
3450 ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c0->name, c1->name);
3451 tone_zone_play_tone(p0->subs[oi0].zfd, ZT_TONE_RINGTONE);
3452 os1 = p1->subs[SUB_REAL].owner->_state;
3454 ast_log(LOG_DEBUG, "Stopping tones on %d/%d talking to %d/%d\n", p0->channel, oi0, p1->channel, oi1);
3455 tone_zone_play_tone(p0->subs[oi0].zfd, -1);
3457 if ((oi0 == SUB_THREEWAY) &&
3458 p0->subs[SUB_THREEWAY].inthreeway &&
3459 p0->subs[SUB_REAL].owner &&
3460 p0->subs[SUB_REAL].inthreeway &&
3461 (p0->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
3462 ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c1->name, c0->name);
3463 tone_zone_play_tone(p1->subs[oi1].zfd, ZT_TONE_RINGTONE);
3464 os0 = p0->subs[SUB_REAL].owner->_state;
3466 ast_log(LOG_DEBUG, "Stopping tones on %d/%d talking to %d/%d\n", p1->channel, oi1, p0->channel, oi0);
3467 tone_zone_play_tone(p1->subs[oi0].zfd, -1);
3469 if ((oi0 == SUB_REAL) && (oi1 == SUB_REAL)) {
3470 if (!p0->echocanbridged || !p1->echocanbridged) {
3471 /* Disable echo cancellation if appropriate */
3476 zt_link(slave, master);
3477 master->inconference = inconf;
3478 } else if (!nothingok)
3479 ast_log(LOG_WARNING, "Can't link %d/%s with %d/%s\n", p0->channel, subnames[oi0], p1->channel, subnames[oi1]);