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>res_smdi</depend>
42 <depend>zaptel_vldtmf</depend>
43 <depend>zaptel</depend>
44 <depend>tonezone</depend>
51 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
59 #include <sys/signal.h>
63 #if !defined(SOLARIS) && !defined(__FreeBSD__)
67 #include <sys/ioctl.h>
70 #include "asterisk/zapata.h"
80 #include "asterisk/lock.h"
81 #include "asterisk/channel.h"
82 #include "asterisk/config.h"
83 #include "asterisk/logger.h"
84 #include "asterisk/module.h"
85 #include "asterisk/pbx.h"
86 #include "asterisk/options.h"
87 #include "asterisk/file.h"
88 #include "asterisk/ulaw.h"
89 #include "asterisk/alaw.h"
90 #include "asterisk/callerid.h"
91 #include "asterisk/adsi.h"
92 #include "asterisk/cli.h"
93 #include "asterisk/cdr.h"
94 #include "asterisk/features.h"
95 #include "asterisk/musiconhold.h"
96 #include "asterisk/say.h"
97 #include "asterisk/tdd.h"
98 #include "asterisk/app.h"
99 #include "asterisk/dsp.h"
100 #include "asterisk/astdb.h"
101 #include "asterisk/manager.h"
102 #include "asterisk/causes.h"
103 #include "asterisk/term.h"
104 #include "asterisk/utils.h"
105 #include "asterisk/transcap.h"
106 #include "asterisk/stringfields.h"
107 #include "asterisk/abstract_jb.h"
108 #include "asterisk/smdi.h"
109 #include "asterisk/astobj.h"
110 #include "asterisk/event.h"
112 #define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */
114 /*! Global jitterbuffer configuration - by default, jb is disabled */
115 static struct ast_jb_conf default_jbconf =
119 .resync_threshold = -1,
122 static struct ast_jb_conf global_jbconf;
124 #if !defined(ZT_SIG_EM_E1) || (defined(HAVE_PRI) && !defined(ZT_SIG_HARDHDLC))
125 #error "Your zaptel is too old. Please update"
128 #ifndef ZT_TONEDETECT
129 /* Work around older code with no tone detect */
130 #define ZT_EVENT_DTMFDOWN 0
131 #define ZT_EVENT_DTMFUP 0
134 /* define this to send PRI user-user information elements */
135 #undef SUPPORT_USERUSER
138 * \note Define ZHONE_HACK to cause us to go off hook and then back on hook when
139 * the user hangs up to reset the state machine so ring works properly.
140 * This is used to be able to support kewlstart by putting the zhone in
141 * groundstart mode since their forward disconnect supervision is entirely
142 * broken even though their documentation says it isn't and their support
143 * is entirely unwilling to provide any assistance with their channel banks
144 * even though their web site says they support their products for life.
146 /* #define ZHONE_HACK */
149 * Define if you want to check the hook state for an FXO (FXS signalled) interface
150 * before dialing on it. Certain FXO interfaces always think they're out of
151 * service with this method however.
153 /* #define ZAP_CHECK_HOOKSTATE */
155 /*! \brief Typically, how many rings before we should send Caller*ID */
156 #define DEFAULT_CIDRINGS 1
158 #define CHANNEL_PSEUDO -12
160 #define AST_LAW(p) (((p)->law == ZT_LAW_ALAW) ? AST_FORMAT_ALAW : AST_FORMAT_ULAW)
162 /*! \brief Signaling types that need to use MF detection should be placed in this macro */
163 #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))
165 static const char tdesc[] = "Zapata Telephony Driver"
174 static const char config[] = "zapata.conf";
176 #define SIG_EM ZT_SIG_EM
177 #define SIG_EMWINK (0x0100000 | ZT_SIG_EM)
178 #define SIG_FEATD (0x0200000 | ZT_SIG_EM)
179 #define SIG_FEATDMF (0x0400000 | ZT_SIG_EM)
180 #define SIG_FEATB (0x0800000 | ZT_SIG_EM)
181 #define SIG_E911 (0x1000000 | ZT_SIG_EM)
182 #define SIG_FEATDMF_TA (0x2000000 | ZT_SIG_EM)
183 #define SIG_FGC_CAMA (0x4000000 | ZT_SIG_EM)
184 #define SIG_FGC_CAMAMF (0x8000000 | ZT_SIG_EM)
185 #define SIG_FXSLS ZT_SIG_FXSLS
186 #define SIG_FXSGS ZT_SIG_FXSGS
187 #define SIG_FXSKS ZT_SIG_FXSKS
188 #define SIG_FXOLS ZT_SIG_FXOLS
189 #define SIG_FXOGS ZT_SIG_FXOGS
190 #define SIG_FXOKS ZT_SIG_FXOKS
191 #define SIG_PRI ZT_SIG_CLEAR
192 #define SIG_SS7 (0x1000000 | ZT_SIG_CLEAR)
193 #define SIG_SF ZT_SIG_SF
194 #define SIG_SFWINK (0x0100000 | ZT_SIG_SF)
195 #define SIG_SF_FEATD (0x0200000 | ZT_SIG_SF)
196 #define SIG_SF_FEATDMF (0x0400000 | ZT_SIG_SF)
197 #define SIG_SF_FEATB (0x0800000 | ZT_SIG_SF)
198 #define SIG_EM_E1 ZT_SIG_EM_E1
199 #define SIG_GR303FXOKS (0x0100000 | ZT_SIG_FXOKS)
200 #define SIG_GR303FXSKS (0x0100000 | ZT_SIG_FXSKS)
203 #define NUM_DCHANS 4 /*!< No more than 4 d-channels */
204 #define MAX_CHANNELS 672 /*!< No more than a DS3 per trunk group */
206 #define CHAN_PSEUDO -2
208 #define DCHAN_PROVISIONED (1 << 0)
209 #define DCHAN_NOTINALARM (1 << 1)
210 #define DCHAN_UP (1 << 2)
212 #define DCHAN_AVAILABLE (DCHAN_PROVISIONED | DCHAN_NOTINALARM | DCHAN_UP)
214 /* Overlap dialing option types */
215 #define ZAP_OVERLAPDIAL_NONE 0
216 #define ZAP_OVERLAPDIAL_OUTGOING 1
217 #define ZAP_OVERLAPDIAL_INCOMING 2
218 #define ZAP_OVERLAPDIAL_BOTH (ZAP_OVERLAPDIAL_INCOMING|ZAP_OVERLAPDIAL_OUTGOING)
220 static char defaultcic[64] = "";
221 static char defaultozz[64] = "";
223 static char progzone[10] = "";
225 static int usedistinctiveringdetection = 0;
226 static int distinctiveringaftercid = 0;
228 static int numbufs = 4;
231 static struct ast_channel inuse;
232 #ifdef PRI_GETSET_TIMERS
233 static int pritimers[PRI_MAX_TIMERS];
235 static int pridebugfd = -1;
236 static char pridebugfilename[1024] = "";
239 /*! \brief Wait up to 16 seconds for first digit (FXO logic) */
240 static int firstdigittimeout = 16000;
242 /*! \brief How long to wait for following digits (FXO logic) */
243 static int gendigittimeout = 8000;
245 /*! \brief How long to wait for an extra digit, if there is an ambiguous match */
246 static int matchdigittimeout = 3000;
248 /*! \brief Protect the interface list (of zt_pvt's) */
249 AST_MUTEX_DEFINE_STATIC(iflock);
252 static int ifcount = 0;
255 AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
258 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
259 when it's doing something critical. */
260 AST_MUTEX_DEFINE_STATIC(monlock);
262 /*! \brief This is the thread for the monitor which checks for input on the channels
263 which are not currently in use. */
264 static pthread_t monitor_thread = AST_PTHREADT_NULL;
266 static int restart_monitor(void);
268 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);
270 static int zt_sendtext(struct ast_channel *c, const char *text);
272 static void mwi_event_cb(const struct ast_event *event, void *userdata)
274 /* This module does not handle MWI in an event-based manner. However, it
275 * subscribes to MWI for each mailbox that is configured so that the core
276 * knows that we care about it. Then, chan_zap will get the MWI from the
277 * event cache instead of checking the mailbox directly. */
280 /*! \brief Avoid the silly zt_getevent which ignores a bunch of events */
281 static inline int zt_get_event(int fd)
284 if (ioctl(fd, ZT_GETEVENT, &j) == -1)
289 /*! \brief Avoid the silly zt_waitevent which ignores a bunch of events */
290 static inline int zt_wait_event(int fd)
293 i = ZT_IOMUX_SIGEVENT;
294 if (ioctl(fd, ZT_IOMUX, &i) == -1)
296 if (ioctl(fd, ZT_GETEVENT, &j) == -1)
301 /*! Chunk size to read -- we use 20ms chunks to make things happy. */
302 #define READ_SIZE 160
304 #define MASK_AVAIL (1 << 0) /*!< Channel available for PRI use */
305 #define MASK_INUSE (1 << 1) /*!< Channel currently in use */
307 #define CALLWAITING_SILENT_SAMPLES ( (300 * 8) / READ_SIZE) /*!< 300 ms */
308 #define CALLWAITING_REPEAT_SAMPLES ( (10000 * 8) / READ_SIZE) /*!< 300 ms */
309 #define CIDCW_EXPIRE_SAMPLES ( (500 * 8) / READ_SIZE) /*!< 500 ms */
310 #define MIN_MS_SINCE_FLASH ( (2000) ) /*!< 2000 ms */
311 #define DEFAULT_RINGT ( (8000 * 8) / READ_SIZE)
315 static int ringt_base = DEFAULT_RINGT;
319 #define LINKSTATE_INALARM (1 << 0)
320 #define LINKSTATE_STARTING (1 << 1)
321 #define LINKSTATE_UP (1 << 2)
322 #define LINKSTATE_DOWN (1 << 3)
324 #define SS7_NAI_DYNAMIC -1
327 pthread_t master; /*!< Thread of master */
331 int linkstate[NUM_DCHANS];
335 LINKSET_STATE_DOWN = 0,
338 char called_nai; /*!< Called Nature of Address Indicator */
339 char calling_nai; /*!< Calling Nature of Address Indicator */
340 char internationalprefix[10]; /*!< country access code ('00' for european dialplans) */
341 char nationalprefix[10]; /*!< area access code ('0' for european dialplans) */
342 char subscriberprefix[20]; /*!< area access code + area code ('0'+area code for european dialplans) */
343 char unknownprefix[20]; /*!< for unknown dialplans */
345 struct zt_pvt *pvts[MAX_CHANNELS]; /*!< Member channel pvt structs */
348 static struct zt_ss7 linksets[NUM_SPANS];
350 static int cur_ss7type = -1;
351 static int cur_linkset = -1;
352 static int cur_pointcode = -1;
353 static int cur_cicbeginswith = -1;
354 static int cur_adjpointcode = -1;
355 static int cur_networkindicator = -1;
356 static int cur_defaultdpc = -1;
357 #endif /* HAVE_SS7 */
361 #define PVT_TO_CHANNEL(p) (((p)->prioffset) | ((p)->logicalspan << 8) | (p->pri->mastertrunkgroup ? 0x10000 : 0))
362 #define PRI_CHANNEL(p) ((p) & 0xff)
363 #define PRI_SPAN(p) (((p) >> 8) & 0xff)
364 #define PRI_EXPLICIT(p) (((p) >> 16) & 0x01)
367 pthread_t master; /*!< Thread of master */
368 ast_mutex_t lock; /*!< Mutex */
369 char idleext[AST_MAX_EXTENSION]; /*!< Where to idle extra calls */
370 char idlecontext[AST_MAX_CONTEXT]; /*!< What context to use for idle */
371 char idledial[AST_MAX_EXTENSION]; /*!< What to dial before dumping */
372 int minunused; /*!< Min # of channels to keep empty */
373 int minidle; /*!< Min # of "idling" calls to keep active */
374 int nodetype; /*!< Node type */
375 int switchtype; /*!< Type of switch to emulate */
376 int nsf; /*!< Network-Specific Facilities */
377 int dialplan; /*!< Dialing plan */
378 int localdialplan; /*!< Local dialing plan */
379 char internationalprefix[10]; /*!< country access code ('00' for european dialplans) */
380 char nationalprefix[10]; /*!< area access code ('0' for european dialplans) */
381 char localprefix[20]; /*!< area access code + area code ('0'+area code for european dialplans) */
382 char privateprefix[20]; /*!< for private dialplans */
383 char unknownprefix[20]; /*!< for unknown dialplans */
384 int dchannels[NUM_DCHANS]; /*!< What channel are the dchannels on */
385 int trunkgroup; /*!< What our trunkgroup is */
386 int mastertrunkgroup; /*!< What trunk group is our master */
387 int prilogicalspan; /*!< Logical span number within trunk group */
388 int numchans; /*!< Num of channels we represent */
389 int overlapdial; /*!< In overlap dialing mode */
390 int facilityenable; /*!< Enable facility IEs */
391 struct pri *dchans[NUM_DCHANS]; /*!< Actual d-channels */
392 int dchanavail[NUM_DCHANS]; /*!< Whether each channel is available */
393 struct pri *pri; /*!< Currently active D-channel */
395 int fds[NUM_DCHANS]; /*!< FD's for d-channels */
400 time_t lastreset; /*!< time when unused channels were last reset */
401 long resetinterval; /*!< Interval (in seconds) for resetting unused channels */
402 struct zt_pvt *pvts[MAX_CHANNELS]; /*!< Member channel pvt structs */
403 struct zt_pvt *crvs; /*!< Member CRV structs */
404 struct zt_pvt *crvend; /*!< Pointer to end of CRV structs */
408 static struct zt_pri pris[NUM_SPANS];
411 #define DEFAULT_PRI_DEBUG (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE)
413 #define DEFAULT_PRI_DEBUG 0
416 static inline void pri_rel(struct zt_pri *pri)
418 ast_mutex_unlock(&pri->lock);
422 /*! Shut up the compiler */
426 #define SUB_REAL 0 /*!< Active call */
427 #define SUB_CALLWAIT 1 /*!< Call-Waiting call on hold */
428 #define SUB_THREEWAY 2 /*!< Three-way call */
430 /* Polarity states */
431 #define POLARITY_IDLE 0
432 #define POLARITY_REV 1
435 static struct zt_distRings drings;
437 struct distRingData {
441 struct ringContextData {
442 char contextData[AST_MAX_CONTEXT];
444 struct zt_distRings {
445 struct distRingData ringnum[3];
446 struct ringContextData ringContext[3];
449 static char *subnames[] = {
455 struct zt_subchannel {
457 struct ast_channel *owner;
459 short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
460 struct ast_frame f; /*!< One frame for each channel. How did this ever work before? */
461 unsigned int needringing:1;
462 unsigned int needbusy:1;
463 unsigned int needcongestion:1;
464 unsigned int needcallerid:1;
465 unsigned int needanswer:1;
466 unsigned int needflash:1;
467 unsigned int needhold:1;
468 unsigned int needunhold:1;
469 unsigned int linear:1;
470 unsigned int inthreeway:1;
474 #define CONF_USER_REAL (1 << 0)
475 #define CONF_USER_THIRDCALL (1 << 1)
479 static struct zt_pvt {
481 struct ast_channel *owner; /*!< Our current active owner (if applicable) */
482 /*!< Up to three channels can be associated with this call */
484 struct zt_subchannel sub_unused; /*!< Just a safety precaution */
485 struct zt_subchannel subs[3]; /*!< Sub-channels */
486 struct zt_confinfo saveconf; /*!< Saved conference info */
488 struct zt_pvt *slaves[MAX_SLAVES]; /*!< Slave to us (follows our conferencing) */
489 struct zt_pvt *master; /*!< Master to us (we follow their conferencing) */
490 int inconference; /*!< If our real should be in the conference */
492 int sig; /*!< Signalling style */
493 int radio; /*!< radio type */
494 int outsigmod; /*!< Outbound Signalling style (modifier) */
495 int oprmode; /*!< "Operator Services" mode */
496 struct zt_pvt *oprpeer; /*!< "Operator Services" peer tech_pvt ptr */
497 float cid_rxgain; /*!< "Gain to apply during caller id */
500 int tonezone; /*!< tone zone for this chan, or -1 for default */
501 struct zt_pvt *next; /*!< Next channel in list */
502 struct zt_pvt *prev; /*!< Prev channel in list */
506 unsigned int answeronpolarityswitch:1;
507 unsigned int busydetect:1;
508 unsigned int callreturn:1;
509 unsigned int callwaiting:1;
510 unsigned int callwaitingcallerid:1;
511 unsigned int cancallforward:1;
512 unsigned int canpark:1;
513 unsigned int confirmanswer:1; /*!< Wait for '#' to confirm answer */
514 unsigned int destroy:1;
515 unsigned int didtdd:1; /*!< flag to say its done it once */
516 unsigned int dialednone:1;
517 unsigned int dialing:1;
518 unsigned int digital:1;
520 unsigned int echobreak:1;
521 unsigned int echocanbridged:1;
522 unsigned int echocanon:1;
523 unsigned int faxhandled:1; /*!< Has a fax tone already been handled? */
524 unsigned int firstradio:1;
525 unsigned int hanguponpolarityswitch:1;
526 unsigned int hardwaredtmf:1;
527 unsigned int hidecallerid:1;
528 unsigned int hidecalleridname:1; /*!< Hide just the name not the number for legacy PBX use */
529 unsigned int ignoredtmf:1;
530 unsigned int immediate:1; /*!< Answer before getting digits? */
531 unsigned int inalarm:1;
532 unsigned int mate:1; /*!< flag to say its in MATE mode */
533 unsigned int outgoing:1;
534 /* unsigned int overlapdial:1; unused and potentially confusing */
535 unsigned int permcallwaiting:1;
536 unsigned int permhidecallerid:1; /*!< Whether to hide our outgoing caller ID or not */
537 unsigned int priindication_oob:1;
538 unsigned int priexclusive:1;
539 unsigned int pulse:1;
540 unsigned int pulsedial:1; /*!< whether a pulse dial phone is detected */
541 unsigned int restrictcid:1; /*!< Whether restrict the callerid -> only send ANI */
542 unsigned int threewaycalling:1;
543 unsigned int transfer:1;
544 unsigned int use_callerid:1; /*!< Whether or not to use caller id on this channel */
545 unsigned int use_callingpres:1; /*!< Whether to use the callingpres the calling switch sends */
546 unsigned int usedistinctiveringdetection:1;
547 unsigned int zaptrcallerid:1; /*!< should we use the callerid from incoming call on zap transfer or not */
548 unsigned int transfertobusy:1; /*!< allow flash-transfers to busy channels */
549 /* Channel state or unavilability flags */
550 unsigned int inservice:1;
551 unsigned int locallyblocked:1;
552 unsigned int remotelyblocked:1;
553 #if defined(HAVE_PRI)
554 unsigned int alerting:1;
555 unsigned int alreadyhungup:1;
556 unsigned int isidlecall:1;
557 unsigned int proceeding:1;
558 unsigned int progress:1;
559 unsigned int resetting:1;
560 unsigned int setup_ack:1;
562 unsigned int use_smdi:1; /* Whether to use SMDI on this channel */
563 struct ast_smdi_interface *smdi_iface; /* The serial port to listen for SMDI data on */
565 struct zt_distRings drings;
567 char context[AST_MAX_CONTEXT];
568 char defcontext[AST_MAX_CONTEXT];
569 char exten[AST_MAX_EXTENSION];
570 char language[MAX_LANGUAGE];
571 char mohinterpret[MAX_MUSICCLASS];
572 char mohsuggest[MAX_MUSICCLASS];
574 char cid_ani[AST_MAX_EXTENSION];
576 char cid_num[AST_MAX_EXTENSION];
577 int cid_ton; /*!< Type Of Number (TON) */
578 char cid_name[AST_MAX_EXTENSION];
579 char lastcid_num[AST_MAX_EXTENSION];
580 char lastcid_name[AST_MAX_EXTENSION];
581 char *origcid_num; /*!< malloced original callerid */
582 char *origcid_name; /*!< malloced original callerid */
583 char callwait_num[AST_MAX_EXTENSION];
584 char callwait_name[AST_MAX_EXTENSION];
585 char rdnis[AST_MAX_EXTENSION];
586 char dnid[AST_MAX_EXTENSION];
589 int confno; /*!< Our conference */
590 int confusers; /*!< Who is using our conference */
591 int propconfno; /*!< Propagated conference number */
592 ast_group_t callgroup;
593 ast_group_t pickupgroup;
594 int channel; /*!< Channel Number or CRV */
595 int span; /*!< Span number */
596 time_t guardtime; /*!< Must wait this much time before using for new call */
597 int cid_signalling; /*!< CID signalling type bell202 or v23 */
598 int cid_start; /*!< CID start indicator, polarity or ring */
599 int callingpres; /*!< The value of callling presentation that we're going to use when placing a PRI call */
600 int callwaitingrepeat; /*!< How many samples to wait before repeating call waiting */
601 int cidcwexpire; /*!< When to expire our muting for CID/CW */
602 unsigned char *cidspill;
615 int busy_quietlength;
617 struct timeval flashtime; /*!< Last flash-hook time */
619 int cref; /*!< Call reference number */
620 ZT_DIAL_OPERATION dop;
621 int whichwink; /*!< SIG_FEATDMF_TA Which wink are we on? */
623 char accountcode[AST_MAX_ACCOUNT_CODE]; /*!< Account code */
624 int amaflags; /*!< AMA Flags */
625 struct tdd_state *tdd; /*!< TDD flag */
626 char call_forward[AST_MAX_EXTENSION];
627 char mailbox[AST_MAX_EXTENSION];
628 struct ast_event_sub *mwi_event_sub;
632 int distinctivering; /*!< Which distinctivering to use */
633 int cidrings; /*!< Which ring to deliver CID on */
634 int dtmfrelax; /*!< whether to run in relaxed DTMF mode */
636 int polarityonanswerdelay;
637 struct timeval polaritydelaytv;
638 int sendcalleridafter;
641 struct zt_pvt *bearer;
642 struct zt_pvt *realcall;
651 struct isup_call *ss7call;
653 int cic; /*!< CIC associated with channel */
654 unsigned int dpc; /*!< CIC's DPC */
657 } *iflist = NULL, *ifend = NULL;
659 /*! \brief Channel configuration from zapata.conf .
660 * This struct is used for parsing the [channels] section of zapata.conf.
661 * Generally there is a field here for every possible configuration item.
663 * The state of fields is saved along the parsing and whenever a 'channel'
664 * statement is reached, the current zt_chan_conf is used to configure the
665 * channel (struct zt_pvt)
667 * \see zt_chan_init for the default values.
669 struct zt_chan_conf {
680 char smdi_port[SMDI_MAX_FILENAME_LEN];
683 /** returns a new zt_chan_conf with default values (by-value) */
684 static struct zt_chan_conf zt_chan_conf_default(void) {
685 /* recall that if a field is not included here it is initialized
688 struct zt_chan_conf conf = {
692 .switchtype = PRI_SWITCH_NI2,
693 .dialplan = PRI_NATIONAL_ISDN + 1,
694 .localdialplan = PRI_NATIONAL_ISDN + 1,
700 .internationalprefix = "",
701 .nationalprefix = "",
706 .resetinterval = 3600
711 .called_nai = SS7_NAI_NATIONAL,
712 .calling_nai = SS7_NAI_NATIONAL,
713 .internationalprefix = "",
714 .nationalprefix = "",
715 .subscriberprefix = "",
720 .context = "default",
723 .mohinterpret = "default",
727 .cid_signalling = CID_SIG_BELL,
728 .cid_start = CID_START_RING,
747 .polarityonanswerdelay = 600,
749 .sendcalleridafter = DEFAULT_CIDRINGS
761 .smdi_port = "/dev/ttyS0",
768 static struct ast_channel *zt_request(const char *type, int format, void *data, int *cause);
769 static int zt_digit_begin(struct ast_channel *ast, char digit);
770 static int zt_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
771 static int zt_sendtext(struct ast_channel *c, const char *text);
772 static int zt_call(struct ast_channel *ast, char *rdest, int timeout);
773 static int zt_hangup(struct ast_channel *ast);
774 static int zt_answer(struct ast_channel *ast);
775 static struct ast_frame *zt_read(struct ast_channel *ast);
776 static int zt_write(struct ast_channel *ast, struct ast_frame *frame);
777 static struct ast_frame *zt_exception(struct ast_channel *ast);
778 static int zt_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
779 static int zt_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
780 static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen);
781 static int zt_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len);
783 static const struct ast_channel_tech zap_tech = {
785 .description = tdesc,
786 .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
787 .requester = zt_request,
788 .send_digit_begin = zt_digit_begin,
789 .send_digit_end = zt_digit_end,
790 .send_text = zt_sendtext,
797 .exception = zt_exception,
798 .indicate = zt_indicate,
800 .setoption = zt_setoption,
801 .func_channel_read = zt_func_read,
805 #define GET_CHANNEL(p) ((p)->bearer ? (p)->bearer->channel : p->channel)
807 #define GET_CHANNEL(p) ((p)->channel)
810 struct zt_pvt *round_robin[32];
813 static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri)
816 /* Grab the lock first */
818 res = ast_mutex_trylock(&pri->lock);
820 ast_mutex_unlock(&pvt->lock);
821 /* Release the lock and try again */
823 ast_mutex_lock(&pvt->lock);
826 /* Then break the poll */
827 pthread_kill(pri->master, SIGURG);
833 static inline void ss7_rel(struct zt_ss7 *ss7)
835 ast_mutex_unlock(&ss7->lock);
838 static inline int ss7_grab(struct zt_pvt *pvt, struct zt_ss7 *pri)
841 /* Grab the lock first */
843 res = ast_mutex_trylock(&pri->lock);
845 ast_mutex_unlock(&pvt->lock);
846 /* Release the lock and try again */
848 ast_mutex_lock(&pvt->lock);
851 /* Then break the poll */
852 pthread_kill(pri->master, SIGURG);
856 #define NUM_CADENCE_MAX 25
857 static int num_cadence = 4;
858 static int user_has_defined_cadences = 0;
860 static struct zt_ring_cadence cadences[NUM_CADENCE_MAX] = {
861 { { 125, 125, 2000, 4000 } }, /*!< Quick chirp followed by normal ring */
862 { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /*!< British style ring */
863 { { 125, 125, 125, 125, 125, 4000 } }, /*!< Three short bursts */
864 { { 1000, 500, 2500, 5000 } }, /*!< Long ring */
867 /*! \brief cidrings says in which pause to transmit the cid information, where the first pause
868 * is 1, the second pause is 2 and so on.
871 static int cidrings[NUM_CADENCE_MAX] = {
872 2, /*!< Right after first long ring */
873 4, /*!< Right after long part */
874 3, /*!< After third chirp */
875 2, /*!< Second spell */
878 #define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
879 (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
881 #define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
882 #define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
884 static int zt_get_index(struct ast_channel *ast, struct zt_pvt *p, int nullok)
887 if (p->subs[0].owner == ast)
889 else if (p->subs[1].owner == ast)
891 else if (p->subs[2].owner == ast)
896 ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n");
902 static void wakeup_sub(struct zt_pvt *p, int a, struct zt_pri *pri)
904 static void wakeup_sub(struct zt_pvt *p, int a, void *pri)
909 ast_mutex_unlock(&pri->lock);
912 if (p->subs[a].owner) {
913 if (ast_mutex_trylock(&p->subs[a].owner->lock)) {
914 ast_mutex_unlock(&p->lock);
916 ast_mutex_lock(&p->lock);
918 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
919 ast_mutex_unlock(&p->subs[a].owner->lock);
927 ast_mutex_lock(&pri->lock);
931 static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, void *data)
934 struct zt_pri *pri = (struct zt_pri*) data;
937 struct zt_ss7 *ss7 = (struct zt_ss7*) data;
939 /* We must unlock the PRI to avoid the possibility of a deadlock */
940 #if defined(HAVE_PRI) || defined(HAVE_SS7)
945 ast_mutex_unlock(&pri->lock);
950 ast_mutex_unlock(&ss7->lock);
960 if (ast_mutex_trylock(&p->owner->lock)) {
961 ast_mutex_unlock(&p->lock);
963 ast_mutex_lock(&p->lock);
965 ast_queue_frame(p->owner, f);
966 ast_mutex_unlock(&p->owner->lock);
972 #if defined(HAVE_PRI) || defined(HAVE_SS7)
977 ast_mutex_lock(&pri->lock);
982 ast_mutex_lock(&ss7->lock);
993 static int restore_gains(struct zt_pvt *p);
995 static void swap_subs(struct zt_pvt *p, int a, int b)
999 struct ast_channel *towner;
1001 ast_debug(1, "Swapping %d and %d\n", a, b);
1003 tchan = p->subs[a].chan;
1004 towner = p->subs[a].owner;
1005 tinthreeway = p->subs[a].inthreeway;
1007 p->subs[a].chan = p->subs[b].chan;
1008 p->subs[a].owner = p->subs[b].owner;
1009 p->subs[a].inthreeway = p->subs[b].inthreeway;
1011 p->subs[b].chan = tchan;
1012 p->subs[b].owner = towner;
1013 p->subs[b].inthreeway = tinthreeway;
1015 if (p->subs[a].owner)
1016 p->subs[a].owner->fds[0] = p->subs[a].zfd;
1017 if (p->subs[b].owner)
1018 p->subs[b].owner->fds[0] = p->subs[b].zfd;
1019 wakeup_sub(p, a, NULL);
1020 wakeup_sub(p, b, NULL);
1023 static int zt_open(char *fn)
1031 for (x = 0; x < strlen(fn); x++) {
1032 if (!isdigit(fn[x])) {
1040 ast_log(LOG_WARNING, "Invalid channel number '%s'\n", fn);
1043 fn = "/dev/zap/channel";
1045 fd = open(fn, O_RDWR | O_NONBLOCK);
1047 ast_log(LOG_WARNING, "Unable to open '%s': %s\n", fn, strerror(errno));
1051 if (ioctl(fd, ZT_SPECIFY, &chan)) {
1055 ast_log(LOG_WARNING, "Unable to specify channel %d: %s\n", chan, strerror(errno));
1060 if (ioctl(fd, ZT_SET_BLOCKSIZE, &bs) == -1) return -1;
1064 static void zt_close(int fd)
1070 static int zt_setlinear(int zfd, int linear)
1073 res = ioctl(zfd, ZT_SETLINEAR, &linear);
1080 static int alloc_sub(struct zt_pvt *p, int x)
1084 if (p->subs[x].zfd < 0) {
1085 p->subs[x].zfd = zt_open("/dev/zap/pseudo");
1086 if (p->subs[x].zfd > -1) {
1087 res = ioctl(p->subs[x].zfd, ZT_GET_BUFINFO, &bi);
1089 bi.txbufpolicy = ZT_POLICY_IMMEDIATE;
1090 bi.rxbufpolicy = ZT_POLICY_IMMEDIATE;
1091 bi.numbufs = numbufs;
1092 res = ioctl(p->subs[x].zfd, ZT_SET_BUFINFO, &bi);
1094 ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d\n", x);
1097 ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d\n", x);
1098 if (ioctl(p->subs[x].zfd, ZT_CHANNO, &p->subs[x].chan) == 1) {
1099 ast_log(LOG_WARNING, "Unable to get channel number for pseudo channel on FD %d\n", p->subs[x].zfd);
1100 zt_close(p->subs[x].zfd);
1101 p->subs[x].zfd = -1;
1104 ast_debug(1, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].zfd, p->subs[x].chan);
1107 ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
1110 ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
1114 static int unalloc_sub(struct zt_pvt *p, int x)
1117 ast_log(LOG_WARNING, "Trying to unalloc the real channel %d?!?\n", p->channel);
1120 ast_debug(1, "Released sub %d of channel %d\n", x, p->channel);
1121 if (p->subs[x].zfd > -1) {
1122 zt_close(p->subs[x].zfd);
1124 p->subs[x].zfd = -1;
1125 p->subs[x].linear = 0;
1126 p->subs[x].chan = 0;
1127 p->subs[x].owner = NULL;
1128 p->subs[x].inthreeway = 0;
1129 p->polarity = POLARITY_IDLE;
1130 memset(&p->subs[x].curconf, 0, sizeof(p->subs[x].curconf));
1134 static int digit_to_dtmfindex(char digit)
1137 return ZT_TONE_DTMF_BASE + (digit - '0');
1138 else if (digit >= 'A' && digit <= 'D')
1139 return ZT_TONE_DTMF_A + (digit - 'A');
1140 else if (digit >= 'a' && digit <= 'd')
1141 return ZT_TONE_DTMF_A + (digit - 'a');
1142 else if (digit == '*')
1143 return ZT_TONE_DTMF_s;
1144 else if (digit == '#')
1145 return ZT_TONE_DTMF_p;
1150 static int zt_digit_begin(struct ast_channel *chan, char digit)
1156 pvt = chan->tech_pvt;
1158 ast_mutex_lock(&pvt->lock);
1160 index = zt_get_index(chan, pvt, 0);
1162 if ((index != SUB_REAL) || !pvt->owner)
1166 if ((pvt->sig == SIG_PRI) && (chan->_state == AST_STATE_DIALING) && !pvt->proceeding) {
1167 if (pvt->setup_ack) {
1168 if (!pri_grab(pvt, pvt->pri)) {
1169 pri_information(pvt->pri->pri, pvt->call, digit);
1172 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", pvt->span);
1173 } else if (strlen(pvt->dialdest) < sizeof(pvt->dialdest) - 1) {
1175 ast_debug(1, "Queueing digit '%c' since setup_ack not yet received\n", digit);
1176 res = strlen(pvt->dialdest);
1177 pvt->dialdest[res++] = digit;
1178 pvt->dialdest[res] = '\0';
1183 if ((dtmf = digit_to_dtmfindex(digit)) == -1)
1186 if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].zfd, ZT_SENDTONE, &dtmf)) {
1188 ZT_DIAL_OPERATION zo = {
1189 .op = ZT_DIAL_OP_APPEND,
1192 zo.dialstr[0] = 'T';
1193 zo.dialstr[1] = digit;
1194 zo.dialstr[2] = '\0';
1195 if ((res = ioctl(pvt->subs[SUB_REAL].zfd, ZT_DIAL, &zo)))
1196 ast_log(LOG_WARNING, "Couldn't dial digit %c\n", digit);
1200 ast_debug(1, "Started VLDTMF digit '%c'\n", digit);
1202 pvt->begindigit = digit;
1206 ast_mutex_unlock(&pvt->lock);
1211 static int zt_digit_end(struct ast_channel *chan, char digit, unsigned int duration)
1218 pvt = chan->tech_pvt;
1220 ast_mutex_lock(&pvt->lock);
1222 index = zt_get_index(chan, pvt, 0);
1224 if ((index != SUB_REAL) || !pvt->owner || pvt->pulse)
1228 /* This means that the digit was already sent via PRI signalling */
1229 if (pvt->sig == SIG_PRI && !pvt->begindigit)
1233 if (pvt->begindigit) {
1235 ast_debug(1, "Ending VLDTMF digit '%c'\n", digit);
1236 res = ioctl(pvt->subs[SUB_REAL].zfd, ZT_SENDTONE, &x);
1238 pvt->begindigit = 0;
1242 ast_mutex_unlock(&pvt->lock);
1247 static char *events[] = {
1260 "Hook Transition Complete",
1265 "Polarity Reversal",
1273 { ZT_ALARM_RED, "Red Alarm" },
1274 { ZT_ALARM_YELLOW, "Yellow Alarm" },
1275 { ZT_ALARM_BLUE, "Blue Alarm" },
1276 { ZT_ALARM_RECOVER, "Recovering" },
1277 { ZT_ALARM_LOOPBACK, "Loopback" },
1278 { ZT_ALARM_NOTOPEN, "Not Open" },
1279 { ZT_ALARM_NONE, "None" },
1282 static char *alarm2str(int alarm)
1285 for (x = 0; x < sizeof(alarms) / sizeof(alarms[0]); x++) {
1286 if (alarms[x].alarm & alarm)
1287 return alarms[x].name;
1289 return alarm ? "Unknown Alarm" : "No Alarm";
1292 static char *event2str(int event)
1294 static char buf[256];
1295 if ((event < (sizeof(events) / sizeof(events[0]))) && (event > -1))
1296 return events[event];
1297 sprintf(buf, "Event %d", event); /* safe */
1302 static char *dialplan2str(int dialplan)
1304 if (dialplan == -1 || dialplan == -2) {
1305 return("Dynamically set dialplan in ISDN");
1307 return (pri_plan2str(dialplan));
1311 static char *zap_sig2str(int sig)
1313 static char buf[256];
1316 return "E & M Immediate";
1318 return "E & M Wink";
1322 return "Feature Group D (DTMF)";
1324 return "Feature Group D (MF)";
1325 case SIG_FEATDMF_TA:
1326 return "Feature Groud D (MF) Tandem Access";
1328 return "Feature Group B (MF)";
1332 return "FGC/CAMA (Dialpulse)";
1333 case SIG_FGC_CAMAMF:
1334 return "FGC/CAMA (MF)";
1336 return "FXS Loopstart";
1338 return "FXS Groundstart";
1340 return "FXS Kewlstart";
1342 return "FXO Loopstart";
1344 return "FXO Groundstart";
1346 return "FXO Kewlstart";
1348 return "PRI Signalling";
1350 return "SS7 Signalling";
1352 return "SF (Tone) Signalling Immediate";
1354 return "SF (Tone) Signalling Wink";
1356 return "SF (Tone) Signalling with Feature Group D (DTMF)";
1357 case SIG_SF_FEATDMF:
1358 return "SF (Tone) Signalling with Feature Group D (MF)";
1360 return "SF (Tone) Signalling with Feature Group B (MF)";
1361 case SIG_GR303FXOKS:
1362 return "GR-303 Signalling with FXOKS";
1363 case SIG_GR303FXSKS:
1364 return "GR-303 Signalling with FXSKS";
1366 return "Pseudo Signalling";
1368 snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
1373 #define sig2str zap_sig2str
1375 static int conf_add(struct zt_pvt *p, struct zt_subchannel *c, int index, int slavechannel)
1377 /* If the conference already exists, and we're already in it
1378 don't bother doing anything */
1381 memset(&zi, 0, sizeof(zi));
1384 if (slavechannel > 0) {
1385 /* If we have only one slave, do a digital mon */
1386 zi.confmode = ZT_CONF_DIGITALMON;
1387 zi.confno = slavechannel;
1390 /* Real-side and pseudo-side both participate in conference */
1391 zi.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER |
1392 ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
1394 zi.confmode = ZT_CONF_CONF | ZT_CONF_TALKER | ZT_CONF_LISTENER;
1395 zi.confno = p->confno;
1397 if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
1401 if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
1402 ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d\n", c->zfd, zi.confmode, zi.confno);
1405 if (slavechannel < 1) {
1406 p->confno = zi.confno;
1408 memcpy(&c->curconf, &zi, sizeof(c->curconf));
1409 ast_debug(1, "Added %d to conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1413 static int isourconf(struct zt_pvt *p, struct zt_subchannel *c)
1415 /* If they're listening to our channel, they're ours */
1416 if ((p->channel == c->curconf.confno) && (c->curconf.confmode == ZT_CONF_DIGITALMON))
1418 /* If they're a talker on our (allocated) conference, they're ours */
1419 if ((p->confno > 0) && (p->confno == c->curconf.confno) && (c->curconf.confmode & ZT_CONF_TALKER))
1424 static int conf_del(struct zt_pvt *p, struct zt_subchannel *c, int index)
1427 if (/* Can't delete if there's no zfd */
1429 /* Don't delete from the conference if it's not our conference */
1431 /* Don't delete if we don't think it's conferenced at all (implied) */
1433 memset(&zi, 0, sizeof(zi));
1437 if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
1438 ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1441 ast_debug(1, "Removed %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
1442 memcpy(&c->curconf, &zi, sizeof(c->curconf));
1446 static int isslavenative(struct zt_pvt *p, struct zt_pvt **out)
1450 struct zt_pvt *slave = NULL;
1451 /* Start out optimistic */
1453 /* Update conference state in a stateless fashion */
1454 for (x = 0; x < 3; x++) {
1455 /* Any three-way calling makes slave native mode *definitely* out
1457 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway)
1460 /* If we don't have any 3-way calls, check to see if we have
1461 precisely one slave */
1462 if (useslavenative) {
1463 for (x = 0; x < MAX_SLAVES; x++) {
1466 /* Whoops already have a slave! No
1467 slave native and stop right away */
1472 /* We have one slave so far */
1473 slave = p->slaves[x];
1478 /* If no slave, slave native definitely out */
1481 else if (slave->law != p->law) {
1487 return useslavenative;
1490 static int reset_conf(struct zt_pvt *p)
1493 memset(&zi, 0, sizeof(zi));
1495 memset(&p->subs[SUB_REAL].curconf, 0, sizeof(p->subs[SUB_REAL].curconf));
1496 if (p->subs[SUB_REAL].zfd > -1) {
1497 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &zi))
1498 ast_log(LOG_WARNING, "Failed to reset conferencing on channel %d!\n", p->channel);
1503 static int update_conf(struct zt_pvt *p)
1508 struct zt_pvt *slave = NULL;
1510 useslavenative = isslavenative(p, &slave);
1511 /* Start with the obvious, general stuff */
1512 for (x = 0; x < 3; x++) {
1513 /* Look for three way calls */
1514 if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway) {
1515 conf_add(p, &p->subs[x], x, 0);
1518 conf_del(p, &p->subs[x], x);
1521 /* If we have a slave, add him to our conference now. or DAX
1522 if this is slave native */
1523 for (x = 0; x < MAX_SLAVES; x++) {
1526 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
1528 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
1533 /* If we're supposed to be in there, do so now */
1534 if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
1536 conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
1538 conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
1542 /* If we have a master, add ourselves to his conference */
1544 if (isslavenative(p->master, NULL)) {
1545 conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
1547 conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
1551 /* Nobody is left (or should be left) in our conference.
1555 ast_debug(1, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
1559 static void zt_enable_ec(struct zt_pvt *p)
1566 ast_debug(1, "Echo cancellation already on\n");
1570 ast_debug(1, "Echo cancellation isn't required on digital connection\n");
1573 if (p->echocancel) {
1574 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
1576 res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x);
1578 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1581 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1583 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
1586 ast_debug(1, "Enabled echo cancellation on channel %d\n", p->channel);
1589 ast_debug(1, "No echo cancellation requested\n");
1592 static void zt_train_ec(struct zt_pvt *p)
1596 if (p && p->echocancel && p->echotraining) {
1597 x = p->echotraining;
1598 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOTRAIN, &x);
1600 ast_log(LOG_WARNING, "Unable to request echo training on channel %d\n", p->channel);
1602 ast_debug(1, "Engaged echo training on channel %d\n", p->channel);
1604 ast_debug(1, "No echo training requested\n");
1607 static void zt_disable_ec(struct zt_pvt *p)
1611 if (p->echocancel) {
1613 res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
1615 ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d\n", p->channel);
1617 ast_debug(1, "disabled echo cancellation on channel %d\n", p->channel);
1622 static void fill_txgain(struct zt_gains *g, float gain, int law)
1626 float linear_gain = pow(10.0, gain / 20.0);
1630 for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
1632 k = (int) (((float) AST_ALAW(j)) * linear_gain);
1633 if (k > 32767) k = 32767;
1634 if (k < -32767) k = -32767;
1635 g->txgain[j] = AST_LIN2A(k);
1642 for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
1644 k = (int) (((float) AST_MULAW(j)) * linear_gain);
1645 if (k > 32767) k = 32767;
1646 if (k < -32767) k = -32767;
1647 g->txgain[j] = AST_LIN2MU(k);
1656 static void fill_rxgain(struct zt_gains *g, float gain, int law)
1660 float linear_gain = pow(10.0, gain / 20.0);
1664 for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
1666 k = (int) (((float) AST_ALAW(j)) * linear_gain);
1667 if (k > 32767) k = 32767;
1668 if (k < -32767) k = -32767;
1669 g->rxgain[j] = AST_LIN2A(k);
1676 for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
1678 k = (int) (((float) AST_MULAW(j)) * linear_gain);
1679 if (k > 32767) k = 32767;
1680 if (k < -32767) k = -32767;
1681 g->rxgain[j] = AST_LIN2MU(k);
1690 static int set_actual_txgain(int fd, int chan, float gain, int law)
1695 memset(&g, 0, sizeof(g));
1697 res = ioctl(fd, ZT_GETGAINS, &g);
1699 ast_debug(1, "Failed to read gains: %s\n", strerror(errno));
1703 fill_txgain(&g, gain, law);
1705 return ioctl(fd, ZT_SETGAINS, &g);
1708 static int set_actual_rxgain(int fd, int chan, float gain, int law)
1713 memset(&g, 0, sizeof(g));
1715 res = ioctl(fd, ZT_GETGAINS, &g);
1717 ast_debug(1, "Failed to read gains: %s\n", strerror(errno));
1721 fill_rxgain(&g, gain, law);
1723 return ioctl(fd, ZT_SETGAINS, &g);
1726 static int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
1728 return set_actual_txgain(fd, chan, txgain, law) | set_actual_rxgain(fd, chan, rxgain, law);
1731 static int bump_gains(struct zt_pvt *p)
1735 /* Bump receive gain by value stored in cid_rxgain */
1736 res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain + p->cid_rxgain, p->txgain, p->law);
1738 ast_log(LOG_WARNING, "Unable to bump gain: %s\n", strerror(errno));
1745 static int restore_gains(struct zt_pvt *p)
1749 res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
1751 ast_log(LOG_WARNING, "Unable to restore gains: %s\n", strerror(errno));
1758 static inline int zt_set_hook(int fd, int hs)
1762 res = ioctl(fd, ZT_HOOK, &x);
1765 if (errno == EINPROGRESS) return 0;
1766 ast_log(LOG_WARNING, "zt hook failed: %s\n", strerror(errno));
1771 static inline int zt_confmute(struct zt_pvt *p, int muted)
1775 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
1777 res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &y);
1779 ast_log(LOG_WARNING, "Unable to set audio mode on '%d'\n", p->channel);
1781 res = ioctl(p->subs[SUB_REAL].zfd, ZT_CONFMUTE, &x);
1783 ast_log(LOG_WARNING, "zt confmute(%d) failed on channel %d: %s\n", muted, p->channel, strerror(errno));
1787 static int save_conference(struct zt_pvt *p)
1789 struct zt_confinfo c;
1791 if (p->saveconf.confmode) {
1792 ast_log(LOG_WARNING, "Can't save conference -- already in use\n");
1795 p->saveconf.chan = 0;
1796 res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &p->saveconf);
1798 ast_log(LOG_WARNING, "Unable to get conference info: %s\n", strerror(errno));
1799 p->saveconf.confmode = 0;
1804 c.confmode = ZT_CONF_NORMAL;
1805 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &c);
1807 ast_log(LOG_WARNING, "Unable to set conference info: %s\n", strerror(errno));
1810 ast_debug(1, "Disabled conferencing\n");
1814 static int restore_conference(struct zt_pvt *p)
1817 if (p->saveconf.confmode) {
1818 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &p->saveconf);
1819 p->saveconf.confmode = 0;
1821 ast_log(LOG_WARNING, "Unable to restore conference info: %s\n", strerror(errno));
1825 ast_debug(1, "Restored conferencing\n");
1829 static int send_callerid(struct zt_pvt *p);
1831 static int send_cwcidspill(struct zt_pvt *p)
1835 if (!(p->cidspill = ast_malloc(MAX_CALLERID_SIZE)))
1837 p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, p->callwait_name, p->callwait_num, AST_LAW(p));
1838 /* Make sure we account for the end */
1839 p->cidlen += READ_SIZE * 4;
1842 if (option_verbose > 2)
1843 ast_verbose(VERBOSE_PREFIX_3 "CPE supports Call Waiting Caller*ID. Sending '%s/%s'\n", p->callwait_name, p->callwait_num);
1847 static int has_voicemail(struct zt_pvt *p)
1850 struct ast_event *event;
1852 event = ast_event_get_cached(AST_EVENT_MWI,
1853 AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, p->mailbox,
1854 AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_EXISTS,
1858 new_msgs = ast_event_get_ie_uint(event, AST_EVENT_IE_NEWMSGS);
1859 ast_event_destroy(event);
1861 new_msgs = ast_app_has_voicemail(p->mailbox, NULL);
1866 static int send_callerid(struct zt_pvt *p)
1868 /* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */
1870 /* Take out of linear mode if necessary */
1871 if (p->subs[SUB_REAL].linear) {
1872 p->subs[SUB_REAL].linear = 0;
1873 zt_setlinear(p->subs[SUB_REAL].zfd, 0);
1875 while (p->cidpos < p->cidlen) {
1876 res = write(p->subs[SUB_REAL].zfd, p->cidspill + p->cidpos, p->cidlen - p->cidpos);
1878 if (errno == EAGAIN)
1881 ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
1889 ast_free(p->cidspill);
1891 if (p->callwaitcas) {
1892 /* Wait for CID/CW to expire */
1893 p->cidcwexpire = CIDCW_EXPIRE_SAMPLES;
1895 restore_conference(p);
1899 static int zt_callwait(struct ast_channel *ast)
1901 struct zt_pvt *p = ast->tech_pvt;
1902 p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1904 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1905 ast_free(p->cidspill);
1907 if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1911 memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1912 if (!p->callwaitrings && p->callwaitingcallerid) {
1913 ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
1915 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1917 ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
1919 p->cidlen = 2400 + READ_SIZE * 4;
1928 static unsigned char cid_pres2ss7pres(int cid_pres)
1930 return (cid_pres >> 5) & 0x03;
1933 static unsigned char cid_pres2ss7screen(int cid_pres)
1935 return cid_pres & 0x03;
1939 static int zt_call(struct ast_channel *ast, char *rdest, int timeout)
1941 struct zt_pvt *p = ast->tech_pvt;
1942 int x, res, index,mysig;
1947 char dest[256]; /* must be same length as p->dialdest */
1948 ast_mutex_lock(&p->lock);
1949 ast_copy_string(dest, rdest, sizeof(dest));
1950 ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));
1951 if ((ast->_state == AST_STATE_BUSY)) {
1952 p->subs[SUB_REAL].needbusy = 1;
1953 ast_mutex_unlock(&p->lock);
1956 if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
1957 ast_log(LOG_WARNING, "zt_call called on %s, neither down nor reserved\n", ast->name);
1958 ast_mutex_unlock(&p->lock);
1962 if ((p->radio || (p->oprmode < 0))) /* if a radio channel, up immediately */
1964 /* Special pseudo -- automatically up */
1965 ast_setstate(ast, AST_STATE_UP);
1966 ast_mutex_unlock(&p->lock);
1969 x = ZT_FLUSH_READ | ZT_FLUSH_WRITE;
1970 res = ioctl(p->subs[SUB_REAL].zfd, ZT_FLUSH, &x);
1972 ast_log(LOG_WARNING, "Unable to flush input on channel %d\n", p->channel);
1975 set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
1978 if (p->outsigmod > -1)
1979 mysig = p->outsigmod;
1985 if (p->owner == ast) {
1986 /* Normal ring, on hook */
1988 /* Don't send audio while on hook, until the call is answered */
1990 if (p->use_callerid) {
1991 /* Generate the Caller-ID spill if desired */
1993 ast_log(LOG_WARNING, "cidspill already exists??\n");
1994 ast_free(p->cidspill);
1997 if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1998 p->cidlen = ast_callerid_generate(p->cidspill, ast->cid.cid_name, ast->cid.cid_num, AST_LAW(p));
2003 /* Choose proper cadence */
2004 if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
2005 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, &cadences[p->distinctivering - 1]))
2006 ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s'\n", p->distinctivering, ast->name);
2007 p->cidrings = cidrings[p->distinctivering - 1];
2009 if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, NULL))
2010 ast_log(LOG_WARNING, "Unable to reset default ring on '%s'\n", ast->name);
2011 p->cidrings = p->sendcalleridafter;
2014 /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */
2015 c = strchr(dest, '/');
2018 if (c && (strlen(c) < p->stripmsd)) {
2019 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
2023 p->dop.op = ZT_DIAL_OP_REPLACE;
2024 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c);
2025 ast_debug(1, "FXO: setup deferred dialstring: %s\n", c);
2027 p->dop.dialstr[0] = '\0';
2030 if (ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x) && (errno != EINPROGRESS)) {
2031 ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
2032 ast_mutex_unlock(&p->lock);
2037 /* Call waiting call */
2038 p->callwaitrings = 0;
2039 if (ast->cid.cid_num)
2040 ast_copy_string(p->callwait_num, ast->cid.cid_num, sizeof(p->callwait_num));
2042 p->callwait_num[0] = '\0';
2043 if (ast->cid.cid_name)
2044 ast_copy_string(p->callwait_name, ast->cid.cid_name, sizeof(p->callwait_name));
2046 p->callwait_name[0] = '\0';
2047 /* Call waiting tone instead */
2048 if (zt_callwait(ast)) {
2049 ast_mutex_unlock(&p->lock);
2052 /* Make ring-back */
2053 if (tone_zone_play_tone(p->subs[SUB_CALLWAIT].zfd, ZT_TONE_RINGTONE))
2054 ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast->name);
2057 n = ast->cid.cid_name;
2058 l = ast->cid.cid_num;
2060 ast_copy_string(p->lastcid_num, l, sizeof(p->lastcid_num));
2062 p->lastcid_num[0] = '\0';
2064 ast_copy_string(p->lastcid_name, n, sizeof(p->lastcid_name));
2066 p->lastcid_name[0] = '\0';
2067 ast_setstate(ast, AST_STATE_RINGING);
2068 index = zt_get_index(ast, p, 0);
2070 p->subs[index].needringing = 1;
2083 case SIG_FGC_CAMAMF:
2088 case SIG_SF_FEATDMF:
2089 case SIG_FEATDMF_TA:
2091 c = strchr(dest, '/');
2096 if (strlen(c) < p->stripmsd) {
2097 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
2098 ast_mutex_unlock(&p->lock);
2102 /* Start the trunk, if not GR-303 */
2106 res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2108 if (errno != EINPROGRESS) {
2109 ast_log(LOG_WARNING, "Unable to start channel: %s\n", strerror(errno));
2110 ast_mutex_unlock(&p->lock);
2117 ast_debug(1, "Dialing '%s'\n", c);
2118 p->dop.op = ZT_DIAL_OP_REPLACE;
2124 l = ast->cid.cid_num;
2126 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c);
2128 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c);
2131 l = ast->cid.cid_num;
2133 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c);
2135 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c);
2137 case SIG_FEATDMF_TA:
2139 const char *cic, *ozz;
2141 /* If you have to go through a Tandem Access point you need to use this */
2142 ozz = pbx_builtin_getvar_helper(p->owner, "FEATDMF_OZZ");
2145 cic = pbx_builtin_getvar_helper(p->owner, "FEATDMF_CIC");
2149 ast_log(LOG_WARNING, "Unable to dial channel of type feature group D MF tandem access without CIC or OZZ set\n");
2150 ast_mutex_unlock(&p->lock);
2153 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s%s#", ozz, cic);
2154 snprintf(p->finaldial, sizeof(p->finaldial), "M*%s#", c);
2159 ast_copy_string(p->dop.dialstr, "M*911#", sizeof(p->dop.dialstr));
2162 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%s", c);
2164 case SIG_FGC_CAMAMF:
2166 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c);
2170 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%sw", c);
2172 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c);
2176 if (p->echotraining && (strlen(p->dop.dialstr) > 4)) {
2177 memset(p->echorest, 'w', sizeof(p->echorest) - 1);
2178 strcpy(p->echorest + (p->echotraining / 400) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
2179 p->echorest[sizeof(p->echorest) - 1] = '\0';
2181 p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
2185 if (ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop)) {
2187 ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
2188 ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
2189 ast_mutex_unlock(&p->lock);
2193 ast_debug(1, "Deferring dialing...\n");
2196 if (ast_strlen_zero(c))
2198 ast_setstate(ast, AST_STATE_DIALING);
2201 /* Special pseudo -- automatically up*/
2202 ast_setstate(ast, AST_STATE_UP);
2206 /* We'll get it in a moment -- but use dialdest to store pre-setup_ack digits */
2207 p->dialdest[0] = '\0';
2210 ast_debug(1, "not yet implemented\n");
2211 ast_mutex_unlock(&p->lock);
2216 char ss7_called_nai;
2217 int called_nai_strip;
2218 char ss7_calling_nai;
2219 int calling_nai_strip;
2221 c = strchr(dest, '/');
2227 if (!p->hidecallerid) {
2228 l = ast->cid.cid_num;
2233 if (ss7_grab(p, p->ss7)) {
2234 ast_log(LOG_WARNING, "Failed to grab SS7!\n");
2235 ast_mutex_unlock(&p->lock);
2238 p->digital = IS_DIGITAL(ast->transfercapability);
2239 p->ss7call = isup_new_call(p->ss7->ss7);
2243 ast_mutex_unlock(&p->lock);
2244 ast_log(LOG_ERROR, "Unable to allocate new SS7 call!\n");
2248 called_nai_strip = 0;
2249 ss7_called_nai = p->ss7->called_nai;
2250 if (ss7_called_nai == SS7_NAI_DYNAMIC) { /* compute dynamically */
2251 if (strncmp(c + p->stripmsd, p->ss7->internationalprefix, strlen(p->ss7->internationalprefix)) == 0) {
2252 called_nai_strip = strlen(p->ss7->internationalprefix);
2253 ss7_called_nai = SS7_NAI_INTERNATIONAL;
2254 } else if (strncmp(c + p->stripmsd, p->ss7->nationalprefix, strlen(p->ss7->nationalprefix)) == 0) {
2255 called_nai_strip = strlen(p->ss7->nationalprefix);
2256 ss7_called_nai = SS7_NAI_NATIONAL;
2258 ss7_called_nai = SS7_NAI_SUBSCRIBER;
2261 isup_set_called(p->ss7call, c + p->stripmsd + called_nai_strip, ss7_called_nai, p->ss7->ss7);
2263 calling_nai_strip = 0;
2264 ss7_calling_nai = p->ss7->calling_nai;
2265 if ((l != NULL) && (ss7_calling_nai == SS7_NAI_DYNAMIC)) { /* compute dynamically */
2266 if (strncmp(l, p->ss7->internationalprefix, strlen(p->ss7->internationalprefix)) == 0) {
2267 calling_nai_strip = strlen(p->ss7->internationalprefix);
2268 ss7_calling_nai = SS7_NAI_INTERNATIONAL;
2269 } else if (strncmp(l, p->ss7->nationalprefix, strlen(p->ss7->nationalprefix)) == 0) {
2270 calling_nai_strip = strlen(p->ss7->nationalprefix);
2271 ss7_calling_nai = SS7_NAI_NATIONAL;
2273 ss7_calling_nai = SS7_NAI_SUBSCRIBER;
2276 isup_set_calling(p->ss7call, l ? (l + calling_nai_strip) : NULL, ss7_calling_nai,
2277 p->use_callingpres ? cid_pres2ss7pres(ast->cid.cid_pres) : (l ? SS7_PRESENTATION_ALLOWED : SS7_PRESENTATION_RESTRICTED),
2278 p->use_callingpres ? cid_pres2ss7screen(ast->cid.cid_pres) : SS7_SCREENING_USER_PROVIDED );
2280 isup_init_call(p->ss7->ss7, p->ss7call, p->cic, p->dpc);
2282 isup_iam(p->ss7->ss7, p->ss7call);
2283 ast_setstate(ast, AST_STATE_DIALING);
2286 #endif /* HAVE_SS7 */
2290 #ifdef SUPPORT_USERUSER
2291 const char *useruser;
2295 int prilocaldialplan;
2299 int redirect_reason;
2301 c = strchr(dest, '/');
2306 if (!p->hidecalleridname)
2307 n = ast->cid.cid_name;
2310 if (!p->hidecallerid) {
2311 l = ast->cid.cid_num;
2312 n = ast->cid.cid_name;
2317 if (strlen(c) < p->stripmsd) {
2318 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
2319 ast_mutex_unlock(&p->lock);
2322 if (mysig != SIG_FXSKS) {
2323 p->dop.op = ZT_DIAL_OP_REPLACE;
2324 s = strchr(c + p->stripmsd, 'w');
2327 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%s", s);
2329 p->dop.dialstr[0] = '\0';
2332 p->dop.dialstr[0] = '\0';
2335 if (pri_grab(p, p->pri)) {
2336 ast_log(LOG_WARNING, "Failed to grab PRI!\n");
2337 ast_mutex_unlock(&p->lock);
2340 if (!(p->call = pri_new_call(p->pri->pri))) {
2341 ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel);
2343 ast_mutex_unlock(&p->lock);
2346 if (!(sr = pri_sr_new())) {
2347 ast_log(LOG_WARNING, "Failed to allocate setup request channel %d\n", p->channel);
2349 ast_mutex_unlock(&p->lock);
2351 if (p->bearer || (mysig == SIG_FXSKS)) {
2353 ast_debug(1, "Oooh, I have a bearer on %d (%d:%d)\n", PVT_TO_CHANNEL(p->bearer), p->bearer->logicalspan, p->bearer->channel);
2354 p->bearer->call = p->call;
2356 ast_debug(1, "I'm being setup with no bearer right now...\n");
2358 pri_set_crv(p->pri->pri, p->call, p->channel, 0);
2360 p->digital = IS_DIGITAL(ast->transfercapability);
2361 /* Add support for exclusive override */
2362 if (p->priexclusive)
2365 /* otherwise, traditional behavior */
2366 if (p->pri->nodetype == PRI_NETWORK)
2372 pri_sr_set_channel(sr, p->bearer ? PVT_TO_CHANNEL(p->bearer) : PVT_TO_CHANNEL(p), exclusive, 1);
2373 pri_sr_set_bearer(sr, p->digital ? PRI_TRANS_CAP_DIGITAL : ast->transfercapability,
2375 ((p->law == ZT_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW)));
2376 if (p->pri->facilityenable)
2377 pri_facility_enable(p->pri->pri);
2379 if (option_verbose > 2)
2380 ast_verbose(VERBOSE_PREFIX_3 "Requested transfer capability: 0x%.2x - %s\n", ast->transfercapability, ast_transfercapability2str(ast->transfercapability));
2382 pridialplan = p->pri->dialplan - 1;
2383 if (pridialplan == -2 || pridialplan == -3) { /* compute dynamically */
2384 if (strncmp(c + p->stripmsd, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
2385 if (pridialplan == -2) {
2386 dp_strip = strlen(p->pri->internationalprefix);
2388 pridialplan = PRI_INTERNATIONAL_ISDN;
2389 } else if (strncmp(c + p->stripmsd, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
2390 if (pridialplan == -2) {
2391 dp_strip = strlen(p->pri->nationalprefix);
2393 pridialplan = PRI_NATIONAL_ISDN;
2395 pridialplan = PRI_LOCAL_ISDN;
2398 pri_sr_set_called(sr, c + p->stripmsd + dp_strip, pridialplan, s ? 1 : 0);
2401 prilocaldialplan = p->pri->localdialplan - 1;
2402 if ((l != NULL) && (prilocaldialplan == -2 || prilocaldialplan == -3)) { /* compute dynamically */
2403 if (strncmp(l, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
2404 if (prilocaldialplan == -2) {
2405 ldp_strip = strlen(p->pri->internationalprefix);
2407 prilocaldialplan = PRI_INTERNATIONAL_ISDN;
2408 } else if (strncmp(l, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
2409 if (prilocaldialplan == -2) {
2410 ldp_strip = strlen(p->pri->nationalprefix);
2412 prilocaldialplan = PRI_NATIONAL_ISDN;
2414 prilocaldialplan = PRI_LOCAL_ISDN;
2417 pri_sr_set_caller(sr, l ? (l + ldp_strip) : NULL, n, prilocaldialplan,
2418 p->use_callingpres ? ast->cid.cid_pres : (l ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_NUMBER_NOT_AVAILABLE));
2419 if ((rr_str = pbx_builtin_getvar_helper(ast, "PRIREDIRECTREASON"))) {
2420 if (!strcasecmp(rr_str, "UNKNOWN"))
2421 redirect_reason = 0;
2422 else if (!strcasecmp(rr_str, "BUSY"))
2423 redirect_reason = 1;
2424 else if (!strcasecmp(rr_str, "NO_REPLY"))
2425 redirect_reason = 2;
2426 else if (!strcasecmp(rr_str, "UNCONDITIONAL"))
2427 redirect_reason = 15;
2429 redirect_reason = PRI_REDIR_UNCONDITIONAL;
2431 redirect_reason = PRI_REDIR_UNCONDITIONAL;
2432 pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, redirect_reason);
2434 #ifdef SUPPORT_USERUSER
2435 /* User-user info */
2436 useruser = pbx_builtin_getvar_helper(p->owner, "USERUSERINFO");
2439 pri_sr_set_useruser(sr, useruser);
2442 if (pri_setup(p->pri->pri, p->call, sr)) {
2443 ast_log(LOG_WARNING, "Unable to setup call to %s (using %s)\n",
2444 c + p->stripmsd + dp_strip, dialplan2str(p->pri->dialplan));
2446 ast_mutex_unlock(&p->lock);
2451 ast_setstate(ast, AST_STATE_DIALING);
2455 ast_mutex_unlock(&p->lock);
2459 static void destroy_zt_pvt(struct zt_pvt **pvt)
2461 struct zt_pvt *p = *pvt;
2462 /* Remove channel from the list */
2464 p->prev->next = p->next;
2466 p->next->prev = p->prev;
2468 ASTOBJ_UNREF(p->smdi_iface, ast_smdi_interface_destroy);
2469 if (p->mwi_event_sub)
2470 ast_event_unsubscribe(p->mwi_event_sub);
2471 ast_mutex_destroy(&p->lock);
2476 static int destroy_channel(struct zt_pvt *prev, struct zt_pvt *cur, int now)
2486 for (i = 0; i < 3; i++) {
2487 if (cur->subs[i].owner) {
2493 prev->next = cur->next;
2495 prev->next->prev = prev;
2501 iflist->prev = NULL;
2505 if (cur->subs[SUB_REAL].zfd > -1) {
2506 zt_close(cur->subs[SUB_REAL].zfd);
2508 destroy_zt_pvt(&cur);
2512 prev->next = cur->next;
2514 prev->next->prev = prev;
2520 iflist->prev = NULL;
2524 if (cur->subs[SUB_REAL].zfd > -1) {
2525 zt_close(cur->subs[SUB_REAL].zfd);
2527 destroy_zt_pvt(&cur);
2533 static char *zap_send_keypad_facility_app = "ZapSendKeypadFacility";
2535 static char *zap_send_keypad_facility_synopsis = "Send digits out of band over a PRI";
2537 static char *zap_send_keypad_facility_descrip =
2538 " ZapSendKeypadFacility(): This application will send the given string of digits in a Keypad Facility\n"
2539 " IE over the current channel.\n";
2541 static int zap_send_keypad_facility_exec(struct ast_channel *chan, void *data)
2543 /* Data will be our digit string */
2545 char *digits = (char *) data;
2547 if (ast_strlen_zero(digits)) {
2548 ast_debug(1, "No digit string sent to application!\n");
2552 p = (struct zt_pvt *)chan->tech_pvt;
2555 ast_debug(1, "Unable to find technology private\n");
2559 ast_mutex_lock(&p->lock);
2561 if (!p->pri || !p->call) {
2562 ast_debug(1, "Unable to find pri or call on channel!\n");
2563 ast_mutex_unlock(&p->lock);
2567 if (!pri_grab(p, p->pri)) {
2568 pri_keypad_facility(p->pri->pri, p->call, digits);
2571 ast_debug(1, "Unable to grab pri to send keypad facility!\n");
2572 ast_mutex_unlock(&p->lock);
2576 ast_mutex_unlock(&p->lock);
2581 static int pri_is_up(struct zt_pri *pri)
2584 for (x = 0; x < NUM_DCHANS; x++) {
2585 if (pri->dchanavail[x] == DCHAN_AVAILABLE)
2591 static int pri_assign_bearer(struct zt_pvt *crv, struct zt_pri *pri, struct zt_pvt *bearer)
2593 bearer->owner = &inuse;
2594 bearer->realcall = crv;
2595 crv->subs[SUB_REAL].zfd = bearer->subs[SUB_REAL].zfd;
2596 if (crv->subs[SUB_REAL].owner)
2597 crv->subs[SUB_REAL].owner->fds[0] = crv->subs[SUB_REAL].zfd;
2598 crv->bearer = bearer;
2599 crv->call = bearer->call;
2604 static char *pri_order(int level)
2614 return "Quaternary";
2620 /* Returns fd of the active dchan */
2621 static int pri_active_dchan_fd(struct zt_pri *pri)
2625 for (x = 0; x < NUM_DCHANS; x++) {
2626 if ((pri->dchans[x] == pri->pri))
2633 static int pri_find_dchan(struct zt_pri *pri)
2640 for (x = 0; x < NUM_DCHANS; x++) {
2641 if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
2643 if (pri->dchans[x] == old) {
2649 ast_log(LOG_WARNING, "No D-channels available! Using Primary channel %d as D-channel anyway!\n",
2650 pri->dchannels[newslot]);
2652 if (old && (oldslot != newslot))
2653 ast_log(LOG_NOTICE, "Switching from from d-channel %d to channel %d!\n",
2654 pri->dchannels[oldslot], pri->dchannels[newslot]);
2655 pri->pri = pri->dchans[newslot];
2660 static int zt_hangup(struct ast_channel *ast)
2664 /*static int restore_gains(struct zt_pvt *p);*/
2665 struct zt_pvt *p = ast->tech_pvt;
2666 struct zt_pvt *tmp = NULL;
2667 struct zt_pvt *prev = NULL;
2670 ast_debug(1, "zt_hangup(%s)\n", ast->name);
2671 if (!ast->tech_pvt) {
2672 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
2676 ast_mutex_lock(&p->lock);
2678 index = zt_get_index(ast, p, 1);
2680 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
2682 ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
2688 if (p->origcid_num) {
2689 ast_copy_string(p->cid_num, p->origcid_num, sizeof(p->cid_num));
2690 ast_free(p->origcid_num);
2691 p->origcid_num = NULL;
2693 if (p->origcid_name) {
2694 ast_copy_string(p->cid_name, p->origcid_name, sizeof(p->cid_name));
2695 ast_free(p->origcid_name);
2696 p->origcid_name = NULL;
2699 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);
2703 ast_debug(1, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
2704 p->channel, index, p->subs[SUB_REAL].zfd, p->subs[SUB_CALLWAIT].zfd, p->subs[SUB_THREEWAY].zfd);
2708 /* Real channel, do some fixup */
2709 p->subs[index].owner = NULL;
2710 p->subs[index].needanswer = 0;
2711 p->subs[index].needflash = 0;
2712 p->subs[index].needringing = 0;
2713 p->subs[index].needbusy = 0;
2714 p->subs[index].needcongestion = 0;
2715 p->subs[index].linear = 0;
2716 p->subs[index].needcallerid = 0;
2717 p->polarity = POLARITY_IDLE;
2718 zt_setlinear(p->subs[index].zfd, 0);
2719 if (index == SUB_REAL) {
2720 if ((p->subs[SUB_CALLWAIT].zfd > -1) && (p->subs[SUB_THREEWAY].zfd > -1)) {
2721 ast_debug(1, "Normal call hung up with both three way call and a call waiting call in place?\n");
2722 if (p->subs[SUB_CALLWAIT].inthreeway) {
2723 /* We had flipped over to answer a callwait and now it's gone */
2724 ast_debug(1, "We were flipped over to the callwait, moving back and unowning.\n");
2725 /* Move to the call-wait, but un-own us until they flip back. */
2726 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
2727 unalloc_sub(p, SUB_CALLWAIT);
2730 /* The three way hung up, but we still have a call wait */
2731 ast_debug(1, "We were in the threeway and have a callwait still. Ditching the threeway.\n");
2732 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2733 unalloc_sub(p, SUB_THREEWAY);
2734 if (p->subs[SUB_REAL].inthreeway) {
2735 /* This was part of a three way call. Immediately make way for
2737 ast_debug(1, "Call was complete, setting owner to former third call\n");
2738 p->owner = p->subs[SUB_REAL].owner;
2740 /* This call hasn't been completed yet... Set owner to NULL */
2741 ast_debug(1, "Call was incomplete, setting owner to NULL\n");
2744 p->subs[SUB_REAL].inthreeway = 0;
2746 } else if (p->subs[SUB_CALLWAIT].zfd > -1) {
2747 /* Move to the call-wait and switch back to them. */
2748 swap_subs(p, SUB_CALLWAIT, SUB_REAL);
2749 unalloc_sub(p, SUB_CALLWAIT);
2750 p->owner = p->subs[SUB_REAL].owner;
2751 if (p->owner->_state != AST_STATE_UP)
2752 p->subs[SUB_REAL].needanswer = 1;
2753 if (ast_bridged_channel(p->subs[SUB_REAL].owner))
2754 ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD);
2755 } else if (p->subs[SUB_THREEWAY].zfd > -1) {
2756 swap_subs(p, SUB_THREEWAY, SUB_REAL);
2757 unalloc_sub(p, SUB_THREEWAY);
2758 if (p->subs[SUB_REAL].inthreeway) {
2759 /* This was part of a three way call. Immediately make way for
2761 ast_debug(1, "Call was complete, setting owner to former third call\n");
2762 p->owner = p->subs[SUB_REAL].owner;
2764 /* This call hasn't been completed yet... Set owner to NULL */
2765 ast_debug(1, "Call was incomplete, setting owner to NULL\n");
2768 p->subs[SUB_REAL].inthreeway = 0;
2770 } else if (index == SUB_CALLWAIT) {
2771 /* Ditch the holding callwait call, and immediately make it availabe */
2772 if (p->subs[SUB_CALLWAIT].inthreeway) {
2773 /* This is actually part of a three way, placed on hold. Place the third part
2774 on music on hold now */
2775 if (p->subs[SUB_THREEWAY].owner && ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) {
2776 ast_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD,
2777 S_OR(p->mohsuggest, NULL),
2778 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
2780 p->subs[SUB_THREEWAY].inthreeway = 0;
2781 /* Make it the call wait now */
2782 swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
2783 unalloc_sub(p, SUB_THREEWAY);
2785 unalloc_sub(p, SUB_CALLWAIT);
2786 } else if (index == SUB_THREEWAY) {
2787 if (p->subs[SUB_CALLWAIT].inthreeway) {
2788 /* The other party of the three way call is currently in a call-wait state.
2789 Start music on hold for them, and take the main guy out of the third call */
2790 if (p->subs[SUB_CALLWAIT].owner && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) {
2791 ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD,
2792 S_OR(p->mohsuggest, NULL),
2793 !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
2795 p->subs[SUB_CALLWAIT].inthreeway = 0;
2797 p->subs[SUB_REAL].inthreeway = 0;
2798 /* If this was part of a three way call index, let us make
2799 another three way call */
2800 unalloc_sub(p, SUB_THREEWAY);
2802 /* This wasn't any sort of call, but how are we an index? */
2803 ast_log(LOG_WARNING, "Index found but not any type of call?\n");
2807 if (!p->subs[SUB_REAL].owner && !p->subs[SUB_CALLWAIT].owner && !p->subs[SUB_THREEWAY].owner) {
2810 p->distinctivering = 0;
2811 p->confirmanswer = 0;
2817 p->onhooktime = time(NULL);
2825 ast_dsp_free(p->dsp);
2829 law = ZT_LAW_DEFAULT;
2830 res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETLAW, &law);
2832 ast_log(LOG_WARNING, "Unable to set law on channel %d to default\n", p->channel);
2833 /* Perform low level hangup if no owner left */
2837 if (!ss7_grab(p, p->ss7)) {
2838 if (!p->alreadyhungup) {
2839 const char *cause = pbx_builtin_getvar_helper(ast,"SS7_CAUSE");
2840 int icause = ast->hangupcause ? ast->hangupcause : -1;
2844 icause = atoi(cause);
2846 isup_rel(p->ss7->ss7, p->ss7call, icause);
2848 p->alreadyhungup = 1;
2850 ast_log(LOG_WARNING, "Trying to hangup twice!\n");
2852 ast_log(LOG_WARNING, "Unable to grab SS7 on CIC %d\n", p->cic);
2860 #ifdef SUPPORT_USERUSER
2861 const char *useruser = pbx_builtin_getvar_helper(ast,"USERUSERINFO");
2864 /* Make sure we have a call (or REALLY have a call in the case of a PRI) */
2865 if (p->call && (!p->bearer || (p->bearer->call == p->call))) {
2866 if (!pri_grab(p, p->pri)) {
2867 if (p->alreadyhungup) {
2868 ast_debug(1, "Already hungup... Calling hangup once, and clearing call\n");
2870 #ifdef SUPPORT_USERUSER
2871 pri_call_set_useruser(p->call, useruser);
2874 pri_hangup(p->pri->pri, p->call, -1);
2877 p->bearer->call = NULL;
2879 const char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE");
2880 int icause = ast->hangupcause ? ast->hangupcause : -1;
2881 ast_debug(1, "Not yet hungup... Calling hangup once with icause, and clearing call\n");
2883 #ifdef SUPPORT_USERUSER
2884 pri_call_set_useruser(p->call, useruser);
2887 p->alreadyhungup = 1;
2889 p->bearer->alreadyhungup = 1;
2892 icause = atoi(cause);
2894 pri_hangup(p->pri->pri, p->call, icause);
2897 ast_log(LOG_WARNING, "pri_disconnect failed\n");
2900 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
2905 ast_debug(1, "Bearer call is %p, while ours is still %p\n", p->bearer->call, p->call);
2911 if (p->sig && ((p->sig != SIG_PRI) && (p->sig != SIG_SS7)))
2912 res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_ONHOOK);
2914 ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name);
2920 res = ioctl(p->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &par);
2923 ast_debug(1, "Hanging up channel %d, offhook = %d\n", p->channel, par.rxisoffhook);
2925 /* If they're off hook, try playing congestion */
2926 if ((par.rxisoffhook) && (!(p->radio || (p->oprmode < 0))))
2927 tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_CONGESTION);
2929 tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
2935 /* Make sure we're not made available for at least two seconds assuming
2936 we were actually used for an inbound or outbound call. */
2937 if (ast->_state != AST_STATE_RESERVED) {
2938 time(&p->guardtime);
2943 tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
2946 ast_free(p->cidspill);
2950 ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0);
2951 ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0);
2955 p->callwaiting = p->permcallwaiting;
2956 p->hidecallerid = p->permhidecallerid;
2961 /* Restore data mode */
2962 if ((p->sig == SIG_PRI) || (p->sig == SIG_SS7)) {
2964 ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
2968 ast_debug(1, "Freeing up bearer channel %d\n", p->bearer->channel);
2969 /* Free up the bearer channel as well, and
2970 don't use its file descriptor anymore */
2971 update_conf(p->bearer);
2972 reset_conf(p->bearer);
2973 p->bearer->owner = NULL;
2974 p->bearer->realcall = NULL;
2976 p->subs[SUB_REAL].zfd = -1;
2983 p->callwaitingrepeat = 0;
2986 ast->tech_pvt = NULL;
2987 ast_mutex_unlock(&p->lock);
2988 ast_module_unref(ast_module_info->self);
2989 if (option_verbose > 2)
2990 ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);
2992 ast_mutex_lock(&iflock);
2998 destroy_channel(prev, tmp, 0);
3006 ast_mutex_unlock(&iflock);
3010 static int zt_answer(struct ast_channel *ast)
3012 struct zt_pvt *p = ast->tech_pvt;
3015 int oldstate = ast->_state;
3016 ast_setstate(ast, AST_STATE_UP);
3017 ast_mutex_lock(&p->lock);
3018 index = zt_get_index(ast, p, 0);
3021 /* nothing to do if a radio channel */
3022 if ((p->radio || (p->oprmode < 0))) {
3023 ast_mutex_unlock(&p->lock);
3037 case SIG_FEATDMF_TA:
3040 case SIG_FGC_CAMAMF:
3045 case SIG_SF_FEATDMF:
3050 /* Pick up the line */
3051 ast_debug(1, "Took %s off hook\n", ast->name);
3052 if (p->hanguponpolarityswitch) {
3053 gettimeofday(&p->polaritydelaytv, NULL);
3055 res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
3056 tone_zone_play_tone(p->subs[index].zfd, -1);
3058 if ((index == SUB_REAL) && p->subs[SUB_THREEWAY].inthreeway) {
3059 if (oldstate == AST_STATE_RINGING) {
3060 ast_debug(1, "Finally swapping real and threeway\n");
3061 tone_zone_play_tone(p->subs[SUB_THREEWAY].zfd, -1);
3062 swap_subs(p, SUB_THREEWAY, SUB_REAL);
3063 p->owner = p->subs[SUB_REAL].owner;
3066 if (p->sig & __ZT_SIG_FXS) {
3073 /* Send a pri acknowledge */
3074 if (!pri_grab(p, p->pri)) {
3076 res = pri_answer(p->pri->pri, p->call, 0, !p->digital);
3079 ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
3086 if (!ss7_grab(p, p->ss7)) {
3088 res = isup_anm(p->ss7->ss7, p->ss7call);
3091 ast_log(LOG_WARNING, "Unable to grab SS7 on span %d\n", p->span);
3097 ast_mutex_unlock(&p->lock);
3100 ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
3103 ast_mutex_unlock(&p->lock);
3107 static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen)
3113 struct zt_pvt *p = chan->tech_pvt, *pp;
3114 struct oprmode *oprmode;
3117 /* all supported options require data */
3118 if (!data || (datalen < 1)) {
3124 case AST_OPTION_TXGAIN:
3125 scp = (signed char *) data;
3126 index = zt_get_index(chan, p, 0);
3128 ast_log(LOG_WARNING, "No index in TXGAIN?\n");
3131 ast_debug(1, "Setting actual tx gain on %s to %f\n", chan->name, p->txgain + (float) *scp);
3132 return set_actual_txgain(p->subs[index].zfd, 0, p->txgain + (float) *scp, p->law);
3133 case AST_OPTION_RXGAIN:
3134 scp = (signed char *) data;
3135 index = zt_get_index(chan, p, 0);
3137 ast_log(LOG_WARNING, "No index in RXGAIN?\n");
3140 ast_debug(1, "Setting actual rx gain on %s to %f\n", chan->name, p->rxgain + (float) *scp);
3141 return set_actual_rxgain(p->subs[index].zfd, 0, p->rxgain + (float) *scp, p->law);
3142 case AST_OPTION_TONE_VERIFY:
3148 ast_debug(1, "Set option TONE VERIFY, mode: MUTECONF(1) on %s\n",chan->name);
3149 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | p->dtmfrelax); /* set mute mode if desired */
3152 ast_debug(1, "Set option TONE VERIFY, mode: MUTECONF/MAX(2) on %s\n",chan->name);
3153 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX | p->dtmfrelax); /* set mute mode if desired */
3156 ast_debug(1, "Set option TONE VERIFY, mode: OFF(0) on %s\n",chan->name);
3157 ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax); /* set mute mode if desired */
3161 case AST_OPTION_TDD:
3162 /* turn on or off TDD */
3165 if (!*cp) { /* turn it off */
3166 ast_debug(1, "Set option TDD MODE, value: OFF(0) on %s\n",chan->name);
3172 ast_debug(1, "Set option TDD MODE, value: %s(%d) on %s\n",
3173 (*cp == 2) ? "MATE" : "ON", (int) *cp, chan->name);
3175 /* otherwise, turn it on */
3176 if (!p->didtdd) { /* if havent done it yet */
3177 unsigned char mybuf[41000], *buf;
3178 int size, res, fd, len;
3179 struct pollfd fds[1];
3182 memset(buf, 0x7f, sizeof(mybuf)); /* set to silence */
3183 ast_tdd_gen_ecdisa(buf + 16000, 16000); /* put in tone */
3185 index = zt_get_index(chan, p, 0);
3187 ast_log(LOG_WARNING, "No index in TDD?\n");
3190 fd = p->subs[index].zfd;
3192 if (ast_check_hangup(chan))
3195 if (size > READ_SIZE)
3198 fds[0].events = POLLPRI | POLLOUT;
3200 res = poll(fds, 1, -1);
3202 ast_debug(1, "poll (for write) ret. 0 on channel %d\n", p->channel);
3205 /* if got exception */
3206 if (fds[0].revents & POLLPRI)
3208 if (!(fds[0].revents & POLLOUT)) {
3209 ast_debug(1, "write fd not ready on channel %d\n", p->channel);
3212 res = write(fd, buf, size);
3214 if (res == -1) return -1;
3215 ast_debug(1, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
3221 p->didtdd = 1; /* set to have done it now */
3223 if (*cp == 2) { /* Mate mode */
3230 if (!p->tdd) { /* if we dont have one yet */
3231 p->tdd = tdd_new(); /* allocate one */
3234 case AST_OPTION_RELAXDTMF: /* Relax DTMF decoding (or not) */
3238 ast_debug(1, "Set option RELAX DTMF, value: %s(%d) on %s\n",
3239 *cp ? "ON" : "OFF", (int) *cp, chan->name);
3240 ast_dsp_digitmode(p->dsp, ((*cp) ? DSP_DIGITMODE_RELAXDTMF : DSP_DIGITMODE_DTMF) | p->dtmfrelax);
3242 case AST_OPTION_AUDIO_MODE: /* Set AUDIO mode (or not) */
3245 ast_debug(1, "Set option AUDIO MODE, value: OFF(0) on %s\n", chan->name);
3249 ast_debug(1, "Set option AUDIO MODE, value: ON(1) on %s\n", chan->name);
3252 if (ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x) == -1)
3253 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d\n", p->channel, x);
3255 case AST_OPTION_OPRMODE: /* Operator services mode */
3256 oprmode = (struct oprmode *) data;
3257 pp = oprmode->peer->tech_pvt;
3258 p->oprmode = pp->oprmode = 0;
3262 /* setup modes, if any */
3265 pp->oprmode = oprmode->mode;
3266 p->oprmode = -oprmode->mode;
3268 ast_debug(1, "Set Operator Services mode, value: %d on %s/%s\n",
3269 oprmode->mode, chan->name,oprmode->peer->name);
3271 case AST_OPTION_ECHOCAN:
3274 ast_debug(1, "Enabling echo cancelation on %s\n", chan->name);
3277 ast_debug(1, "Disabling echo cancelation on %s\n", chan->name);
3287 static int zt_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len)
3289 struct zt_pvt *p = chan->tech_pvt;
3291 if (!strcasecmp(data, "rxgain")) {
3292 ast_mutex_lock(&p->lock);
3293 snprintf(buf, len, "%f", p->rxgain);
3294 ast_mutex_unlock(&p->lock);
3295 } else if (!strcasecmp(data, "txgain")) {
3296 ast_mutex_lock(&p->lock);
3297 snprintf(buf, len, "%f", p->txgain);
3298 ast_mutex_unlock(&p->lock);
3300 ast_copy_string(buf, "", len);
3306 static void zt_unlink(struct zt_pvt *slave, struct zt_pvt *master, int needlock)
3308 /* Unlink a specific slave or all slaves/masters from a given master */
3314 ast_mutex_lock(&master->lock);
3316 while (ast_mutex_trylock(&slave->lock)) {
3317 ast_mutex_unlock(&master->lock);
3319 ast_mutex_lock(&master->lock);
3324 for (x = 0; x < MAX_SLAVES; x++) {
3325 if (master->slaves[x]) {
3326 if (!slave || (master->slaves[x] == slave)) {
3327 /* Take slave out of the conference */
3328 ast_debug(1, "Unlinking slave %d from %d\n", master->slaves[x]->channel, master->channel);
3329 conf_del(master, &master->slaves[x]->subs[SUB_REAL], SUB_REAL);
3330 conf_del(master->slaves[x], &master->subs[SUB_REAL], SUB_REAL);
3331 master->slaves[x]->master = NULL;
3332 master->slaves[x] = NULL;
3337 master->inconference = 0;
3340 if (master->master) {
3341 /* Take master out of the conference */
3342 conf_del(master->master, &master->subs[SUB_REAL], SUB_REAL);
3343 conf_del(master, &master->master->subs[SUB_REAL], SUB_REAL);
3345 for (x = 0; x < MAX_SLAVES; x++) {
3346 if (master->master->slaves[x] == master)
3347 master->master->slaves[x] = NULL;
3348 else if (master->master->slaves[x])
3352 master->master->inconference = 0;
3354 master->master = NULL;
3356 update_conf(master);
3359 ast_mutex_unlock(&slave->lock);
3360 ast_mutex_unlock(&master->lock);
3364 static void zt_link(struct zt_pvt *slave, struct zt_pvt *master) {
3366 if (!slave || !master) {
3367 ast_log(LOG_WARNING, "Tried to link to/from NULL??\n");
3370 for (x = 0; x < MAX_SLAVES; x++) {
3371 if (!master->slaves[x]) {
3372 master->slaves[x] = slave;
3376 if (x >= MAX_SLAVES) {
3377 ast_log(LOG_WARNING, "Replacing slave %d with new slave, %d\n", master->slaves[MAX_SLAVES - 1]->channel, slave->channel);
3378 master->slaves[MAX_SLAVES - 1] = slave;
3381 ast_log(LOG_WARNING, "Replacing master %d with new master, %d\n", slave->master->channel, master->channel);
3382 slave->master = master;
3384 ast_debug(1, "Making %d slave to master %d at %d\n", slave->channel, master->channel, x);
3387 static void disable_dtmf_detect(struct zt_pvt *p)
3389 #ifdef ZT_TONEDETECT
3395 #ifdef ZT_TONEDETECT
3397 ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
3399 if (!p->hardwaredtmf && p->dsp) {
3400 p->dsp_features &= ~DSP_FEATURE_DTMF_DETECT;
3401 ast_dsp_set_features(p->dsp, p->dsp_features);
3405 static void enable_dtmf_detect(struct zt_pvt *p)
3407 #ifdef ZT_TONEDETECT
3411 if (p->channel == CHAN_PSEUDO)
3416 #ifdef ZT_TONEDETECT
3417 val = ZT_TONEDETECT_ON | ZT_TONEDETECT_MUTE;
3418 ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
3420 if (!p->hardwaredtmf && p->dsp) {
3421 p->dsp_features |= DSP_FEATURE_DTMF_DETECT;
3422 ast_dsp_set_features(p->dsp, p->dsp_features);
3426 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)
3428 struct ast_channel *who;
3429 struct zt_pvt *p0, *p1, *op0, *op1;
3430 struct zt_pvt *master = NULL, *slave = NULL;
3431 struct ast_frame *f;
3435 int oi0, oi1, i0 = -1, i1 = -1, t0, t1;
3436 int os0 = -1, os1 = -1;
3438 struct ast_channel *oc0, *oc1;
3439 enum ast_bridge_result res;
3442 int triedtopribridge = 0;
3443 q931_call *q931c0 = NULL, *q931c1 = NULL;
3446 /* For now, don't attempt to native bridge if either channel needs DTMF detection.
3447 There is code below to handle it properly until DTMF is actually seen,
3448 but due to currently unresolved issues it's ignored...
3451 if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
3452 return AST_BRIDGE_FAILED_NOWARN;
3454 ast_mutex_lock(&c0->lock);
3455 ast_mutex_lock(&c1->lock);