chan_zap.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2005, Digium, Inc.
 *
 * Mark Spencer <markster@digium.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief Zaptel Pseudo TDM interface 
 * 
 * Connects to the zaptel telephony library as well as 
 * libpri. Libpri is optional and needed only if you are
 * going to use ISDN connections.
 *
 * You need to install libraries before you attempt to compile
 * and install the zaptel channel.
 *
 * \par See also
 * \arg \ref Config_zap
 *
 * \ingroup channel_drivers
 */

#include <stdio.h>
#include <string.h>
#ifdef __NetBSD__
#include <pthread.h>
#include <signal.h>
#else
#include <sys/signal.h>
#endif
#include <errno.h>
#include <stdlib.h>
#if !defined(SOLARIS) && !defined(__FreeBSD__)
#include <stdint.h>
#endif
#include <unistd.h>
#include <sys/ioctl.h>
#ifdef __linux__
#include <linux/zaptel.h>
#else
#include <zaptel.h>
#endif /* __linux__ */
#include <math.h>
#include <tonezone.h>
#include <ctype.h>
#ifdef ZAPATA_PRI
#include <libpri.h>
#ifndef PRI_USER_USER_TX
#error "You need newer libpri"
#endif
#endif
#ifdef ZAPATA_R2
#include <libmfcr2.h>
#endif

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 211526 $")

#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/file.h"
#include "asterisk/ulaw.h"
#include "asterisk/alaw.h"
#include "asterisk/callerid.h"
#include "asterisk/adsi.h"
#include "asterisk/cli.h"
#include "asterisk/cdr.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/tdd.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/astdb.h"
#include "asterisk/manager.h"
#include "asterisk/causes.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/transcap.h"

#ifndef ZT_SIG_EM_E1
#error "Your zaptel is too old.  please cvs update"
#endif

#ifndef ZT_TONEDETECT
/* Work around older code with no tone detect */
#define ZT_EVENT_DTMFDOWN 0
#define ZT_EVENT_DTMFUP 0
#endif

/* define this to send PRI user-user information elements */
#undef SUPPORT_USERUSER

/*! 
 * \note Define ZHONE_HACK to cause us to go off hook and then back on hook when
 * the user hangs up to reset the state machine so ring works properly.
 * This is used to be able to support kewlstart by putting the zhone in
 * groundstart mode since their forward disconnect supervision is entirely
 * broken even though their documentation says it isn't and their support
 * is entirely unwilling to provide any assistance with their channel banks
 * even though their web site says they support their products for life.
 */
/* #define ZHONE_HACK */

/*! \note
 * Define if you want to check the hook state for an FXO (FXS signalled) interface
 * before dialing on it.  Certain FXO interfaces always think they're out of
 * service with this method however.
 */
/* #define ZAP_CHECK_HOOKSTATE */

/*! \brief Typically, how many rings before we should send Caller*ID */
#define DEFAULT_CIDRINGS 1

#define CHANNEL_PSEUDO -12

#define AST_LAW(p) (((p)->law == ZT_LAW_ALAW) ? AST_FORMAT_ALAW : AST_FORMAT_ULAW)

/*! \brief Signaling types that need to use MF detection should be placed in this macro */
#define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FEATB)) 

static const char desc[] = "Zapata Telephony"
#ifdef ZAPATA_PRI
               " w/PRI"
#endif
#ifdef ZAPATA_R2
               " w/R2"
#endif
;

static const char tdesc[] = "Zapata Telephony Driver"
#ifdef ZAPATA_PRI
               " w/PRI"
#endif
#ifdef ZAPATA_R2
               " w/R2"
#endif
;

static const char type[] = "Zap";
static const char config[] = "zapata.conf";

#define SIG_EM    ZT_SIG_EM
#define SIG_EMWINK   (0x0100000 | ZT_SIG_EM)
#define SIG_FEATD (0x0200000 | ZT_SIG_EM)
#define  SIG_FEATDMF (0x0400000 | ZT_SIG_EM)
#define  SIG_FEATB   (0x0800000 | ZT_SIG_EM)
#define  SIG_E911 (0x1000000 | ZT_SIG_EM)
#define  SIG_FEATDMF_TA (0x2000000 | ZT_SIG_EM)
#define SIG_FXSLS ZT_SIG_FXSLS
#define SIG_FXSGS ZT_SIG_FXSGS
#define SIG_FXSKS ZT_SIG_FXSKS
#define SIG_FXOLS ZT_SIG_FXOLS
#define SIG_FXOGS ZT_SIG_FXOGS
#define SIG_FXOKS ZT_SIG_FXOKS
#define SIG_PRI      ZT_SIG_CLEAR
#define SIG_R2    ZT_SIG_CAS
#define  SIG_SF      ZT_SIG_SF
#define SIG_SFWINK   (0x0100000 | ZT_SIG_SF)
#define SIG_SF_FEATD (0x0200000 | ZT_SIG_SF)
#define  SIG_SF_FEATDMF (0x0400000 | ZT_SIG_SF)
#define  SIG_SF_FEATB   (0x0800000 | ZT_SIG_SF)
#define SIG_EM_E1 ZT_SIG_EM_E1
#define SIG_GR303FXOKS  (0x0100000 | ZT_SIG_FXOKS)
#define SIG_GR303FXSKS  (0x0100000 | ZT_SIG_FXSKS)

#define NUM_SPANS       32
#define NUM_DCHANS      4  /*!< No more than 4 d-channels */
#define MAX_CHANNELS 672      /*!< No more than a DS3 per trunk group */

#define CHAN_PSEUDO  -2

#define DCHAN_PROVISIONED (1 << 0)
#define DCHAN_NOTINALARM  (1 << 1)
#define DCHAN_UP          (1 << 2)

#define DCHAN_AVAILABLE (DCHAN_PROVISIONED | DCHAN_NOTINALARM | DCHAN_UP)

static char defaultcic[64] = "";
static char defaultozz[64] = "";

static char language[MAX_LANGUAGE] = "";
static char progzone[10]= "";

static int usedistinctiveringdetection = 0;

static int numbufs = 4;

#ifdef ZAPATA_PRI
static struct ast_channel inuse = { "GR-303InUse" };
#ifdef PRI_GETSET_TIMERS
static int pritimers[PRI_MAX_TIMERS];
#endif
static int pridebugfd = -1;
static char pridebugfilename[1024]="";
#endif

/*! \brief Wait up to 16 seconds for first digit (FXO logic) */
static int firstdigittimeout = 16000;

/*! \brief How long to wait for following digits (FXO logic) */
static int gendigittimeout = 8000;

/*! \brief How long to wait for an extra digit, if there is an ambiguous match */
static int matchdigittimeout = 3000;

static int usecnt =0;
AST_MUTEX_DEFINE_STATIC(usecnt_lock);

/*! \brief Protect the interface list (of zt_pvt's) */
AST_MUTEX_DEFINE_STATIC(iflock);


static int ifcount = 0;

#ifdef ZAPATA_PRI
AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
#endif

/*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
   when it's doing something critical. */
AST_MUTEX_DEFINE_STATIC(monlock);

/*! \brief This is the thread for the monitor which checks for input on the channels
   which are not currently in use.  */
static pthread_t monitor_thread = AST_PTHREADT_NULL;

static int restart_monitor(void);

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);

static int zt_sendtext(struct ast_channel *c, const char *text);

/*! \brief Avoid the silly zt_getevent which ignores a bunch of events */
static inline int zt_get_event(int fd)
{
   int j;
   if (ioctl(fd, ZT_GETEVENT, &j) == -1) return -1;
   return j;
}

/*! \brief Avoid the silly zt_waitevent which ignores a bunch of events */
static inline int zt_wait_event(int fd)
{
   int i,j=0;
   i = ZT_IOMUX_SIGEVENT;
   if (ioctl(fd, ZT_IOMUX, &i) == -1) return -1;
   if (ioctl(fd, ZT_GETEVENT, &j) == -1) return -1;
   return j;
}

/*! Chunk size to read -- we use 20ms chunks to make things happy.  */   
#define READ_SIZE 160

#define MASK_AVAIL      (1 << 0) /*!< Channel available for PRI use */
#define MASK_INUSE      (1 << 1) /*!< Channel currently in use */

#define CALLWAITING_SILENT_SAMPLES  ( (300 * 8) / READ_SIZE) /*!< 300 ms */
#define CALLWAITING_REPEAT_SAMPLES  ( (10000 * 8) / READ_SIZE) /*!< 300 ms */
#define CIDCW_EXPIRE_SAMPLES     ( (500 * 8) / READ_SIZE) /*!< 500 ms */
#define MIN_MS_SINCE_FLASH       ( (2000) )  /*!< 2000 ms */
#define DEFAULT_RINGT            ( (8000 * 8) / READ_SIZE)

struct zt_pvt;


#ifdef ZAPATA_R2
static int r2prot = -1;
#endif

static int ringt_base = DEFAULT_RINGT;

#ifdef ZAPATA_PRI

#define PVT_TO_CHANNEL(p) (((p)->prioffset) | ((p)->logicalspan << 8) | (p->pri->mastertrunkgroup ? 0x10000 : 0))
#define PRI_CHANNEL(p) ((p) & 0xff)
#define PRI_SPAN(p) (((p) >> 8) & 0xff)
#define PRI_EXPLICIT(p) (((p) >> 16) & 0x01)

struct zt_pri {
   pthread_t master;                /*!< Thread of master */
   ast_mutex_t lock;                /*!< Mutex */
   char idleext[AST_MAX_EXTENSION];          /*!< Where to idle extra calls */
   char idlecontext[AST_MAX_CONTEXT];           /*!< What context to use for idle */
   char idledial[AST_MAX_EXTENSION];            /*!< What to dial before dumping */
   int minunused;                   /*!< Min # of channels to keep empty */
   int minidle;                     /*!< Min # of "idling" calls to keep active */
   int nodetype;                    /*!< Node type */
   int switchtype;                     /*!< Type of switch to emulate */
   int nsf;                   /*!< Network-Specific Facilities */
   int dialplan;                    /*!< Dialing plan */
   int localdialplan;                  /*!< Local dialing plan */
   char internationalprefix[10];             /*!< country access code ('00' for european dialplans) */
   char nationalprefix[10];               /*!< area access code ('0' for european dialplans) */
   char localprefix[20];                  /*!< area access code + area code ('0'+area code for european dialplans) */
   char privateprefix[20];                /*!< for private dialplans */
   char unknownprefix[20];                /*!< for unknown dialplans */
   int dchannels[NUM_DCHANS];             /*!< What channel are the dchannels on */
   int trunkgroup;                     /*!< What our trunkgroup is */
   int mastertrunkgroup;                  /*!< What trunk group is our master */
   int prilogicalspan;                 /*!< Logical span number within trunk group */
   int numchans;                    /*!< Num of channels we represent */
   int overlapdial;                 /*!< In overlap dialing mode */
   int facilityenable;                 /*!< Enable facility IEs */
   struct pri *dchans[NUM_DCHANS];              /*!< Actual d-channels */
   int dchanavail[NUM_DCHANS];               /*!< Whether each channel is available */
   struct pri *pri;                 /*!< Currently active D-channel */
   int debug;
   int fds[NUM_DCHANS];                /*!< FD's for d-channels */
   int offset;
   int span;
   int resetting;
   int resetpos;
   time_t lastreset;                /*!< time when unused channels were last reset */
   long resetinterval;                 /*!< Interval (in seconds) for resetting unused channels */
   struct zt_pvt *pvts[MAX_CHANNELS];           /*!< Member channel pvt structs */
   struct zt_pvt *crvs;                /*!< Member CRV structs */
   struct zt_pvt *crvend;                 /*!< Pointer to end of CRV structs */
};


static struct zt_pri pris[NUM_SPANS];

static int pritype = PRI_CPE;

#if 0
#define DEFAULT_PRI_DEBUG (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE)
#else
#define DEFAULT_PRI_DEBUG 0
#endif

static inline void pri_rel(struct zt_pri *pri)
{
   ast_mutex_unlock(&pri->lock);
}

static int switchtype = PRI_SWITCH_NI2;
static int nsf = PRI_NSF_NONE;
static int dialplan = PRI_NATIONAL_ISDN + 1;
static int localdialplan = PRI_NATIONAL_ISDN + 1;

#else
/*! Shut up the compiler */
struct zt_pri;
#endif

#define SUB_REAL  0        /*!< Active call */
#define SUB_CALLWAIT 1        /*!< Call-Waiting call on hold */
#define SUB_THREEWAY 2        /*!< Three-way call */

/* Polarity states */
#define POLARITY_IDLE   0
#define POLARITY_REV    1


static struct zt_distRings drings;

struct distRingData {
   int ring[3];
};
struct ringContextData {
   char contextData[AST_MAX_CONTEXT];
};
struct zt_distRings {
   struct distRingData ringnum[3];
   struct ringContextData ringContext[3];
};

static char *subnames[] = {
   "Real",
   "Callwait",
   "Threeway"
};

struct zt_subchannel {
   int zfd;
   struct ast_channel *owner;
   int chan;
   short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
   struct ast_frame f;     /*!< One frame for each channel.  How did this ever work before? */
   unsigned int needringing:1;
   unsigned int needbusy:1;
   unsigned int needcongestion:1;
   unsigned int needcallerid:1;
   unsigned int needanswer:1;
   unsigned int needflash:1;
   unsigned int linear:1;
   unsigned int inthreeway:1;
   ZT_CONFINFO curconf;
};

#define CONF_USER_REAL     (1 << 0)
#define CONF_USER_THIRDCALL   (1 << 1)

#define MAX_SLAVES   4

/*! \brief The PRI part of the channel configuration.
 * Separated as it is is applied to the span rather than to the channel.
 */
struct zt_pri_conf {
#ifdef ZAPATA_PRI
   int minunused;
   int minidle;
   char idleext[AST_MAX_EXTENSION];
   char idledial[AST_MAX_EXTENSION];
   int overlapdial;
   int facilityenable;
   char internationalprefix[10];
   char nationalprefix[10];
   char localprefix[20];
   char privateprefix[20];
   char unknownprefix[20];
   long resetinterval;
#endif
};

/*! \brief Channel configuration from zapata.conf .
 * This struct is used for parsing the [channels] section of zapata.conf.
 * Generally there is a field here for every possible configuration item.
 *
 * The state of fields is saved along the parsing and whenever a 'channel'
 * statement is reached, the current zt_chan_conf is used to configure the 
 * channel (struct zt_pvt)
 *
 * @seealso zt_chan_init for the default values.
 */
struct zt_chan_conf {
   struct zt_pri_conf pri;
   char context[AST_MAX_CONTEXT];
   char cid_num[AST_MAX_EXTENSION];
   char cid_name[AST_MAX_EXTENSION];
   char musicclass[MAX_MUSICCLASS];
   int transfertobusy;

   int cid_signalling;
   int cid_start;
   int zaptrcallerid;
   int use_callerid;
   int signalling;
   int outsignalling;
   ast_group_t group;
   ast_group_t callergroup;
   ast_group_t pickupgroup;

   int relaxdtmf;

   int immediate; 

   int stripmsd;

   int callwaiting;

   int callwaitingcallerid;

   int hidecallerid;

   int restrictcid;

   int use_callingpres;

   int callreturn;

   int threewaycalling;

   int transfer;

   int canpark;

   int cancallforward;

   float rxgain;

   float txgain;

   int tonezone;

   int echocancel;

   int echotraining;

   int pulse;

   int echocanbridged;

   int busydetect;

   int busycount;
   int busy_tonelength;
   int busy_quietlength;

   int callprogress;

   char accountcode[AST_MAX_ACCOUNT_CODE];

   char mailbox[AST_MAX_EXTENSION];

   int amaflags;

   int adsi;

   int numbufs;

   int prewink;
   int preflash;
   int wink;
   int flash;
   int start;
   int rxwink;
   int rxflash;
   int debounce;
   int priexclusive;

   int answeronpolarityswitch;
   int hanguponpolarityswitch;
   int polarityonanswerdelay;
   int sendcalleridafter;

   int priindication_oob;
   int radio;
};

/** returns a new zt_chan_conf with default values (by-value) */
struct zt_chan_conf zt_chan_conf_default(void) {
   struct zt_chan_conf chan_conf = {
      .pri = {
#ifdef ZAPATA_PRI
         .minunused = 2,
         .minidle = 0,
         .idleext = "",
         .idledial = "",
         .overlapdial = 0,
         .facilityenable = 0,
         .internationalprefix = "",
         .nationalprefix = "",
         .localprefix = "",
         .privateprefix = "",
         .unknownprefix = "",
         /*!< How often (in seconds) to reset unused channels. Default 1 hour. */
         .resetinterval = 3600,  
#endif
      },
      .context = "default",
      .cid_num = "",
      .cid_name = "",
      .musicclass = "",
      .transfertobusy = 1,

      .cid_signalling = CID_SIG_BELL,
      .cid_start = CID_START_RING,
      .zaptrcallerid = 0,
      .use_callerid = 1,
      .signalling = -1,
      .group = 0,
      .callergroup = 0,
      .pickupgroup = 0,

      .relaxdtmf = 0,
      .immediate = 0,

      .stripmsd = 0,

      .callwaiting = 0,

      .callwaitingcallerid = 0,

      .hidecallerid = 0,

      .restrictcid = 0,

      .use_callingpres = 0,

      .callreturn = 0,

      .threewaycalling = 0,

      .transfer = 0,

      .canpark = 0,

      .cancallforward = 0,

      .rxgain = 0.0,

      .txgain = 0.0,

      .tonezone = -1,

      /*! \brief Boolean: true to use echo cancelling. Default: True. */
      .echocancel = 1,

      /*! \brief Integer: Echo training time. True implies 400. */
      .echotraining = 0,

      /*! \brief Boolean: Use pulse dialing. Default: false. Right? */
      .pulse = 0,
      
      /*! \brief Boolean: true to use echo cancelling even between zaptel 
       * channels. Default: false. */
      .echocanbridged = 0,

      /*! \brief Boolean: hangup calls by detecting a busy tone. 
       * Default: false. */
      .busydetect = 0,

      .busycount = 3,
      .busy_tonelength = 0,
      .busy_quietlength = 0,

      .callprogress = 0,

      .accountcode = "",

      /*! \brief String. Voicemail box in which to check mail for 
       * the channel (mailbox[@context]). Default: none. */
      .mailbox = "",
      .amaflags = 0,

      .adsi = 0,
      .numbufs = 4,

      .prewink = -1,
      .preflash = -1,
      .wink = -1,
      .flash = -1,
      .start = -1,
      .rxwink = -1,
      .rxflash = -1,
      .debounce = -1,
      .priexclusive = 0,

      /*! \brief Whether we answer on a Polarity Switch event */
      .answeronpolarityswitch = 0,

      /*! \brief Whether we hang up on a Polarity Switch event */
      .hanguponpolarityswitch = 0,

      /*! \brief How long (ms) to ignore Polarity Switch events after we answer a call */
      .polarityonanswerdelay = 600,

      /*! \brief When to send the CallerID signals (rings) */
      .sendcalleridafter = DEFAULT_CIDRINGS,

      .priindication_oob = 0,

      /* Add fields above this comment. "radio" will be 
       * kept as the one without the comma. for the moment, 
       * until we add all fields.
       */
      .radio = 0
   };

   return chan_conf;
}

static struct zt_pvt {
   ast_mutex_t lock;
   struct ast_channel *owner;       /*!< Our current active owner (if applicable) */
                     /*!< Up to three channels can be associated with this call */
      
   struct zt_subchannel sub_unused;    /*!< Just a safety precaution */
   struct zt_subchannel subs[3];       /*!< Sub-channels */
   struct zt_confinfo saveconf;        /*!< Saved conference info */

   struct zt_pvt *slaves[MAX_SLAVES];     /*!< Slave to us (follows our conferencing) */
   struct zt_pvt *master;           /*!< Master to us (we follow their conferencing) */
   int inconference;          /*!< If our real should be in the conference */
   
   int sig;             /*!< Signalling style */
   int radio;              /*!< radio type */
   float rxgain;
   float txgain;
   int tonezone;              /*!< tone zone for this chan, or -1 for default */
   struct zt_pvt *next;          /*!< Next channel in list */
   struct zt_pvt *prev;          /*!< Prev channel in list */

   /* flags */
   unsigned int adsi:1;
   unsigned int answeronpolarityswitch:1;
   unsigned int busydetect:1;
   unsigned int callreturn:1;
   unsigned int callwaiting:1;
   unsigned int callwaitingcallerid:1;
   unsigned int cancallforward:1;
   unsigned int canpark:1;
   unsigned int confirmanswer:1;       /*!< Wait for '#' to confirm answer */
   unsigned int destroy:1;
   unsigned int didtdd:1;           /*!< flag to say its done it once */
   unsigned int dialednone:1;
   unsigned int dialing:1;
   unsigned int digital:1;
   unsigned int dnd:1;
   unsigned int echobreak:1;
   unsigned int echocanbridged:1;
   unsigned int echocanon:1;
   unsigned int faxhandled:1;       /*!< Has a fax tone already been handled? */
   unsigned int firstradio:1;
   unsigned int hanguponpolarityswitch:1;
   unsigned int hardwaredtmf:1;
   unsigned int hidecallerid;
   unsigned int ignoredtmf:1;
   unsigned int immediate:1;        /*!< Answer before getting digits? */
   unsigned int inalarm:1;
   unsigned int mate:1;          /*!< flag to say its in MATE mode */
   unsigned int outgoing:1;
   unsigned int overlapdial:1;
   unsigned int permcallwaiting:1;
   unsigned int permhidecallerid:1;    /*!< Whether to hide our outgoing caller ID or not */
   unsigned int priindication_oob:1;
   unsigned int priexclusive:1;
   unsigned int pulse:1;
   unsigned int pulsedial:1;        /*!< whether a pulse dial phone is detected */
   unsigned int restrictcid:1;         /*!< Whether restrict the callerid -> only send ANI */
   unsigned int threewaycalling:1;
   unsigned int transfer:1;
   unsigned int use_callerid:1;        /*!< Whether or not to use caller id on this channel */
   unsigned int use_callingpres:1;        /*!< Whether to use the callingpres the calling switch sends */
   unsigned int usedistinctiveringdetection:1;
   unsigned int zaptrcallerid:1;       /*!< should we use the callerid from incoming call on zap transfer or not */
   unsigned int transfertobusy:1;         /*!< allow flash-transfers to busy channels */
#if defined(ZAPATA_PRI)
   unsigned int alerting:1;
   unsigned int alreadyhungup:1;
   unsigned int isidlecall:1;
   unsigned int proceeding:1;
   unsigned int progress:1;
   unsigned int resetting:1;
   unsigned int setup_ack:1;
#endif
#if defined(ZAPATA_R2)
   unsigned int hasr2call:1;
   unsigned int r2blocked:1;
   unsigned int sigchecked:1;
#endif

   struct zt_distRings drings;

   char context[AST_MAX_CONTEXT];
   char defcontext[AST_MAX_CONTEXT];
   char exten[AST_MAX_EXTENSION];
   char language[MAX_LANGUAGE];
   char musicclass[MAX_MUSICCLASS];
#ifdef PRI_ANI
   char cid_ani[AST_MAX_EXTENSION];
#endif
   char cid_num[AST_MAX_EXTENSION];
   int cid_ton;               /*!< Type Of Number (TON) */
   char cid_name[AST_MAX_EXTENSION];
   char lastcid_num[AST_MAX_EXTENSION];
   char lastcid_name[AST_MAX_EXTENSION];
   char *origcid_num;            /*!< malloced original callerid */
   char *origcid_name;           /*!< malloced original callerid */
   char callwait_num[AST_MAX_EXTENSION];
   char callwait_name[AST_MAX_EXTENSION];
   char rdnis[AST_MAX_EXTENSION];
   char dnid[AST_MAX_EXTENSION];
   unsigned int group;
   int law;
   int confno;             /*!< Our conference */
   int confusers;             /*!< Who is using our conference */
   int propconfno;               /*!< Propagated conference number */
   ast_group_t callgroup;
   ast_group_t pickupgroup;
   int channel;               /*!< Channel Number or CRV */
   int span;               /*!< Span number */
   time_t guardtime;          /*!< Must wait this much time before using for new call */
   int cid_signalling;           /*!< CID signalling type bell202 or v23 */
   int cid_start;             /*!< CID start indicator, polarity or ring */
   int callingpres;           /*!< The value of callling presentation that we're going to use when placing a PRI call */
   int callwaitingrepeat;           /*!< How many samples to wait before repeating call waiting */
   int cidcwexpire;           /*!< When to expire our muting for CID/CW */
   unsigned char *cidspill;
   int cidpos;
   int cidlen;
   int ringt;
   int ringt_base;
   int stripmsd;
   int callwaitcas;
   int callwaitrings;
   int echocancel;
   int echotraining;
   char echorest[20];
   int busycount;
   int busy_tonelength;
   int busy_quietlength;
   int callprogress;
   struct timeval flashtime;        /*!< Last flash-hook time */
   struct ast_dsp *dsp;
   int cref;               /*!< Call reference number */
   ZT_DIAL_OPERATION dop;
   int whichwink;             /*!< SIG_FEATDMF_TA Which wink are we on? */
   char finaldial[64];
   char accountcode[AST_MAX_ACCOUNT_CODE];      /*!< Account code */
   int amaflags;              /*!< AMA Flags */
   struct tdd_state *tdd;           /*!< TDD flag */
   char call_forward[AST_MAX_EXTENSION];
   char mailbox[AST_MAX_EXTENSION];
   char dialdest[256];
   int onhooktime;
   int msgstate;
   int distinctivering;          /*!< Which distinctivering to use */
   int cidrings;              /*!< Which ring to deliver CID on */
   int dtmfrelax;             /*!< whether to run in relaxed DTMF mode */
   int fake_event;
   int polarityonanswerdelay;
   struct timeval polaritydelaytv;
   int sendcalleridafter;
#ifdef ZAPATA_PRI
   struct zt_pri *pri;
   struct zt_pvt *bearer;
   struct zt_pvt *realcall;
   q931_call *call;
   int prioffset;
   int logicalspan;
#endif   
#ifdef ZAPATA_R2
   int r2prot;
   mfcr2_t *r2;
#endif   
   int polarity;
   int dsp_features;

} *iflist = NULL, *ifend = NULL;

static struct ast_channel *zt_request(const char *type, int format, void *data, int *cause);
static int zt_digit(struct ast_channel *ast, char digit);
static int zt_sendtext(struct ast_channel *c, const char *text);
static int zt_call(struct ast_channel *ast, char *rdest, int timeout);
static int zt_hangup(struct ast_channel *ast);
static int zt_answer(struct ast_channel *ast);
struct ast_frame *zt_read(struct ast_channel *ast);
static int zt_write(struct ast_channel *ast, struct ast_frame *frame);
struct ast_frame *zt_exception(struct ast_channel *ast);
static int zt_indicate(struct ast_channel *chan, int condition);
static int zt_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen);

static const struct ast_channel_tech zap_tech = {
   .type = type,
   .description = tdesc,
   .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW,
   .requester = zt_request,
   .send_digit = zt_digit,
   .send_text = zt_sendtext,
   .call = zt_call,
   .hangup = zt_hangup,
   .answer = zt_answer,
   .read = zt_read,
   .write = zt_write,
   .bridge = zt_bridge,
   .exception = zt_exception,
   .indicate = zt_indicate,
   .fixup = zt_fixup,
   .setoption = zt_setoption,
};

#ifdef ZAPATA_PRI
#define GET_CHANNEL(p) ((p)->bearer ? (p)->bearer->channel : p->channel)
#else
#define GET_CHANNEL(p) ((p)->channel)
#endif

struct zt_pvt *round_robin[32];

#ifdef ZAPATA_PRI
static inline int pri_grab(struct zt_pvt *pvt, struct zt_pri *pri)
{
   int res;
   /* Grab the lock first */
   do {
       res = ast_mutex_trylock(&pri->lock);
      if (res) {
         ast_mutex_unlock(&pvt->lock);
         /* Release the lock and try again */
         usleep(1);
         ast_mutex_lock(&pvt->lock);
      }
   } while(res);
   /* Then break the poll */
   pthread_kill(pri->master, SIGURG);
   return 0;
}
#endif

#define NUM_CADENCE_MAX 25
static int num_cadence = 4;
static int user_has_defined_cadences = 0;

static struct zt_ring_cadence cadences[NUM_CADENCE_MAX] = {
   { { 125, 125, 2000, 4000 } },       /*!< Quick chirp followed by normal ring */
   { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /*!< British style ring */
   { { 125, 125, 125, 125, 125, 4000 } }, /*!< Three short bursts */
   { { 1000, 500, 2500, 5000 } },   /*!< Long ring */
};

/*! \brief cidrings says in which pause to transmit the cid information, where the first pause
 * is 1, the second pause is 2 and so on.
 */

static int cidrings[NUM_CADENCE_MAX] = {
   2,                            /*!< Right after first long ring */
   4,                            /*!< Right after long part */
   3,                            /*!< After third chirp */
   2,                            /*!< Second spell */
};

#define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
         (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))

#define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)
#define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __ZT_SIG_FXO) */)

static int zt_get_index(struct ast_channel *ast, struct zt_pvt *p, int nullok)
{
   int res;
   if (p->subs[0].owner == ast)
      res = 0;
   else if (p->subs[1].owner == ast)
      res = 1;
   else if (p->subs[2].owner == ast)
      res = 2;
   else {
      res = -1;
      if (!nullok)
         ast_log(LOG_WARNING, "Unable to get index, and nullok is not asserted\n");
   }
   return res;
}

#ifdef ZAPATA_PRI
static void wakeup_sub(struct zt_pvt *p, int a, struct zt_pri *pri)
#else
static void wakeup_sub(struct zt_pvt *p, int a, void *pri)
#endif
{
   struct ast_frame null = { AST_FRAME_NULL, };
#ifdef ZAPATA_PRI
   if (pri)
      ast_mutex_unlock(&pri->lock);
#endif         
   for (;;) {
      if (p->subs[a].owner) {
         if (ast_mutex_trylock(&p->subs[a].owner->lock)) {
            ast_mutex_unlock(&p->lock);
            usleep(1);
            ast_mutex_lock(&p->lock);
         } else {
            ast_queue_frame(p->subs[a].owner, &null);
            ast_mutex_unlock(&p->subs[a].owner->lock);
            break;
         }
      } else
         break;
   }
#ifdef ZAPATA_PRI
   if (pri)
      ast_mutex_lock(&pri->lock);
#endif         
}

#ifdef ZAPATA_PRI
static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, struct zt_pri *pri)
#else
static void zap_queue_frame(struct zt_pvt *p, struct ast_frame *f, void *pri)
#endif
{
   /* We must unlock the PRI to avoid the possibility of a deadlock */
#ifdef ZAPATA_PRI
   if (pri)
      ast_mutex_unlock(&pri->lock);
#endif      
   for (;;) {
      if (p->owner) {
         if (ast_mutex_trylock(&p->owner->lock)) {
            ast_mutex_unlock(&p->lock);
            usleep(1);
            ast_mutex_lock(&p->lock);
         } else {
            ast_queue_frame(p->owner, f);
            ast_mutex_unlock(&p->owner->lock);
            break;
         }
      } else
         break;
   }
#ifdef ZAPATA_PRI
   if (pri)
      ast_mutex_lock(&pri->lock);
#endif      
}

static int restore_gains(struct zt_pvt *p);

static void swap_subs(struct zt_pvt *p, int a, int b)
{
   int tchan;
   int tinthreeway;
   struct ast_channel *towner;

   ast_log(LOG_DEBUG, "Swapping %d and %d\n", a, b);

   tchan = p->subs[a].chan;
   towner = p->subs[a].owner;
   tinthreeway = p->subs[a].inthreeway;

   p->subs[a].chan = p->subs[b].chan;
   p->subs[a].owner = p->subs[b].owner;
   p->subs[a].inthreeway = p->subs[b].inthreeway;

   p->subs[b].chan = tchan;
   p->subs[b].owner = towner;
   p->subs[b].inthreeway = tinthreeway;

   if (p->subs[a].owner) 
      p->subs[a].owner->fds[0] = p->subs[a].zfd;
   if (p->subs[b].owner) 
      p->subs[b].owner->fds[0] = p->subs[b].zfd;
   wakeup_sub(p, a, NULL);
   wakeup_sub(p, b, NULL);
}

static int zt_open(char *fn)
{
   int fd;
   int isnum;
   int chan = 0;
   int bs;
   int x;
   isnum = 1;
   for (x=0;x<strlen(fn);x++) {
      if (!isdigit(fn[x])) {
         isnum = 0;
         break;
      }
   }
   if (isnum) {
      chan = atoi(fn);
      if (chan < 1) {
         ast_log(LOG_WARNING, "Invalid channel number '%s'\n", fn);
         return -1;
      }
      fn = "/dev/zap/channel";
   }
   fd = open(fn, O_RDWR | O_NONBLOCK);
   if (fd < 0) {
      ast_log(LOG_WARNING, "Unable to open '%s': %s\n", fn, strerror(errno));
      return -1;
   }
   if (chan) {
      if (ioctl(fd, ZT_SPECIFY, &chan)) {
         x = errno;
         close(fd);
         errno = x;
         ast_log(LOG_WARNING, "Unable to specify channel %d: %s\n", chan, strerror(errno));
         return -1;
      }
   }
   bs = READ_SIZE;
   if (ioctl(fd, ZT_SET_BLOCKSIZE, &bs) == -1) return -1;
   return fd;
}

static void zt_close(int fd)
{
   if(fd > 0)
      close(fd);
}

int zt_setlinear(int zfd, int linear)
{
   int res;
   res = ioctl(zfd, ZT_SETLINEAR, &linear);
   if (res)
      return res;
   return 0;
}


int zt_setlaw(int zfd, int law)
{
   int res;
   res = ioctl(zfd, ZT_SETLAW, &law);
   if (res)
      return res;
   return 0;
}

static int alloc_sub(struct zt_pvt *p, int x)
{
   ZT_BUFFERINFO bi;
   int res;
   if (p->subs[x].zfd < 0) {
      p->subs[x].zfd = zt_open("/dev/zap/pseudo");
      if (p->subs[x].zfd > -1) {
         res = ioctl(p->subs[x].zfd, ZT_GET_BUFINFO, &bi);
         if (!res) {
            bi.txbufpolicy = ZT_POLICY_IMMEDIATE;
            bi.rxbufpolicy = ZT_POLICY_IMMEDIATE;
            bi.numbufs = numbufs;
            res = ioctl(p->subs[x].zfd, ZT_SET_BUFINFO, &bi);
            if (res < 0) {
               ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d\n", x);
            }
         } else 
            ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d\n", x);
         if (ioctl(p->subs[x].zfd, ZT_CHANNO, &p->subs[x].chan) == 1) {
            ast_log(LOG_WARNING,"Unable to get channel number for pseudo channel on FD %d\n",p->subs[x].zfd);
            zt_close(p->subs[x].zfd);
            p->subs[x].zfd = -1;
            return -1;
         }
         if (option_debug)
            ast_log(LOG_DEBUG, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].zfd, p->subs[x].chan);
         return 0;
      } else
         ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
      return -1;
   }
   ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
   return -1;
}

static int unalloc_sub(struct zt_pvt *p, int x)
{
   if (!x) {
      ast_log(LOG_WARNING, "Trying to unalloc the real channel %d?!?\n", p->channel);
      return -1;
   }
   ast_log(LOG_DEBUG, "Released sub %d of channel %d\n", x, p->channel);
   if (p->subs[x].zfd > -1) {
      zt_close(p->subs[x].zfd);
   }
   p->subs[x].zfd = -1;
   p->subs[x].linear = 0;
   p->subs[x].chan = 0;
   p->subs[x].owner = NULL;
   p->subs[x].inthreeway = 0;
   p->polarity = POLARITY_IDLE;
   memset(&p->subs[x].curconf, 0, sizeof(p->subs[x].curconf));
   return 0;
}

static int zt_digit(struct ast_channel *ast, char digit)
{
   ZT_DIAL_OPERATION zo;
   struct zt_pvt *p;
   int res = 0;
   int index;
   p = ast->tech_pvt;
   ast_mutex_lock(&p->lock);
   index = zt_get_index(ast, p, 0);
   if ((index == SUB_REAL) && p->owner) {
#ifdef ZAPATA_PRI
      if ((p->sig == SIG_PRI) && (ast->_state == AST_STATE_DIALING) && !p->proceeding) {
         if (p->setup_ack) {
            if (!pri_grab(p, p->pri)) {
               pri_information(p->pri->pri,p->call,digit);
               pri_rel(p->pri);
            } else
               ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
         } else if (strlen(p->dialdest) < sizeof(p->dialdest) - 1) {
            ast_log(LOG_DEBUG, "Queueing digit '%c' since setup_ack not yet received\n", digit);
            res = strlen(p->dialdest);
            p->dialdest[res++] = digit;
            p->dialdest[res] = '\0';
         }
      } else {
#else
      {
#endif
         zo.op = ZT_DIAL_OP_APPEND;
         zo.dialstr[0] = 'T';
         zo.dialstr[1] = digit;
         zo.dialstr[2] = 0;
         if ((res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &zo)))
            ast_log(LOG_WARNING, "Couldn't dial digit %c\n", digit);
         else
            p->dialing = 1;
      }
   }
   ast_mutex_unlock(&p->lock);
   return res;
}

static char *events[] = {
      "No event",
      "On hook",
      "Ring/Answered",
      "Wink/Flash",
      "Alarm",
      "No more alarm",
      "HDLC Abort",
      "HDLC Overrun",
      "HDLC Bad FCS",
      "Dial Complete",
      "Ringer On",
      "Ringer Off",
      "Hook Transition Complete",
      "Bits Changed",
      "Pulse Start",
      "Timer Expired",
      "Timer Ping",
      "Polarity Reversal",
      "Ring Begin",
};

static struct {
   int alarm;
   char *name;
} alarms[] = {
   { ZT_ALARM_RED, "Red Alarm" },
   { ZT_ALARM_YELLOW, "Yellow Alarm" },
   { ZT_ALARM_BLUE, "Blue Alarm" },
   { ZT_ALARM_RECOVER, "Recovering" },
   { ZT_ALARM_LOOPBACK, "Loopback" },
   { ZT_ALARM_NOTOPEN, "Not Open" },
   { ZT_ALARM_NONE, "None" },
};

static char *alarm2str(int alarm)
{
   int x;
   for (x=0;x<sizeof(alarms) / sizeof(alarms[0]); x++) {
      if (alarms[x].alarm & alarm)
         return alarms[x].name;
   }
   return alarm ? "Unknown Alarm" : "No Alarm";
}

static char *event2str(int event)
{
        static char buf[256];
        if ((event < (sizeof(events) / sizeof(events[0]))) && (event > -1))
                return events[event];
        sprintf(buf, "Event %d", event); /* safe */
        return buf;
}

#ifdef ZAPATA_PRI
static char *dialplan2str(int dialplan)
{
   if (dialplan == -1) {
      return("Dynamically set dialplan in ISDN");
   }
   return(pri_plan2str(dialplan));
}
#endif

#ifdef ZAPATA_R2
static int str2r2prot(char *swtype)
{
    if (!strcasecmp(swtype, "ar"))
        return MFCR2_PROT_ARGENTINA;
    /*endif*/
    if (!strcasecmp(swtype, "cn"))
        return MFCR2_PROT_CHINA;
    /*endif*/
    if (!strcasecmp(swtype, "kr"))
        return MFCR2_PROT_KOREA;
    /*endif*/
    return -1;
}
#endif

static char *zap_sig2str(int sig)
{
   static char buf[256];
   switch(sig) {
   case SIG_EM:
      return "E & M Immediate";
   case SIG_EMWINK:
      return "E & M Wink";
   case SIG_EM_E1:
      return "E & M E1";
   case SIG_FEATD:
      return "Feature Group D (DTMF)";
   case SIG_FEATDMF:
      return "Feature Group D (MF)";
   case SIG_FEATDMF_TA:
      return "Feature Groud D (MF) Tandem Access";
   case SIG_FEATB:
      return "Feature Group B (MF)";
   case SIG_E911:
      return "E911 (MF)";
   case SIG_FXSLS:
      return "FXS Loopstart";
   case SIG_FXSGS:
      return "FXS Groundstart";
   case SIG_FXSKS:
      return "FXS Kewlstart";
   case SIG_FXOLS:
      return "FXO Loopstart";
   case SIG_FXOGS:
      return "FXO Groundstart";
   case SIG_FXOKS:
      return "FXO Kewlstart";
   case SIG_PRI:
      return "PRI Signalling";
   case SIG_R2:
      return "R2 Signalling";
   case SIG_SF:
      return "SF (Tone) Signalling Immediate";
   case SIG_SFWINK:
      return "SF (Tone) Signalling Wink";
   case SIG_SF_FEATD:
      return "SF (Tone) Signalling with Feature Group D (DTMF)";
   case SIG_SF_FEATDMF:
      return "SF (Tone) Signalling with Feature Group D (MF)";
   case SIG_SF_FEATB:
      return "SF (Tone) Signalling with Feature Group B (MF)";
   case SIG_GR303FXOKS:
      return "GR-303 Signalling with FXOKS";
   case SIG_GR303FXSKS:
      return "GR-303 Signalling with FXSKS";
   case 0:
      return "Pseudo Signalling";
   default:
      snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
      return buf;
   }
}

#define sig2str zap_sig2str

static int conf_add(struct zt_pvt *p, struct zt_subchannel *c, int index, int slavechannel)
{
   /* If the conference already exists, and we're already in it
      don't bother doing anything */
   ZT_CONFINFO zi;
   
   memset(&zi, 0, sizeof(zi));
   zi.chan = 0;

   if (slavechannel > 0) {
      /* If we have only one slave, do a digital mon */
      zi.confmode = ZT_CONF_DIGITALMON;
      zi.confno = slavechannel;
   } else {
      if (!index) {
         /* Real-side and pseudo-side both participate in conference */
         zi.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER |
                        ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
      } else
         zi.confmode = ZT_CONF_CONF | ZT_CONF_TALKER | ZT_CONF_LISTENER;
      zi.confno = p->confno;
   }
   if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
      return 0;
   if (c->zfd < 0)
      return 0;
   if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
      ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d\n", c->zfd, zi.confmode, zi.confno);
      return -1;
   }
   if (slavechannel < 1) {
      p->confno = zi.confno;
   }
   memcpy(&c->curconf, &zi, sizeof(c->curconf));
   ast_log(LOG_DEBUG, "Added %d to conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
   return 0;
}

static int isourconf(struct zt_pvt *p, struct zt_subchannel *c)
{
   /* If they're listening to our channel, they're ours */  
   if ((p->channel == c->curconf.confno) && (c->curconf.confmode == ZT_CONF_DIGITALMON))
      return 1;
   /* If they're a talker on our (allocated) conference, they're ours */
   if ((p->confno > 0) && (p->confno == c->curconf.confno) && (c->curconf.confmode & ZT_CONF_TALKER))
      return 1;
   return 0;
}

static int conf_del(struct zt_pvt *p, struct zt_subchannel *c, int index)
{
   ZT_CONFINFO zi;
   if (/* Can't delete if there's no zfd */
      (c->zfd < 0) ||
      /* Don't delete from the conference if it's not our conference */
      !isourconf(p, c)
      /* Don't delete if we don't think it's conferenced at all (implied) */
      ) return 0;
   memset(&zi, 0, sizeof(zi));
   zi.chan = 0;
   zi.confno = 0;
   zi.confmode = 0;
   if (ioctl(c->zfd, ZT_SETCONF, &zi)) {
      ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
      return -1;
   }
   ast_log(LOG_DEBUG, "Removed %d from conference %d/%d\n", c->zfd, c->curconf.confmode, c->curconf.confno);
   memcpy(&c->curconf, &zi, sizeof(c->curconf));
   return 0;
}

static int isslavenative(struct zt_pvt *p, struct zt_pvt **out)
{
   int x;
   int useslavenative;
   struct zt_pvt *slave = NULL;
   /* Start out optimistic */
   useslavenative = 1;
   /* Update conference state in a stateless fashion */
   for (x=0;x<3;x++) {
      /* Any three-way calling makes slave native mode *definitely* out
         of the question */
      if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway)
         useslavenative = 0;
   }
   /* If we don't have any 3-way calls, check to see if we have
      precisely one slave */
   if (useslavenative) {
      for (x=0;x<MAX_SLAVES;x++) {
         if (p->slaves[x]) {
            if (slave) {
               /* Whoops already have a slave!  No 
                  slave native and stop right away */
               slave = NULL;
               useslavenative = 0;
               break;
            } else {
               /* We have one slave so far */
               slave = p->slaves[x];
            }
         }
      }
   }
   /* If no slave, slave native definitely out */
   if (!slave)
      useslavenative = 0;
   else if (slave->law != p->law) {
      useslavenative = 0;
      slave = NULL;
   }
   if (out)
      *out = slave;
   return useslavenative;
}

static int reset_conf(struct zt_pvt *p)
{
   ZT_CONFINFO zi;
   memset(&zi, 0, sizeof(zi));
   p->confno = -1;
   memset(&p->subs[SUB_REAL].curconf, 0, sizeof(p->subs[SUB_REAL].curconf));
   if (p->subs[SUB_REAL].zfd > -1) {
      if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &zi))
         ast_log(LOG_WARNING, "Failed to reset conferencing on channel %d!\n", p->channel);
   }
   return 0;
}

static int update_conf(struct zt_pvt *p)
{
   int needconf = 0;
   int x;
   int useslavenative;
   struct zt_pvt *slave = NULL;

   useslavenative = isslavenative(p, &slave);
   /* Start with the obvious, general stuff */
   for (x=0;x<3;x++) {
      /* Look for three way calls */
      if ((p->subs[x].zfd > -1) && p->subs[x].inthreeway) {
         conf_add(p, &p->subs[x], x, 0);
         needconf++;
      } else {
         conf_del(p, &p->subs[x], x);
      }
   }
   /* If we have a slave, add him to our conference now. or DAX
      if this is slave native */
   for (x=0;x<MAX_SLAVES;x++) {
      if (p->slaves[x]) {
         if (useslavenative)
            conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
         else {
            conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
            needconf++;
         }
      }
   }
   /* If we're supposed to be in there, do so now */
   if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
      if (useslavenative)
         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
      else {
         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
         needconf++;
      }
   }
   /* If we have a master, add ourselves to his conference */
   if (p->master) {
      if (isslavenative(p->master, NULL)) {
         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
      } else {
         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
      }
   }
   if (!needconf) {
      /* Nobody is left (or should be left) in our conference.  
         Kill it.  */
      p->confno = -1;
   }
   ast_log(LOG_DEBUG, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
   return 0;
}

static void zt_enable_ec(struct zt_pvt *p)
{
   int x;
   int res;
   if (!p)
      return;
   if (p->echocanon) {
      ast_log(LOG_DEBUG, "Echo cancellation already on\n");
      return;
   }
   if (p->digital) {
      ast_log(LOG_DEBUG, "Echo cancellation isn't required on digital connection\n");
      return;
   }
   if (p->echocancel) {
      if (p->sig == SIG_PRI) {
         x = 1;
         res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x);
         if (res)
            ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
      }
      x = p->echocancel;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
      if (res) 
         ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d\n", p->channel);
      else {
         p->echocanon = 1;
         ast_log(LOG_DEBUG, "Enabled echo cancellation on channel %d\n", p->channel);
      }
   } else
      ast_log(LOG_DEBUG, "No echo cancellation requested\n");
}

static void zt_train_ec(struct zt_pvt *p)
{
   int x;
   int res;
   if (p && p->echocancel && p->echotraining) {
      x = p->echotraining;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOTRAIN, &x);
      if (res) 
         ast_log(LOG_WARNING, "Unable to request echo training on channel %d\n", p->channel);
      else {
         ast_log(LOG_DEBUG, "Engaged echo training on channel %d\n", p->channel);
      }
   } else
      ast_log(LOG_DEBUG, "No echo training requested\n");
}

static void zt_disable_ec(struct zt_pvt *p)
{
   int x;
   int res;
   if (p->echocancel) {
      x = 0;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_ECHOCANCEL, &x);
      if (res) 
         ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d\n", p->channel);
      else
         ast_log(LOG_DEBUG, "disabled echo cancellation on channel %d\n", p->channel);
   }
   p->echocanon = 0;
}

static void fill_txgain(struct zt_gains *g, float gain, int law)
{
   int j;
   int k;
   float linear_gain = pow(10.0, gain / 20.0);

   switch (law) {
   case ZT_LAW_ALAW:
      for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
         if (gain) {
            k = (int) (((float) AST_ALAW(j)) * linear_gain);
            if (k > 32767) k = 32767;
            if (k < -32767) k = -32767;
            g->txgain[j] = AST_LIN2A(k);
         } else {
            g->txgain[j] = j;
         }
      }
      break;
   case ZT_LAW_MULAW:
      for (j = 0; j < (sizeof(g->txgain) / sizeof(g->txgain[0])); j++) {
         if (gain) {
            k = (int) (((float) AST_MULAW(j)) * linear_gain);
            if (k > 32767) k = 32767;
            if (k < -32767) k = -32767;
            g->txgain[j] = AST_LIN2MU(k);
         } else {
            g->txgain[j] = j;
         }
      }
      break;
   }
}

static void fill_rxgain(struct zt_gains *g, float gain, int law)
{
   int j;
   int k;
   float linear_gain = pow(10.0, gain / 20.0);

   switch (law) {
   case ZT_LAW_ALAW:
      for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
         if (gain) {
            k = (int) (((float) AST_ALAW(j)) * linear_gain);
            if (k > 32767) k = 32767;
            if (k < -32767) k = -32767;
            g->rxgain[j] = AST_LIN2A(k);
         } else {
            g->rxgain[j] = j;
         }
      }
      break;
   case ZT_LAW_MULAW:
      for (j = 0; j < (sizeof(g->rxgain) / sizeof(g->rxgain[0])); j++) {
         if (gain) {
            k = (int) (((float) AST_MULAW(j)) * linear_gain);
            if (k > 32767) k = 32767;
            if (k < -32767) k = -32767;
            g->rxgain[j] = AST_LIN2MU(k);
         } else {
            g->rxgain[j] = j;
         }
      }
      break;
   }
}

int set_actual_txgain(int fd, int chan, float gain, int law)
{
   struct zt_gains g;
   int res;

   memset(&g, 0, sizeof(g));
   g.chan = chan;
   res = ioctl(fd, ZT_GETGAINS, &g);
   if (res) {
      ast_log(LOG_DEBUG, "Failed to read gains: %s\n", strerror(errno));
      return res;
   }

   fill_txgain(&g, gain, law);

   return ioctl(fd, ZT_SETGAINS, &g);
}

int set_actual_rxgain(int fd, int chan, float gain, int law)
{
   struct zt_gains g;
   int res;

   memset(&g, 0, sizeof(g));
   g.chan = chan;
   res = ioctl(fd, ZT_GETGAINS, &g);
   if (res) {
      ast_log(LOG_DEBUG, "Failed to read gains: %s\n", strerror(errno));
      return res;
   }

   fill_rxgain(&g, gain, law);

   return ioctl(fd, ZT_SETGAINS, &g);
}

int set_actual_gain(int fd, int chan, float rxgain, float txgain, int law)
{
   return set_actual_txgain(fd, chan, txgain, law) | set_actual_rxgain(fd, chan, rxgain, law);
}

static int bump_gains(struct zt_pvt *p)
{
   int res;

   /* Bump receive gain by 5.0db */
   res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain + 5.0, p->txgain, p->law);
   if (res) {
      ast_log(LOG_WARNING, "Unable to bump gain: %s\n", strerror(errno));
      return -1;
   }

   return 0;
}

static int restore_gains(struct zt_pvt *p)
{
   int res;

   res = set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);
   if (res) {
      ast_log(LOG_WARNING, "Unable to restore gains: %s\n", strerror(errno));
      return -1;
   }

   return 0;
}

static inline int zt_set_hook(int fd, int hs)
{
   int x, res;

   x = hs;
   res = ioctl(fd, ZT_HOOK, &x);

   if (res < 0) {
      if (errno == EINPROGRESS)
         return 0;
      ast_log(LOG_WARNING, "zt hook failed: %s\n", strerror(errno));
   }

   return res;
}

static inline int zt_confmute(struct zt_pvt *p, int muted)
{
   int x, y, res;
   x = muted;
   if (p->sig == SIG_PRI) {
      y = 1;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &y);
      if (res)
         ast_log(LOG_WARNING, "Unable to set audio mode on '%d'\n", p->channel);
   }
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_CONFMUTE, &x);
   if (res < 0) 
      ast_log(LOG_WARNING, "zt confmute(%d) failed on channel %d: %s\n", muted, p->channel, strerror(errno));
   return res;
}

static int save_conference(struct zt_pvt *p)
{
   struct zt_confinfo c;
   int res;
   if (p->saveconf.confmode) {
      ast_log(LOG_WARNING, "Can't save conference -- already in use\n");
      return -1;
   }
   p->saveconf.chan = 0;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &p->saveconf);
   if (res) {
      ast_log(LOG_WARNING, "Unable to get conference info: %s\n", strerror(errno));
      p->saveconf.confmode = 0;
      return -1;
   }
   c.chan = 0;
   c.confno = 0;
   c.confmode = ZT_CONF_NORMAL;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &c);
   if (res) {
      ast_log(LOG_WARNING, "Unable to set conference info: %s\n", strerror(errno));
      return -1;
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Disabled conferencing\n");
   return 0;
}

static int restore_conference(struct zt_pvt *p)
{
   int res;
   if (p->saveconf.confmode) {
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETCONF, &p->saveconf);
      p->saveconf.confmode = 0;
      if (res) {
         ast_log(LOG_WARNING, "Unable to restore conference info: %s\n", strerror(errno));
         return -1;
      }
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Restored conferencing\n");
   return 0;
}

static int send_callerid(struct zt_pvt *p);

int send_cwcidspill(struct zt_pvt *p)
{
   p->callwaitcas = 0;
   p->cidcwexpire = 0;
   p->cidspill = malloc(MAX_CALLERID_SIZE);
   if (p->cidspill) {
      memset(p->cidspill, 0x7f, MAX_CALLERID_SIZE);
      p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, p->callwait_name, p->callwait_num, AST_LAW(p));
      /* Make sure we account for the end */
      p->cidlen += READ_SIZE * 4;
      p->cidpos = 0;
      send_callerid(p);
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "CPE supports Call Waiting Caller*ID.  Sending '%s/%s'\n", p->callwait_name, p->callwait_num);
   } else return -1;
   return 0;
}

static int has_voicemail(struct zt_pvt *p)
{

   return ast_app_has_voicemail(p->mailbox, NULL);
}

static int send_callerid(struct zt_pvt *p)
{
   /* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */
   int res;
   /* Take out of linear mode if necessary */
   if (p->subs[SUB_REAL].linear) {
      p->subs[SUB_REAL].linear = 0;
      zt_setlinear(p->subs[SUB_REAL].zfd, 0);
   }
   while(p->cidpos < p->cidlen) {
      res = write(p->subs[SUB_REAL].zfd, p->cidspill + p->cidpos, p->cidlen - p->cidpos);
      if (res < 0) {
         if (errno == EAGAIN)
            return 0;
         else {
            ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
            return -1;
         }
      }
      if (!res)
         return 0;
      p->cidpos += res;
   }
   free(p->cidspill);
   p->cidspill = NULL;
   if (p->callwaitcas) {
      /* Wait for CID/CW to expire */
      p->cidcwexpire = CIDCW_EXPIRE_SAMPLES;
   } else
      restore_conference(p);
   return 0;
}

static int zt_callwait(struct ast_channel *ast)
{
   struct zt_pvt *p = ast->tech_pvt;
   p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
   if (p->cidspill) {
      ast_log(LOG_WARNING, "Spill already exists?!?\n");
      free(p->cidspill);
   }
   p->cidspill = malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4);
   if (p->cidspill) {
      save_conference(p);
      /* Silence */
      memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
      if (!p->callwaitrings && p->callwaitingcallerid) {
         ast_gen_cas(p->cidspill, 1, 2400 + 680, AST_LAW(p));
         p->callwaitcas = 1;
         p->cidlen = 2400 + 680 + READ_SIZE * 4;
      } else {
         ast_gen_cas(p->cidspill, 1, 2400, AST_LAW(p));
         p->callwaitcas = 0;
         p->cidlen = 2400 + READ_SIZE * 4;
      }
      p->cidpos = 0;
      send_callerid(p);
   } else {
      ast_log(LOG_WARNING, "Unable to create SAS/CAS spill\n");
      return -1;
   }
   return 0;
}

static int zt_call(struct ast_channel *ast, char *rdest, int timeout)
{
   struct zt_pvt *p = ast->tech_pvt;
   int x, res, index;
   char *c, *n, *l;
#ifdef ZAPATA_PRI
   char *s=NULL;
#endif
   char dest[256]; /* must be same length as p->dialdest */
   ast_mutex_lock(&p->lock);
   ast_copy_string(dest, rdest, sizeof(dest));
   ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));
   if ((ast->_state == AST_STATE_BUSY)) {
      p->subs[SUB_REAL].needbusy = 1;
      ast_mutex_unlock(&p->lock);
      return 0;
   }
   if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
      ast_log(LOG_WARNING, "zt_call called on %s, neither down nor reserved\n", ast->name);
      ast_mutex_unlock(&p->lock);
      return -1;
   }
   p->dialednone = 0;
   if (p->radio)  /* if a radio channel, up immediately */
   {
      /* Special pseudo -- automatically up */
      ast_setstate(ast, AST_STATE_UP); 
      ast_mutex_unlock(&p->lock);
      return 0;
   }
   x = ZT_FLUSH_READ | ZT_FLUSH_WRITE;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_FLUSH, &x);
   if (res)
      ast_log(LOG_WARNING, "Unable to flush input on channel %d\n", p->channel);
   p->outgoing = 1;

   set_actual_gain(p->subs[SUB_REAL].zfd, 0, p->rxgain, p->txgain, p->law);

   switch(p->sig) {
   case SIG_FXOLS:
   case SIG_FXOGS:
   case SIG_FXOKS:
      if (p->owner == ast) {
         /* Normal ring, on hook */
         
         /* Don't send audio while on hook, until the call is answered */
         p->dialing = 1;
         if (p->use_callerid) {
            /* Generate the Caller-ID spill if desired */
            if (p->cidspill) {
               ast_log(LOG_WARNING, "cidspill already exists??\n");
               free(p->cidspill);
            }
            p->cidspill = malloc(MAX_CALLERID_SIZE);
            p->callwaitcas = 0;
            if (p->cidspill) {
               p->cidlen = ast_callerid_generate(p->cidspill, ast->cid.cid_name, ast->cid.cid_num, AST_LAW(p));
               p->cidpos = 0;
               send_callerid(p);
            } else
               ast_log(LOG_WARNING, "Unable to generate CallerID spill\n");
         }
         /* Choose proper cadence */
         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
            if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, &cadences[p->distinctivering-1]))
               ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s'\n", p->distinctivering, ast->name);
            p->cidrings = cidrings[p->distinctivering - 1];
         } else {
            if (ioctl(p->subs[SUB_REAL].zfd, ZT_SETCADENCE, NULL))
               ast_log(LOG_WARNING, "Unable to reset default ring on '%s'\n", ast->name);
            p->cidrings = p->sendcalleridafter;
         }


         /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */
         c = strchr(dest, '/');
         if (c)
            c++;
         if (c && (strlen(c) < p->stripmsd)) {
            ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
            c = NULL;
         }
         if (c) {
            p->dop.op = ZT_DIAL_OP_REPLACE;
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c);
            ast_log(LOG_DEBUG, "FXO: setup deferred dialstring: %s\n", c);
         } else {
            p->dop.dialstr[0] = '\0';
         }
         x = ZT_RING;
         if (ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x) && (errno != EINPROGRESS)) {
            ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
            ast_mutex_unlock(&p->lock);
            return -1;
         }
         p->dialing = 1;
      } else {
         /* Call waiting call */
         p->callwaitrings = 0;
         if (ast->cid.cid_num)
            ast_copy_string(p->callwait_num, ast->cid.cid_num, sizeof(p->callwait_num));
         else
            p->callwait_num[0] = '\0';
         if (ast->cid.cid_name)
            ast_copy_string(p->callwait_name, ast->cid.cid_name, sizeof(p->callwait_name));
         else
            p->callwait_name[0] = '\0';
         /* Call waiting tone instead */
         if (zt_callwait(ast)) {
            ast_mutex_unlock(&p->lock);
            return -1;
         }
         /* Make ring-back */
         if (tone_zone_play_tone(p->subs[SUB_CALLWAIT].zfd, ZT_TONE_RINGTONE))
            ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast->name);
            
      }
      n = ast->cid.cid_name;
      l = ast->cid.cid_num;
      if (l)
         ast_copy_string(p->lastcid_num, l, sizeof(p->lastcid_num));
      else
         p->lastcid_num[0] = '\0';
      if (n)
         ast_copy_string(p->lastcid_name, n, sizeof(p->lastcid_name));
      else
         p->lastcid_name[0] = '\0';
      ast_setstate(ast, AST_STATE_RINGING);
      index = zt_get_index(ast, p, 0);
      if (index > -1) {
         p->subs[index].needringing = 1;
      }
      break;
   case SIG_FXSLS:
   case SIG_FXSGS:
   case SIG_FXSKS:
   case SIG_EMWINK:
   case SIG_EM:
   case SIG_EM_E1:
   case SIG_FEATD:
   case SIG_FEATDMF:
   case SIG_E911:
   case SIG_FEATB:
   case SIG_SFWINK:
   case SIG_SF:
   case SIG_SF_FEATD:
   case SIG_SF_FEATDMF:
   case SIG_FEATDMF_TA:
   case SIG_SF_FEATB:
      c = strchr(dest, '/');
      if (c)
         c++;
      else
         c = "";
      if (strlen(c) < p->stripmsd) {
         ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
         ast_mutex_unlock(&p->lock);
         return -1;
      }
#ifdef ZAPATA_PRI
      /* Start the trunk, if not GR-303 */
      if (!p->pri) {
#endif
         x = ZT_START;
         res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
         if (res < 0) {
            if (errno != EINPROGRESS) {
               ast_log(LOG_WARNING, "Unable to start channel: %s\n", strerror(errno));
               ast_mutex_unlock(&p->lock);
               return -1;
            }
         }
#ifdef ZAPATA_PRI
      }
#endif
      ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
      p->dop.op = ZT_DIAL_OP_REPLACE;

      c += p->stripmsd;

      switch (p->sig) {
      case SIG_FEATD:
         l = ast->cid.cid_num;
         if (l) 
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c);
         else
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c);
         break;
      case SIG_FEATDMF:
         l = ast->cid.cid_num;
         if (l) 
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c);
         else
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c);
         break;
      case SIG_FEATDMF_TA:
      {
         char *cic = NULL, *ozz = NULL;

         /* If you have to go through a Tandem Access point you need to use this */
         ozz = pbx_builtin_getvar_helper(p->owner, "FEATDMF_OZZ");
         if (!ozz)
            ozz = defaultozz;
         cic = pbx_builtin_getvar_helper(p->owner, "FEATDMF_CIC");
         if (!cic)
            cic = defaultcic;
         if (!ozz || !cic) {
            ast_log(LOG_WARNING, "Unable to dial channel of type feature group D MF tandem access without CIC or OZZ set\n");
            ast_mutex_unlock(&p->lock);
            return -1;
         }
         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s%s#", ozz, cic);
         snprintf(p->finaldial, sizeof(p->finaldial), "M*%s#", c);
         p->whichwink = 0;
      }
         break;
      case SIG_E911:
         ast_copy_string(p->dop.dialstr, "M*911#", sizeof(p->dop.dialstr));
         break;
      case SIG_FEATB:
         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c);
         break;
      default:
         if (p->pulse)
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%sw", c);
         else
            snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c);
         break;
      }

      if (p->echotraining && (strlen(p->dop.dialstr) > 4)) {
         memset(p->echorest, 'w', sizeof(p->echorest) - 1);
         strcpy(p->echorest + (p->echotraining / 400) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
         p->echorest[sizeof(p->echorest) - 1] = '\0';
         p->echobreak = 1;
         p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
      } else
         p->echobreak = 0;
      if (!res) {
         if (ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop)) {
            x = ZT_ONHOOK;
            ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
            ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
            ast_mutex_unlock(&p->lock);
            return -1;
         }
      } else
         ast_log(LOG_DEBUG, "Deferring dialing...\n");
      p->dialing = 1;
      if (ast_strlen_zero(c))
         p->dialednone = 1;
      ast_setstate(ast, AST_STATE_DIALING);
      break;
   case 0:
      /* Special pseudo -- automatically up*/
      ast_setstate(ast, AST_STATE_UP);
      break;      
   case SIG_PRI:
      /* We'll get it in a moment -- but use dialdest to store pre-setup_ack digits */
      p->dialdest[0] = '\0';
      break;
   default:
      ast_log(LOG_DEBUG, "not yet implemented\n");
      ast_mutex_unlock(&p->lock);
      return -1;
   }
#ifdef ZAPATA_PRI
   if (p->pri) {
      struct pri_sr *sr;
#ifdef SUPPORT_USERUSER
      char *useruser;
#endif
      int pridialplan;
      int dp_strip;
      int prilocaldialplan;
      int ldp_strip;
      int exclusive;

      c = strchr(dest, '/');
      if (c)
         c++;
      else
         c = dest;
      if (!p->hidecallerid) {
         l = ast->cid.cid_num;
         n = ast->cid.cid_name;
      } else {
         l = NULL;
         n = NULL;
      }
      if (strlen(c) < p->stripmsd) {
         ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
         ast_mutex_unlock(&p->lock);
         return -1;
      }
      if (p->sig != SIG_FXSKS) {
         p->dop.op = ZT_DIAL_OP_REPLACE;
         s = strchr(c + p->stripmsd, 'w');
         if (s) {
            if (strlen(s) > 1)
               snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%s", s);
            else
               p->dop.dialstr[0] = '\0';
            *s = '\0';
         } else {
            p->dop.dialstr[0] = '\0';
         }
      }
      if (pri_grab(p, p->pri)) {
         ast_log(LOG_WARNING, "Failed to grab PRI!\n");
         ast_mutex_unlock(&p->lock);
         return -1;
      }
      if (!(p->call = pri_new_call(p->pri->pri))) {
         ast_log(LOG_WARNING, "Unable to create call on channel %d\n", p->channel);
         pri_rel(p->pri);
         ast_mutex_unlock(&p->lock);
         return -1;
      }
      if (!(sr = pri_sr_new())) {
         ast_log(LOG_WARNING, "Failed to allocate setup request channel %d\n", p->channel);
         pri_rel(p->pri);
         ast_mutex_unlock(&p->lock);
      }
      if (p->bearer || (p->sig == SIG_FXSKS)) {
         if (p->bearer) {
            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);
            p->bearer->call = p->call;
         } else
            ast_log(LOG_DEBUG, "I'm being setup with no bearer right now...\n");
         pri_set_crv(p->pri->pri, p->call, p->channel, 0);
      }
      p->digital = IS_DIGITAL(ast->transfercapability);
      /* Add support for exclusive override */
      if (p->priexclusive)
         exclusive = 1;
      else {
      /* otherwise, traditional behavior */
         if (p->pri->nodetype == PRI_NETWORK)
            exclusive = 0;
         else
            exclusive = 1;
      }
      
      pri_sr_set_channel(sr, p->bearer ? PVT_TO_CHANNEL(p->bearer) : PVT_TO_CHANNEL(p), exclusive, 1);
      pri_sr_set_bearer(sr, p->digital ? PRI_TRANS_CAP_DIGITAL : ast->transfercapability, 
               (p->digital ? -1 : 
                  ((p->law == ZT_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW)));
      if (p->pri->facilityenable)
         pri_facility_enable(p->pri->pri);

      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Requested transfer capability: 0x%.2x - %s\n", ast->transfercapability, ast_transfercapability2str(ast->transfercapability));
      dp_strip = 0;
      pridialplan = p->pri->dialplan - 1;
      if (pridialplan == -2) { /* compute dynamically */
         if (strncmp(c + p->stripmsd, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
            dp_strip = strlen(p->pri->internationalprefix);
            pridialplan = PRI_INTERNATIONAL_ISDN;
         } else if (strncmp(c + p->stripmsd, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
            dp_strip = strlen(p->pri->nationalprefix);
            pridialplan = PRI_NATIONAL_ISDN;
         } else {
            pridialplan = PRI_LOCAL_ISDN;
         }
      }
      pri_sr_set_called(sr, c + p->stripmsd + dp_strip, pridialplan,  s ? 1 : 0);

      ldp_strip = 0;
      prilocaldialplan = p->pri->localdialplan - 1;
      if ((l != NULL) && (prilocaldialplan == -2)) { /* compute dynamically */
         if (strncmp(l, p->pri->internationalprefix, strlen(p->pri->internationalprefix)) == 0) {
            ldp_strip = strlen(p->pri->internationalprefix);
            prilocaldialplan = PRI_INTERNATIONAL_ISDN;
         } else if (strncmp(l, p->pri->nationalprefix, strlen(p->pri->nationalprefix)) == 0) {
            ldp_strip = strlen(p->pri->nationalprefix);
            prilocaldialplan = PRI_NATIONAL_ISDN;
         } else {
            prilocaldialplan = PRI_LOCAL_ISDN;
         }
      }
      pri_sr_set_caller(sr, l ? (l + ldp_strip) : NULL, n, prilocaldialplan,
              p->use_callingpres ? ast->cid.cid_pres : (l ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_NUMBER_NOT_AVAILABLE));
      pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, PRI_REDIR_UNCONDITIONAL);

#ifdef SUPPORT_USERUSER
      /* User-user info */
      useruser = pbx_builtin_getvar_helper(p->owner, "USERUSERINFO");

      if (useruser)
         pri_sr_set_useruser(sr, useruser);
#endif

      if (pri_setup(p->pri->pri, p->call,  sr)) {
         ast_log(LOG_WARNING, "Unable to setup call to %s (using %s)\n", 
                  c + p->stripmsd + dp_strip, dialplan2str(p->pri->dialplan));
         pri_rel(p->pri);
         ast_mutex_unlock(&p->lock);
         pri_sr_free(sr);
         return -1;
      }
      pri_sr_free(sr);
      ast_setstate(ast, AST_STATE_DIALING);
      pri_rel(p->pri);
   }
#endif      
   ast_mutex_unlock(&p->lock);
   return 0;
}

static void destroy_zt_pvt(struct zt_pvt **pvt)
{
   struct zt_pvt *p = *pvt;
   /* Remove channel from the list */
   if(p->prev)
      p->prev->next = p->next;
   if(p->next)
      p->next->prev = p->prev;
   ast_mutex_destroy(&p->lock);
   free(p);
   *pvt = NULL;
}

static int destroy_channel(struct zt_pvt *prev, struct zt_pvt *cur, int now)
{
   int owned = 0;
   int i = 0;

   if (!now) {
      if (cur->owner) {
         owned = 1;
      }

      for (i = 0; i < 3; i++) {
         if (cur->subs[i].owner) {
            owned = 1;
         }
      }
      if (!owned) {
         if (prev) {
            prev->next = cur->next;
            if (prev->next)
               prev->next->prev = prev;
            else
               ifend = prev;
         } else {
            iflist = cur->next;
            if (iflist)
               iflist->prev = NULL;
            else
               ifend = NULL;
         }
         if (cur->subs[SUB_REAL].zfd > -1) {
            zt_close(cur->subs[SUB_REAL].zfd);
         }
         destroy_zt_pvt(&cur);
      }
   } else {
      if (prev) {
         prev->next = cur->next;
         if (prev->next)
            prev->next->prev = prev;
         else
            ifend = prev;
      } else {
         iflist = cur->next;
         if (iflist)
            iflist->prev = NULL;
         else
            ifend = NULL;
      }
      if (cur->subs[SUB_REAL].zfd > -1) {
         zt_close(cur->subs[SUB_REAL].zfd);
      }
      destroy_zt_pvt(&cur);
   }
   return 0;
}

#ifdef ZAPATA_PRI
int pri_is_up(struct zt_pri *pri)
{
   int x;
   for (x=0;x<NUM_DCHANS;x++) {
      if (pri->dchanavail[x] == DCHAN_AVAILABLE)
         return 1;
   }
   return 0;
}

int pri_assign_bearer(struct zt_pvt *crv, struct zt_pri *pri, struct zt_pvt *bearer)
{
   bearer->owner = &inuse;
   bearer->realcall = crv;
   crv->subs[SUB_REAL].zfd = bearer->subs[SUB_REAL].zfd;
   if (crv->subs[SUB_REAL].owner)
      crv->subs[SUB_REAL].owner->fds[0] = crv->subs[SUB_REAL].zfd;
   crv->bearer = bearer;
   crv->call = bearer->call;
   crv->pri = pri;
   return 0;
}

static char *pri_order(int level)
{
   switch(level) {
   case 0:
      return "Primary";
   case 1:
      return "Secondary";
   case 2:
      return "Tertiary";
   case 3:
      return "Quaternary";
   default:
      return "<Unknown>";
   }     
}

/* Returns fd of the active dchan */
int pri_active_dchan_fd(struct zt_pri *pri)
{
   int x = -1;

   for (x = 0; x < NUM_DCHANS; x++) {
      if ((pri->dchans[x] == pri->pri))
         break;
   }

   return pri->fds[x];
}

int pri_find_dchan(struct zt_pri *pri)
{
   int oldslot = -1;
   struct pri *old;
   int newslot = -1;
   int x;
   old = pri->pri;
   for(x=0;x<NUM_DCHANS;x++) {
      if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
         newslot = x;
      if (pri->dchans[x] == old) {
         oldslot = x;
      }
   }
   if (newslot < 0) {
      newslot = 0;
      ast_log(LOG_WARNING, "No D-channels available!  Using Primary channel %d as D-channel anyway!\n",
         pri->dchannels[newslot]);
   }
   if (old && (oldslot != newslot))
      ast_log(LOG_NOTICE, "Switching from from d-channel %d to channel %d!\n",
         pri->dchannels[oldslot], pri->dchannels[newslot]);
   pri->pri = pri->dchans[newslot];
   return 0;
}
#endif

static int zt_hangup(struct ast_channel *ast)
{
   int res;
   int index,x, law;
   /*static int restore_gains(struct zt_pvt *p);*/
   struct zt_pvt *p = ast->tech_pvt;
   struct zt_pvt *tmp = NULL;
   struct zt_pvt *prev = NULL;
   ZT_PARAMS par;

   if (option_debug)
      ast_log(LOG_DEBUG, "zt_hangup(%s)\n", ast->name);
   if (!ast->tech_pvt) {
      ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
      return 0;
   }
   
   ast_mutex_lock(&p->lock);
   
   index = zt_get_index(ast, p, 1);

   if (p->sig == SIG_PRI) {
      x = 1;
      ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
   }

   x = 0;
   zt_confmute(p, 0);
   restore_gains(p);
   if (p->origcid_num) {
      ast_copy_string(p->cid_num, p->origcid_num, sizeof(p->cid_num));
      free(p->origcid_num);
      p->origcid_num = NULL;
   }  
   if (p->origcid_name) {
      ast_copy_string(p->cid_name, p->origcid_name, sizeof(p->cid_name));
      free(p->origcid_name);
      p->origcid_name = NULL;
   }  
   if (p->dsp)
      ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);
   if (p->exten)
      p->exten[0] = '\0';

   ast_log(LOG_DEBUG, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
      p->channel, index, p->subs[SUB_REAL].zfd, p->subs[SUB_CALLWAIT].zfd, p->subs[SUB_THREEWAY].zfd);
   p->ignoredtmf = 0;
   
   if (index > -1) {
      /* Real channel, do some fixup */
      p->subs[index].owner = NULL;
      p->subs[index].needanswer = 0;
      p->subs[index].needflash = 0;
      p->subs[index].needringing = 0;
      p->subs[index].needbusy = 0;
      p->subs[index].needcongestion = 0;
      p->subs[index].linear = 0;
      p->subs[index].needcallerid = 0;
      p->polarity = POLARITY_IDLE;
      zt_setlinear(p->subs[index].zfd, 0);
      if (index == SUB_REAL) {
         if ((p->subs[SUB_CALLWAIT].zfd > -1) && (p->subs[SUB_THREEWAY].zfd > -1)) {
            ast_log(LOG_DEBUG, "Normal call hung up with both three way call and a call waiting call in place?\n");
            if (p->subs[SUB_CALLWAIT].inthreeway) {
               /* We had flipped over to answer a callwait and now it's gone */
               ast_log(LOG_DEBUG, "We were flipped over to the callwait, moving back and unowning.\n");
               /* Move to the call-wait, but un-own us until they flip back. */
               swap_subs(p, SUB_CALLWAIT, SUB_REAL);
               unalloc_sub(p, SUB_CALLWAIT);
               p->owner = NULL;
            } else {
               /* The three way hung up, but we still have a call wait */
               ast_log(LOG_DEBUG, "We were in the threeway and have a callwait still.  Ditching the threeway.\n");
               swap_subs(p, SUB_THREEWAY, SUB_REAL);
               unalloc_sub(p, SUB_THREEWAY);
               if (p->subs[SUB_REAL].inthreeway) {
                  /* This was part of a three way call.  Immediately make way for
                     another call */
                  ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
                  p->owner = p->subs[SUB_REAL].owner;
               } else {
                  /* This call hasn't been completed yet...  Set owner to NULL */
                  ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
                  p->owner = NULL;
               }
               p->subs[SUB_REAL].inthreeway = 0;
            }
         } else if (p->subs[SUB_CALLWAIT].zfd > -1) {
            /* Move to the call-wait and switch back to them. */
            swap_subs(p, SUB_CALLWAIT, SUB_REAL);
            unalloc_sub(p, SUB_CALLWAIT);
            p->owner = p->subs[SUB_REAL].owner;
            if (p->owner->_state != AST_STATE_UP)
               p->subs[SUB_REAL].needanswer = 1;
            if (ast_bridged_channel(p->subs[SUB_REAL].owner))
               ast_moh_stop(ast_bridged_channel(p->subs[SUB_REAL].owner));
         } else if (p->subs[SUB_THREEWAY].zfd > -1) {
            swap_subs(p, SUB_THREEWAY, SUB_REAL);
            unalloc_sub(p, SUB_THREEWAY);
            if (p->subs[SUB_REAL].inthreeway) {
               /* This was part of a three way call.  Immediately make way for
                  another call */
               ast_log(LOG_DEBUG, "Call was complete, setting owner to former third call\n");
               p->owner = p->subs[SUB_REAL].owner;
            } else {
               /* This call hasn't been completed yet...  Set owner to NULL */
               ast_log(LOG_DEBUG, "Call was incomplete, setting owner to NULL\n");
               p->owner = NULL;
            }
            p->subs[SUB_REAL].inthreeway = 0;
         }
      } else if (index == SUB_CALLWAIT) {
         /* Ditch the holding callwait call, and immediately make it availabe */
         if (p->subs[SUB_CALLWAIT].inthreeway) {
            /* This is actually part of a three way, placed on hold.  Place the third part
               on music on hold now */
            if (p->subs[SUB_THREEWAY].owner && ast_bridged_channel(p->subs[SUB_THREEWAY].owner))
               ast_moh_start(ast_bridged_channel(p->subs[SUB_THREEWAY].owner), NULL);
            p->subs[SUB_THREEWAY].inthreeway = 0;
            /* Make it the call wait now */
            swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
            unalloc_sub(p, SUB_THREEWAY);
         } else
            unalloc_sub(p, SUB_CALLWAIT);
      } else if (index == SUB_THREEWAY) {
         if (p->subs[SUB_CALLWAIT].inthreeway) {
            /* The other party of the three way call is currently in a call-wait state.
               Start music on hold for them, and take the main guy out of the third call */
            if (p->subs[SUB_CALLWAIT].owner && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner))
               ast_moh_start(ast_bridged_channel(p->subs[SUB_CALLWAIT].owner), NULL);
            p->subs[SUB_CALLWAIT].inthreeway = 0;
         }
         p->subs[SUB_REAL].inthreeway = 0;
         /* If this was part of a three way call index, let us make
            another three way call */
         unalloc_sub(p, SUB_THREEWAY);
      } else {
         /* This wasn't any sort of call, but how are we an index? */
         ast_log(LOG_WARNING, "Index found but not any type of call?\n");
      }
   }


   if (!p->subs[SUB_REAL].owner && !p->subs[SUB_CALLWAIT].owner && !p->subs[SUB_THREEWAY].owner) {
      p->owner = NULL;
      p->ringt = 0;
      p->distinctivering = 0;
      p->confirmanswer = 0;
      p->cidrings = 1;
      p->outgoing = 0;
      p->digital = 0;
      p->faxhandled = 0;
      p->pulsedial = 0;
      p->onhooktime = time(NULL);
#ifdef ZAPATA_PRI
      p->proceeding = 0;
      p->progress = 0;
      p->alerting = 0;
      p->setup_ack = 0;
#endif      
      if (p->dsp) {
         ast_dsp_free(p->dsp);
         p->dsp = NULL;
      }

      law = ZT_LAW_DEFAULT;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_SETLAW, &law);
      if (res < 0) 
         ast_log(LOG_WARNING, "Unable to set law on channel %d to default\n", p->channel);
      /* Perform low level hangup if no owner left */
#ifdef ZAPATA_PRI
      if (p->pri) {
#ifdef SUPPORT_USERUSER
         char *useruser = pbx_builtin_getvar_helper(ast,"USERUSERINFO");
#endif

         /* Make sure we have a call (or REALLY have a call in the case of a PRI) */
         if (p->call && (!p->bearer || (p->bearer->call == p->call))) {
            if (!pri_grab(p, p->pri)) {
               if (p->alreadyhungup) {
                  ast_log(LOG_DEBUG, "Already hungup...  Calling hangup once, and clearing call\n");

#ifdef SUPPORT_USERUSER
                  pri_call_set_useruser(p->call, useruser);
#endif

                  pri_hangup(p->pri->pri, p->call, -1);
                  p->call = NULL;
                  if (p->bearer) 
                     p->bearer->call = NULL;
               } else {
                  char *cause = pbx_builtin_getvar_helper(ast,"PRI_CAUSE");
                  int icause = ast->hangupcause ? ast->hangupcause : -1;
                  ast_log(LOG_DEBUG, "Not yet hungup...  Calling hangup once with icause, and clearing call\n");

#ifdef SUPPORT_USERUSER
                  pri_call_set_useruser(p->call, useruser);
#endif

                  p->alreadyhungup = 1;
                  if (p->bearer)
                     p->bearer->alreadyhungup = 1;
                  if (cause) {
                     if (atoi(cause))
                        icause = atoi(cause);
                  }
                  pri_hangup(p->pri->pri, p->call, icause);
               }
               if (res < 0) 
                  ast_log(LOG_WARNING, "pri_disconnect failed\n");
               pri_rel(p->pri);        
            } else {
               ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
               res = -1;
            }
         } else {
            if (p->bearer)
               ast_log(LOG_DEBUG, "Bearer call is %p, while ours is still %p\n", p->bearer->call, p->call);
            p->call = NULL;
            res = 0;
         }
      }
#endif
#ifdef ZAPATA_R2
      if (p->sig == SIG_R2) {
         if (p->hasr2call) {
            mfcr2_DropCall(p->r2, NULL, UC_NORMAL_CLEARING);
            p->hasr2call = 0;
            res = 0;
         } else
            res = 0;

      }
#endif
      if (p->sig && (p->sig != SIG_PRI) && (p->sig != SIG_R2))
         res = zt_set_hook(p->subs[SUB_REAL].zfd, ZT_ONHOOK);
      if (res < 0) {
         ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name);
      }
      switch(p->sig) {
      case SIG_FXOGS:
      case SIG_FXOLS:
      case SIG_FXOKS:
         res = ioctl(p->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &par);
         if (!res) {
#if 0
            ast_log(LOG_DEBUG, "Hanging up channel %d, offhook = %d\n", p->channel, par.rxisoffhook);
#endif
            /* If they're off hook, try playing congestion */
            if ((par.rxisoffhook) && (!p->radio))
               tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_CONGESTION);
            else
               tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
         }
         break;
      case SIG_FXSGS:
      case SIG_FXSLS:
      case SIG_FXSKS:
         /* Make sure we're not made available for at least two seconds assuming
            we were actually used for an inbound or outbound call. */
         if (ast->_state != AST_STATE_RESERVED) {
            time(&p->guardtime);
            p->guardtime += 2;
         }
         break;
      default:
         tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
      }
      if (p->cidspill)
         free(p->cidspill);
      if (p->sig)
         zt_disable_ec(p);
      x = 0;
      ast_channel_setoption(ast,AST_OPTION_TONE_VERIFY,&x,sizeof(char),0);
      ast_channel_setoption(ast,AST_OPTION_TDD,&x,sizeof(char),0);
      p->didtdd = 0;
      p->cidspill = NULL;
      p->callwaitcas = 0;
      p->callwaiting = p->permcallwaiting;
      p->hidecallerid = p->permhidecallerid;
      p->dialing = 0;
      p->rdnis[0] = '\0';
      update_conf(p);
      reset_conf(p);
      /* Restore data mode */
      if (p->sig == SIG_PRI) {
         x = 0;
         ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
      }
#ifdef ZAPATA_PRI
      if (p->bearer) {
         ast_log(LOG_DEBUG, "Freeing up bearer channel %d\n", p->bearer->channel);
         /* Free up the bearer channel as well, and
            don't use its file descriptor anymore */
         update_conf(p->bearer);
         reset_conf(p->bearer);
         p->bearer->owner = NULL;
         p->bearer->realcall = NULL;
         p->bearer = NULL;
         p->subs[SUB_REAL].zfd = -1;
         p->pri = NULL;
      }
#endif
      restart_monitor();
   }


   p->callwaitingrepeat = 0;
   p->cidcwexpire = 0;
   ast->tech_pvt = NULL;
   ast_mutex_unlock(&p->lock);
   ast_mutex_lock(&usecnt_lock);
   usecnt--;
   if (usecnt < 0) 
      ast_log(LOG_WARNING, "Usecnt < 0???\n");
   ast_mutex_unlock(&usecnt_lock);
   ast_update_use_count();
   if (option_verbose > 2) 
      ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);

   ast_mutex_lock(&iflock);
   tmp = iflist;
   prev = NULL;
   if (p->destroy) {
      while (tmp) {
         if (tmp == p) {
            destroy_channel(prev, tmp, 0);
            break;
         } else {
            prev = tmp;
            tmp = tmp->next;
         }
      }
   }
   ast_mutex_unlock(&iflock);
   return 0;
}

static int zt_answer(struct ast_channel *ast)
{
   struct zt_pvt *p = ast->tech_pvt;
   int res=0;
   int index;
   int oldstate = ast->_state;
   ast_setstate(ast, AST_STATE_UP);
   ast_mutex_lock(&p->lock);
   index = zt_get_index(ast, p, 0);
   if (index < 0)
      index = SUB_REAL;
   /* nothing to do if a radio channel */
   if (p->radio) {
      ast_mutex_unlock(&p->lock);
      return 0;
   }
   switch(p->sig) {
   case SIG_FXSLS:
   case SIG_FXSGS:
   case SIG_FXSKS:
      p->ringt = 0;
      /* Fall through */
   case SIG_EM:
   case SIG_EM_E1:
   case SIG_EMWINK:
   case SIG_FEATD:
   case SIG_FEATDMF:
   case SIG_E911:
   case SIG_FEATB:
   case SIG_SF:
   case SIG_SFWINK:
   case SIG_SF_FEATD:
   case SIG_SF_FEATDMF:
   case SIG_SF_FEATB:
   case SIG_FXOLS:
   case SIG_FXOGS:
   case SIG_FXOKS:
      /* Pick up the line */
      ast_log(LOG_DEBUG, "Took %s off hook\n", ast->name);
      if(p->hanguponpolarityswitch) {
         gettimeofday(&p->polaritydelaytv, NULL);
      }
      res =  zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
      tone_zone_play_tone(p->subs[index].zfd, -1);
      p->dialing = 0;
      if ((index == SUB_REAL) && p->subs[SUB_THREEWAY].inthreeway) {
         if (oldstate == AST_STATE_RINGING) {
            ast_log(LOG_DEBUG, "Finally swapping real and threeway\n");
            tone_zone_play_tone(p->subs[SUB_THREEWAY].zfd, -1);
            swap_subs(p, SUB_THREEWAY, SUB_REAL);
            p->owner = p->subs[SUB_REAL].owner;
         }
      }
      if (p->sig & __ZT_SIG_FXS) {
         zt_enable_ec(p);
         zt_train_ec(p);
      }
      break;
#ifdef ZAPATA_PRI
   case SIG_PRI:
      /* Send a pri acknowledge */
      if (!pri_grab(p, p->pri)) {
         p->proceeding = 1;
         res = pri_answer(p->pri->pri, p->call, 0, !p->digital);
         pri_rel(p->pri);
      } else {
         ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
         res= -1;
      }
      break;
#endif
#ifdef ZAPATA_R2
   case SIG_R2:
      res = mfcr2_AnswerCall(p->r2, NULL);
      if (res)
         ast_log(LOG_WARNING, "R2 Answer call failed :( on %s\n", ast->name);
      break;
#endif         
   case 0:
      ast_mutex_unlock(&p->lock);
      return 0;
   default:
      ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
      res = -1;
   }
   ast_mutex_unlock(&p->lock);
   return res;
}

static int zt_setoption(struct ast_channel *chan, int option, void *data, int datalen)
{
   char *cp;
   signed char *scp;
   int x;
   int index;
   struct zt_pvt *p = chan->tech_pvt;

   /* all supported options require data */
   if (!data || (datalen < 1)) {
      errno = EINVAL;
      return -1;
   }

   switch(option) {
   case AST_OPTION_TXGAIN:
      scp = (signed char *) data;
      index = zt_get_index(chan, p, 0);
      if (index < 0) {
         ast_log(LOG_WARNING, "No index in TXGAIN?\n");
         return -1;
      }
      ast_log(LOG_DEBUG, "Setting actual tx gain on %s to %f\n", chan->name, p->txgain + (float) *scp);
      return set_actual_txgain(p->subs[index].zfd, 0, p->txgain + (float) *scp, p->law);
   case AST_OPTION_RXGAIN:
      scp = (signed char *) data;
      index = zt_get_index(chan, p, 0);
      if (index < 0) {
         ast_log(LOG_WARNING, "No index in RXGAIN?\n");
         return -1;
      }
      ast_log(LOG_DEBUG, "Setting actual rx gain on %s to %f\n", chan->name, p->rxgain + (float) *scp);
      return set_actual_rxgain(p->subs[index].zfd, 0, p->rxgain + (float) *scp, p->law);
   case AST_OPTION_TONE_VERIFY:
      if (!p->dsp)
         break;
      cp = (char *) data;
      switch (*cp) {
      case 1:
         ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF(1) on %s\n",chan->name);
         ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | p->dtmfrelax);  /* set mute mode if desired */
         break;
      case 2:
         ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: MUTECONF/MAX(2) on %s\n",chan->name);
         ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MUTECONF | DSP_DIGITMODE_MUTEMAX | p->dtmfrelax);  /* set mute mode if desired */
         break;
      default:
         ast_log(LOG_DEBUG, "Set option TONE VERIFY, mode: OFF(0) on %s\n",chan->name);
         ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);  /* set mute mode if desired */
         break;
      }
      break;
   case AST_OPTION_TDD:
      /* turn on or off TDD */
      cp = (char *) data;
      p->mate = 0;
      if (!*cp) { /* turn it off */
         ast_log(LOG_DEBUG, "Set option TDD MODE, value: OFF(0) on %s\n",chan->name);
         if (p->tdd) tdd_free(p->tdd);
         p->tdd = 0;
         break;
      }
      ast_log(LOG_DEBUG, "Set option TDD MODE, value: %s(%d) on %s\n",
         (*cp == 2) ? "MATE" : "ON", (int) *cp, chan->name);
      zt_disable_ec(p);
      /* otherwise, turn it on */
      if (!p->didtdd) { /* if havent done it yet */
         unsigned char mybuf[41000],*buf;
         int size,res,fd,len;
         struct pollfd fds[1];

         buf = mybuf;
         memset(buf, 0x7f, sizeof(mybuf)); /* set to silence */
         ast_tdd_gen_ecdisa(buf + 16000, 16000);  /* put in tone */
         len = 40000;
         index = zt_get_index(chan, p, 0);
         if (index < 0) {
            ast_log(LOG_WARNING, "No index in TDD?\n");
            return -1;
         }
         fd = p->subs[index].zfd;
         while(len) {
            if (ast_check_hangup(chan)) return -1;
            size = len;
            if (size > READ_SIZE)
               size = READ_SIZE;
            fds[0].fd = fd;
            fds[0].events = POLLPRI | POLLOUT;
            fds[0].revents = 0;
            res = poll(fds, 1, -1);
            if (!res) {
               ast_log(LOG_DEBUG, "poll (for write) ret. 0 on channel %d\n", p->channel);
               continue;
            }
            /* if got exception */
            if (fds[0].revents & POLLPRI) return -1;
            if (!(fds[0].revents & POLLOUT)) {
               ast_log(LOG_DEBUG, "write fd not ready on channel %d\n", p->channel);
               continue;
            }
            res = write(fd, buf, size);
            if (res != size) {
               if (res == -1) return -1;
               ast_log(LOG_DEBUG, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
               break;
            }
            len -= size;
            buf += size;
         }
         p->didtdd = 1; /* set to have done it now */    
      }
      if (*cp == 2) { /* Mate mode */
         if (p->tdd) tdd_free(p->tdd);
         p->tdd = 0;
         p->mate = 1;
         break;
      }     
      if (!p->tdd) { /* if we dont have one yet */
         p->tdd = tdd_new(); /* allocate one */
      }     
      break;
   case AST_OPTION_RELAXDTMF:  /* Relax DTMF decoding (or not) */
      if (!p->dsp)
         break;
      cp = (char *) data;
      ast_log(LOG_DEBUG, "Set option RELAX DTMF, value: %s(%d) on %s\n",
         *cp ? "ON" : "OFF", (int) *cp, chan->name);
      ast_dsp_digitmode(p->dsp, ((*cp) ? DSP_DIGITMODE_RELAXDTMF : DSP_DIGITMODE_DTMF) | p->dtmfrelax);
      break;
   case AST_OPTION_AUDIO_MODE:  /* Set AUDIO mode (or not) */
      cp = (char *) data;
      if (!*cp) {    
         ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: OFF(0) on %s\n", chan->name);
         x = 0;
         zt_disable_ec(p);
      } else {    
         ast_log(LOG_DEBUG, "Set option AUDIO MODE, value: ON(1) on %s\n", chan->name);
         x = 1;
      }
      if (ioctl(p->subs[SUB_REAL].zfd, ZT_AUDIOMODE, &x) == -1)
         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d\n", p->channel, x);
      break;
   }
   errno = 0;

   return 0;
}

static void zt_unlink(struct zt_pvt *slave, struct zt_pvt *master, int needlock)
{
   /* Unlink a specific slave or all slaves/masters from a given master */
   int x;
   int hasslaves;
   if (!master)
      return;
   if (needlock) {
      ast_mutex_lock(&master->lock);
      if (slave) {
         while(ast_mutex_trylock(&slave->lock)) {
            ast_mutex_unlock(&master->lock);
            usleep(1);
            ast_mutex_lock(&master->lock);
         }
      }
   }
   hasslaves = 0;
   for (x=0;x<MAX_SLAVES;x++) {
      if (master->slaves[x]) {
         if (!slave || (master->slaves[x] == slave)) {
            /* Take slave out of the conference */
            ast_log(LOG_DEBUG, "Unlinking slave %d from %d\n", master->slaves[x]->channel, master->channel);
            conf_del(master, &master->slaves[x]->subs[SUB_REAL], SUB_REAL);
            conf_del(master->slaves[x], &master->subs[SUB_REAL], SUB_REAL);
            master->slaves[x]->master = NULL;
            master->slaves[x] = NULL;
         } else
            hasslaves = 1;
      }
      if (!hasslaves)
         master->inconference = 0;
   }
   if (!slave) {
      if (master->master) {
         /* Take master out of the conference */
         conf_del(master->master, &master->subs[SUB_REAL], SUB_REAL);
         conf_del(master, &master->master->subs[SUB_REAL], SUB_REAL);
         hasslaves = 0;
         for (x=0;x<MAX_SLAVES;x++) {
            if (master->master->slaves[x] == master)
               master->master->slaves[x] = NULL;
            else if (master->master->slaves[x])
               hasslaves = 1;
         }
         if (!hasslaves)
            master->master->inconference = 0;
      }
      master->master = NULL;
   }
   update_conf(master);
   if (needlock) {
      if (slave)
         ast_mutex_unlock(&slave->lock);
      ast_mutex_unlock(&master->lock);
   }
}

static void zt_link(struct zt_pvt *slave, struct zt_pvt *master) {
   int x;
   if (!slave || !master) {
      ast_log(LOG_WARNING, "Tried to link to/from NULL??\n");
      return;
   }
   for (x=0;x<MAX_SLAVES;x++) {
      if (!master->slaves[x]) {
         master->slaves[x] = slave;
         break;
      }
   }
   if (x >= MAX_SLAVES) {
      ast_log(LOG_WARNING, "Replacing slave %d with new slave, %d\n", master->slaves[MAX_SLAVES - 1]->channel, slave->channel);
      master->slaves[MAX_SLAVES - 1] = slave;
   }
   if (slave->master) 
      ast_log(LOG_WARNING, "Replacing master %d with new master, %d\n", slave->master->channel, master->channel);
   slave->master = master;
   
   ast_log(LOG_DEBUG, "Making %d slave to master %d at %d\n", slave->channel, master->channel, x);
}

static void disable_dtmf_detect(struct zt_pvt *p)
{
#ifdef ZT_TONEDETECT
   int val;
#endif

   p->ignoredtmf = 1;

#ifdef ZT_TONEDETECT
   val = 0;
   ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
#endif      
   if (!p->hardwaredtmf && p->dsp) {
      p->dsp_features &= ~DSP_FEATURE_DTMF_DETECT;
      ast_dsp_set_features(p->dsp, p->dsp_features);
   }
}

static void enable_dtmf_detect(struct zt_pvt *p)
{
#ifdef ZT_TONEDETECT
   int val;
#endif

   if (p->channel == CHAN_PSEUDO)
      return;

   p->ignoredtmf = 0;

#ifdef ZT_TONEDETECT
   val = ZT_TONEDETECT_ON | ZT_TONEDETECT_MUTE;
   ioctl(p->subs[SUB_REAL].zfd, ZT_TONEDETECT, &val);
#endif      
   if (!p->hardwaredtmf && p->dsp) {
      p->dsp_features |= DSP_FEATURE_DTMF_DETECT;
      ast_dsp_set_features(p->dsp, p->dsp_features);
   }
}

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)
{
   struct ast_channel *who;
   struct zt_pvt *p0, *p1, *op0, *op1;
   struct zt_pvt *master = NULL, *slave = NULL;
   struct ast_frame *f;
   int inconf = 0;
   int nothingok = 1;
   int ofd0, ofd1;
   int oi0, oi1, i0 = -1, i1 = -1, t0, t1;
   int os0 = -1, os1 = -1;
   int priority = 0;
   struct ast_channel *oc0, *oc1;
   enum ast_bridge_result res;

#ifdef PRI_2BCT
   int triedtopribridge = 0;
   q931_call *q931c0 = NULL, *q931c1 = NULL;
#endif

   /* For now, don't attempt to native bridge if either channel needs DTMF detection.
      There is code below to handle it properly until DTMF is actually seen,
      but due to currently unresolved issues it's ignored...
   */

   if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
      return AST_BRIDGE_FAILED_NOWARN;

   ast_mutex_lock(&c0->lock);
   ast_mutex_lock(&c1->lock);

   p0 = c0->tech_pvt;
   p1 = c1->tech_pvt;
   /* cant do pseudo-channels here */
   if (!p0 || (!p0->sig) || !p1 || (!p1->sig)) {
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED_NOWARN;
   }

   oi0 = zt_get_index(c0, p0, 0);
   oi1 = zt_get_index(c1, p1, 0);
   if ((oi0 < 0) || (oi1 < 0)) {
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED;
   }

   op0 = p0 = c0->tech_pvt;
   op1 = p1 = c1->tech_pvt;
   ofd0 = c0->fds[0];
   ofd1 = c1->fds[0];
   oc0 = p0->owner;
   oc1 = p1->owner;

   if (ast_mutex_trylock(&p0->lock)) {
      /* Don't block, due to potential for deadlock */
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      ast_log(LOG_NOTICE, "Avoiding deadlock...\n");
      return AST_BRIDGE_RETRY;
   }
   if (ast_mutex_trylock(&p1->lock)) {
      /* Don't block, due to potential for deadlock */
      ast_mutex_unlock(&p0->lock);
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      ast_log(LOG_NOTICE, "Avoiding deadlock...\n");
      return AST_BRIDGE_RETRY;
   }

   if ((oi0 == SUB_REAL) && (oi1 == SUB_REAL)) {
      if (p0->owner && p1->owner) {
         /* If we don't have a call-wait in a 3-way, and we aren't in a 3-way, we can be master */
         if (!p0->subs[SUB_CALLWAIT].inthreeway && !p1->subs[SUB_REAL].inthreeway) {
            master = p0;
            slave = p1;
            inconf = 1;
         } else if (!p1->subs[SUB_CALLWAIT].inthreeway && !p0->subs[SUB_REAL].inthreeway) {
            master = p1;
            slave = p0;
            inconf = 1;
         } else {
            ast_log(LOG_WARNING, "Huh?  Both calls are callwaits or 3-ways?  That's clever...?\n");
            ast_log(LOG_WARNING, "p0: chan %d/%d/CW%d/3W%d, p1: chan %d/%d/CW%d/3W%d\n",
               p0->channel,
               oi0, (p0->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0,
               p0->subs[SUB_REAL].inthreeway, p0->channel,
               oi0, (p1->subs[SUB_CALLWAIT].zfd > -1) ? 1 : 0,
               p1->subs[SUB_REAL].inthreeway);
         }
         nothingok = 0;
      }
   } else if ((oi0 == SUB_REAL) && (oi1 == SUB_THREEWAY)) {
      if (p1->subs[SUB_THREEWAY].inthreeway) {
         master = p1;
         slave = p0;
         nothingok = 0;
      }
   } else if ((oi0 == SUB_THREEWAY) && (oi1 == SUB_REAL)) {
      if (p0->subs[SUB_THREEWAY].inthreeway) {
         master = p0;
         slave = p1;
         nothingok = 0;
      }
   } else if ((oi0 == SUB_REAL) && (oi1 == SUB_CALLWAIT)) {
      /* We have a real and a call wait.  If we're in a three way call, put us in it, otherwise, 
         don't put us in anything */
      if (p1->subs[SUB_CALLWAIT].inthreeway) {
         master = p1;
         slave = p0;
         nothingok = 0;
      }
   } else if ((oi0 == SUB_CALLWAIT) && (oi1 == SUB_REAL)) {
      /* Same as previous */
      if (p0->subs[SUB_CALLWAIT].inthreeway) {
         master = p0;
         slave = p1;
         nothingok = 0;
      }
   }
   ast_log(LOG_DEBUG, "master: %d, slave: %d, nothingok: %d\n",
      master ? master->channel : 0, slave ? slave->channel : 0, nothingok);
   if (master && slave) {
      /* Stop any tones, or play ringtone as appropriate.  If they're bridged
         in an active threeway call with a channel that is ringing, we should
         indicate ringing. */
      if ((oi1 == SUB_THREEWAY) && 
          p1->subs[SUB_THREEWAY].inthreeway && 
          p1->subs[SUB_REAL].owner && 
          p1->subs[SUB_REAL].inthreeway && 
          (p1->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
         ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c0->name, c1->name);
         tone_zone_play_tone(p0->subs[oi0].zfd, ZT_TONE_RINGTONE);
         os1 = p1->subs[SUB_REAL].owner->_state;
      } else {
         ast_log(LOG_DEBUG, "Stopping tones on %d/%d talking to %d/%d\n", p0->channel, oi0, p1->channel, oi1);
         tone_zone_play_tone(p0->subs[oi0].zfd, -1);
      }
      if ((oi0 == SUB_THREEWAY) && 
          p0->subs[SUB_THREEWAY].inthreeway && 
          p0->subs[SUB_REAL].owner && 
          p0->subs[SUB_REAL].inthreeway && 
          (p0->subs[SUB_REAL].owner->_state == AST_STATE_RINGING)) {
         ast_log(LOG_DEBUG, "Playing ringback on %s since %s is in a ringing three-way\n", c1->name, c0->name);
         tone_zone_play_tone(p1->subs[oi1].zfd, ZT_TONE_RINGTONE);
         os0 = p0->subs[SUB_REAL].owner->_state;
      } else {
         ast_log(LOG_DEBUG, "Stopping tones on %d/%d talking to %d/%d\n", p1->channel, oi1, p0->channel, oi0);
         tone_zone_play_tone(p1->subs[oi0].zfd, -1);
      }
      if ((oi0 == SUB_REAL) && (oi1 == SUB_REAL)) {
         if (!p0->echocanbridged || !p1->echocanbridged) {
            /* Disable echo cancellation if appropriate */
            zt_disable_ec(p0);
            zt_disable_ec(p1);
         }
      }
      zt_link(slave, master);
      master->inconference = inconf;
   } else if (!nothingok)
      ast_log(LOG_WARNING, "Can't link %d/%s with %d/%s\n", p0->channel, subnames[oi0], p1->channel, subnames[oi1]);

   update_conf(p0);
   update_conf(p1);
   t0 = p0->subs[SUB_REAL].inthreeway;
   t1 = p1->subs[SUB_REAL].inthreeway;

   ast_mutex_unlock(&p0->lock);
   ast_mutex_unlock(&p1->lock);

   ast_mutex_unlock(&c0->lock);
   ast_mutex_unlock(&c1->lock);

   /* Native bridge failed */
   if ((!master || !slave) && !nothingok) {
      zt_enable_ec(p0);
      zt_enable_ec(p1);
      return AST_BRIDGE_FAILED;
   }
   
   if (!(flags & AST_BRIDGE_DTMF_CHANNEL_0) && (oi0 == SUB_REAL))
      disable_dtmf_detect(op0);

   if (!(flags & AST_BRIDGE_DTMF_CHANNEL_1) && (oi1 == SUB_REAL))
      disable_dtmf_detect(op1);

   for (;;) {
      struct ast_channel *c0_priority[2] = {c0, c1};
      struct ast_channel *c1_priority[2] = {c1, c0};

      /* Here's our main loop...  Start by locking things, looking for private parts, 
         and then balking if anything is wrong */
      ast_mutex_lock(&c0->lock);
      ast_mutex_lock(&c1->lock);
      p0 = c0->tech_pvt;
      p1 = c1->tech_pvt;

      if (op0 == p0)
         i0 = zt_get_index(c0, p0, 1);
      if (op1 == p1)
         i1 = zt_get_index(c1, p1, 1);
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);

      if (!timeoutms || 
          (op0 != p0) ||
          (op1 != p1) || 
          (ofd0 != c0->fds[0]) || 
          (ofd1 != c1->fds[0]) ||
          (p0->subs[SUB_REAL].owner && (os0 > -1) && (os0 != p0->subs[SUB_REAL].owner->_state)) || 
          (p1->subs[SUB_REAL].owner && (os1 > -1) && (os1 != p1->subs[SUB_REAL].owner->_state)) || 
          (oc0 != p0->owner) || 
          (oc1 != p1->owner) ||
          (t0 != p0->subs[SUB_REAL].inthreeway) ||
          (t1 != p1->subs[SUB_REAL].inthreeway) ||
          (oi0 != i0) ||
          (oi1 != i1)) {
         ast_log(LOG_DEBUG, "Something changed out on %d/%d to %d/%d, returning -3 to restart\n",
            op0->channel, oi0, op1->channel, oi1);
         res = AST_BRIDGE_RETRY;
         goto return_from_bridge;
      }

#ifdef PRI_2BCT
      q931c0 = p0->call;
      q931c1 = p1->call;
      if (p0->transfer && p1->transfer 
          && q931c0 && q931c1 
          && !triedtopribridge) {
         pri_channel_bridge(q931c0, q931c1);
         triedtopribridge = 1;
      }
#endif

      who = ast_waitfor_n(priority ? c0_priority : c1_priority, 2, &timeoutms);
      if (!who) {
         ast_log(LOG_DEBUG, "Ooh, empty read...\n");
         continue;
      }
      f = ast_read(who);
      if (!f || (f->frametype == AST_FRAME_CONTROL)) {
         *fo = f;
         *rc = who;
         res = AST_BRIDGE_COMPLETE;
         goto return_from_bridge;
      }
      if (f->frametype == AST_FRAME_DTMF) {
         if ((who == c0) && p0->pulsedial) {
            ast_write(c1, f);
         } else if ((who == c1) && p1->pulsedial) {
            ast_write(c0, f);
         } else {
            *fo = f;
            *rc = who;
            res = AST_BRIDGE_COMPLETE;
            goto return_from_bridge;
         }
      }
      ast_frfree(f);
      
      /* Swap who gets priority */
      priority = !priority;
   }

return_from_bridge:
   if (op0 == p0)
      zt_enable_ec(p0);

   if (op1 == p1)
      zt_enable_ec(p1);

   if (!(flags & AST_BRIDGE_DTMF_CHANNEL_0) && (oi0 == SUB_REAL))
      enable_dtmf_detect(op0);

   if (!(flags & AST_BRIDGE_DTMF_CHANNEL_1) && (oi1 == SUB_REAL))
      enable_dtmf_detect(op1);

   zt_unlink(slave, master, 1);

   return res;
}

static int zt_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
{
   struct zt_pvt *p = newchan->tech_pvt;
   int x;
   ast_mutex_lock(&p->lock);
   ast_log(LOG_DEBUG, "New owner for channel %d is %s\n", p->channel, newchan->name);
   if (p->owner == oldchan) {
      p->owner = newchan;
   }
   for (x=0;x<3;x++)
      if (p->subs[x].owner == oldchan) {
         if (!x)
            zt_unlink(NULL, p, 0);
         p->subs[x].owner = newchan;
      }
   if (newchan->_state == AST_STATE_RINGING) 
      zt_indicate(newchan, AST_CONTROL_RINGING);
   update_conf(p);
   ast_mutex_unlock(&p->lock);
   return 0;
}

static int zt_ring_phone(struct zt_pvt *p)
{
   int x;
   int res;
   /* Make sure our transmit state is on hook */
   x = 0;
   x = ZT_ONHOOK;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
   do {
      x = ZT_RING;
      res = ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
      if (res) {
         switch(errno) {
         case EBUSY:
         case EINTR:
            /* Wait just in case */
            usleep(10000);
            continue;
         case EINPROGRESS:
            res = 0;
            break;
         default:
            ast_log(LOG_WARNING, "Couldn't ring the phone: %s\n", strerror(errno));
            res = 0;
         }
      }
   } while (res);
   return res;
}

static void *ss_thread(void *data);

static struct ast_channel *zt_new(struct zt_pvt *, int, int, int, int, int);

static int attempt_transfer(struct zt_pvt *p)
{
   /* In order to transfer, we need at least one of the channels to
      actually be in a call bridge.  We can't conference two applications
      together (but then, why would we want to?) */
   if (ast_bridged_channel(p->subs[SUB_REAL].owner)) {
      /* The three-way person we're about to transfer to could still be in MOH, so
         stop if now if appropriate */
      if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner))
         ast_moh_stop(ast_bridged_channel(p->subs[SUB_THREEWAY].owner));
      if (p->subs[SUB_REAL].owner->_state == AST_STATE_RINGING) {
         ast_indicate(ast_bridged_channel(p->subs[SUB_REAL].owner), AST_CONTROL_RINGING);
      }
      if (p->subs[SUB_REAL].owner->cdr) {
         /* Move CDR from second channel to current one */
         p->subs[SUB_THREEWAY].owner->cdr =
            ast_cdr_append(p->subs[SUB_THREEWAY].owner->cdr, p->subs[SUB_REAL].owner->cdr);
         p->subs[SUB_REAL].owner->cdr = NULL;
      }
      if (ast_bridged_channel(p->subs[SUB_REAL].owner)->cdr) {
         /* Move CDR from second channel's bridge to current one */
         p->subs[SUB_THREEWAY].owner->cdr =
            ast_cdr_append(p->subs[SUB_THREEWAY].owner->cdr, ast_bridged_channel(p->subs[SUB_REAL].owner)->cdr);
         ast_bridged_channel(p->subs[SUB_REAL].owner)->cdr = NULL;
      }
       if (ast_channel_masquerade(p->subs[SUB_THREEWAY].owner, ast_bridged_channel(p->subs[SUB_REAL].owner))) {
         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
               ast_bridged_channel(p->subs[SUB_REAL].owner)->name, p->subs[SUB_THREEWAY].owner->name);
         return -1;
      }
      /* Orphan the channel after releasing the lock */
      ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
      unalloc_sub(p, SUB_THREEWAY);
   } else if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) {
      if (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_RINGING) {
         ast_indicate(ast_bridged_channel(p->subs[SUB_THREEWAY].owner), AST_CONTROL_RINGING);
      }
      ast_moh_stop(ast_bridged_channel(p->subs[SUB_THREEWAY].owner));
      if (p->subs[SUB_THREEWAY].owner->cdr) {
         /* Move CDR from second channel to current one */
         p->subs[SUB_REAL].owner->cdr = 
            ast_cdr_append(p->subs[SUB_REAL].owner->cdr, p->subs[SUB_THREEWAY].owner->cdr);
         p->subs[SUB_THREEWAY].owner->cdr = NULL;
      }
      if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner)->cdr) {
         /* Move CDR from second channel's bridge to current one */
         p->subs[SUB_REAL].owner->cdr = 
            ast_cdr_append(p->subs[SUB_REAL].owner->cdr, ast_bridged_channel(p->subs[SUB_THREEWAY].owner)->cdr);
         ast_bridged_channel(p->subs[SUB_THREEWAY].owner)->cdr = NULL;
      }
      if (ast_channel_masquerade(p->subs[SUB_REAL].owner, ast_bridged_channel(p->subs[SUB_THREEWAY].owner))) {
         ast_log(LOG_WARNING, "Unable to masquerade %s as %s\n",
               ast_bridged_channel(p->subs[SUB_THREEWAY].owner)->name, p->subs[SUB_REAL].owner->name);
         return -1;
      }
      /* Three-way is now the REAL */
      swap_subs(p, SUB_THREEWAY, SUB_REAL);
      ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
      unalloc_sub(p, SUB_THREEWAY);
      /* Tell the caller not to hangup */
      return 1;
   } else {
      ast_log(LOG_DEBUG, "Neither %s nor %s are in a bridge, nothing to transfer\n",
               p->subs[SUB_REAL].owner->name, p->subs[SUB_THREEWAY].owner->name);
      p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
      return -1;
   }
   return 0;
}

#ifdef ZAPATA_R2
static struct ast_frame *handle_r2_event(struct zt_pvt *p, mfcr2_event_t *e, int index)
{
   struct ast_frame *f;
   f = &p->subs[index].f;
   if (!p->r2) {
      ast_log(LOG_WARNING, "Huh?  No R2 structure :(\n");
      return NULL;
   }
   switch(e->e) {
   case MFCR2_EVENT_BLOCKED:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Channel %d blocked\n", p->channel);
      break;
   case MFCR2_EVENT_UNBLOCKED:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Channel %d unblocked\n", p->channel);
      break;
   case MFCR2_EVENT_CONFIG_ERR:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Config error on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_RING:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Ring on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_HANGUP:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Hangup on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_RINGING:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Ringing on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_ANSWER:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Answer on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_HANGUP_ACK:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Hangup ACK on channel %d\n", p->channel);
      break;
   case MFCR2_EVENT_IDLE:
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "Idle on channel %d\n", p->channel);
      break;
   default:
      ast_log(LOG_WARNING, "Unknown MFC/R2 event %d\n", e->e);
      break;
   }
   return f;
}

static mfcr2_event_t *r2_get_event_bits(struct zt_pvt *p)
{
   int x;
   int res;
   mfcr2_event_t *e;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_GETRXBITS, &x);
   if (res) {
      ast_log(LOG_WARNING, "Unable to check received bits\n");
      return NULL;
   }
   if (!p->r2) {
      ast_log(LOG_WARNING, "Odd, no R2 structure on channel %d\n", p->channel);
      return NULL;
   }
   e = mfcr2_cas_signaling_event(p->r2, x);
   return e;
}
#endif

static int check_for_conference(struct zt_pvt *p)
{
   ZT_CONFINFO ci;
   /* Fine if we already have a master, etc */
   if (p->master || (p->confno > -1))
      return 0;
   memset(&ci, 0, sizeof(ci));
   if (ioctl(p->subs[SUB_REAL].zfd, ZT_GETCONF, &ci)) {
      ast_log(LOG_WARNING, "Failed to get conference info on channel %d\n", p->channel);
      return 0;
   }
   /* If we have no master and don't have a confno, then 
      if we're in a conference, it's probably a MeetMe room or
      some such, so don't let us 3-way out! */
   if ((p->subs[SUB_REAL].curconf.confno != ci.confno) || (p->subs[SUB_REAL].curconf.confmode != ci.confmode)) {
      if (option_verbose > 2) 
         ast_verbose(VERBOSE_PREFIX_3 "Avoiding 3-way call when in an external conference\n");
      return 1;
   }
   return 0;
}

static int get_alarms(struct zt_pvt *p)
{
   int res;
   ZT_SPANINFO zi;
   memset(&zi, 0, sizeof(zi));
   zi.spanno = p->span;
   res = ioctl(p->subs[SUB_REAL].zfd, ZT_SPANSTAT, &zi);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to determine alarm on channel %d\n", p->channel);
      return 0;
   }
   return zi.alarms;
}

static void zt_handle_dtmfup(struct ast_channel *ast, int index, struct ast_frame **dest)
{
   struct zt_pvt *p = ast->tech_pvt;
   struct ast_frame *f = *dest;

   ast_log(LOG_DEBUG, "DTMF digit: %c on %s\n", f->subclass, ast->name);
   if (p->confirmanswer) {
      ast_log(LOG_DEBUG, "Confirm answer on %s!\n", ast->name);
      /* Upon receiving a DTMF digit, consider this an answer confirmation instead
         of a DTMF digit */
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_ANSWER;
      *dest = &p->subs[index].f;
      /* Reset confirmanswer so DTMF's will behave properly for the duration of the call */
      p->confirmanswer = 0;
   } else if (p->callwaitcas) {
      if ((f->subclass == 'A') || (f->subclass == 'D')) {
         ast_log(LOG_DEBUG, "Got some DTMF, but it's for the CAS\n");
         if (p->cidspill)
            free(p->cidspill);
         send_cwcidspill(p);
      }
      if ((f->subclass != 'm') && (f->subclass != 'u')) 
         p->callwaitcas = 0;
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      *dest = &p->subs[index].f;
   } else if (f->subclass == 'f') {
      /* Fax tone -- Handle and return NULL */
      if ((p->callprogress & 0x6) && !p->faxhandled) {
         p->faxhandled++;
         if (strcmp(ast->exten, "fax")) {
            const char *target_context = ast_strlen_zero(ast->macrocontext) ? ast->context : ast->macrocontext;

            if (ast_exists_extension(ast, target_context, "fax", 1, ast->cid.cid_num)) {
               if (option_verbose > 2)
                  ast_verbose(VERBOSE_PREFIX_3 "Redirecting %s to fax extension\n", ast->name);
               /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
               pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast->exten);
               if (ast_async_goto(ast, target_context, "fax", 1))
                  ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast->name, target_context);
            } else
               ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
         } else
            ast_log(LOG_DEBUG, "Already in a fax extension, not redirecting\n");
      } else
            ast_log(LOG_DEBUG, "Fax already handled\n");
      zt_confmute(p, 0);
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      *dest = &p->subs[index].f;
   } else if (f->subclass == 'm') {
      /* Confmute request */
      zt_confmute(p, 1);
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      *dest = &p->subs[index].f;    
   } else if (f->subclass == 'u') {
      /* Unmute */
      zt_confmute(p, 0);
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      *dest = &p->subs[index].f;    
   } else
      zt_confmute(p, 0);
}
         
static struct ast_frame *zt_handle_event(struct ast_channel *ast)
{
   int res,x;
   int index;
   char *c;
   struct zt_pvt *p = ast->tech_pvt;
   pthread_t threadid;
   pthread_attr_t attr;
   struct ast_channel *chan;
   struct ast_frame *f;

   index = zt_get_index(ast, p, 0);
   p->subs[index].f.frametype = AST_FRAME_NULL;
   p->subs[index].f.datalen = 0;
   p->subs[index].f.samples = 0;
   p->subs[index].f.mallocd = 0;
   p->subs[index].f.offset = 0;
   p->subs[index].f.src = "zt_handle_event";
   p->subs[index].f.data = NULL;
   f = &p->subs[index].f;

   if (index < 0)
      return &p->subs[index].f;
   if (p->fake_event) {
      res = p->fake_event;
      p->fake_event = 0;
   } else
      res = zt_get_event(p->subs[index].zfd);

   ast_log(LOG_DEBUG, "Got event %s(%d) on channel %d (index %d)\n", event2str(res), res, p->channel, index);

   if (res & (ZT_EVENT_PULSEDIGIT | ZT_EVENT_DTMFUP)) {
      if (res & ZT_EVENT_PULSEDIGIT)
         p->pulsedial = 1;
      else
         p->pulsedial = 0;

      ast_log(LOG_DEBUG, "Detected %sdigit '%c'\n", p->pulsedial ? "pulse ": "", res & 0xff);
#ifdef ZAPATA_PRI
      if (!p->proceeding && p->sig == SIG_PRI && p->pri && p->pri->overlapdial) {
         p->subs[index].f.frametype = AST_FRAME_NULL;
         p->subs[index].f.subclass = 0;
      } else {
#endif
         p->subs[index].f.frametype = AST_FRAME_DTMF;
         p->subs[index].f.subclass = res & 0xff;
#ifdef ZAPATA_PRI
      }
#endif
      zt_handle_dtmfup(ast, index, &f);
      return f;
   }

   if (res & ZT_EVENT_DTMFDOWN) {
      ast_log(LOG_DEBUG, "DTMF Down '%c'\n", res & 0xff);
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      zt_confmute(p, 1);
      /* Mute conference, return null frame */
      return &p->subs[index].f;
   }

   switch(res) {
      case ZT_EVENT_BITSCHANGED:
         if (p->sig == SIG_R2) {
#ifdef ZAPATA_R2
            struct ast_frame  *f = &p->subs[index].f;
            mfcr2_event_t *e;
            e = r2_get_event_bits(p);
            if (e)
               f = handle_r2_event(p, e, index);
            return f;
#else          
            break;
#endif
         }
         ast_log(LOG_WARNING, "Recieved bits changed on %s signalling?\n", sig2str(p->sig));
      case ZT_EVENT_PULSE_START:
         /* Stop tone if there's a pulse start and the PBX isn't started */
         if (!ast->pbx)
            tone_zone_play_tone(p->subs[index].zfd, -1);
         break;   
      case ZT_EVENT_DIALCOMPLETE:
         if (p->inalarm) break;
         if (p->radio) break;
         if (ioctl(p->subs[index].zfd,ZT_DIALING,&x) == -1) {
            ast_log(LOG_DEBUG, "ZT_DIALING ioctl failed on %s\n",ast->name);
            return NULL;
         }
         if (!x) { /* if not still dialing in driver */
            zt_enable_ec(p);
            if (p->echobreak) {
               zt_train_ec(p);
               ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr));
               p->dop.op = ZT_DIAL_OP_REPLACE;
               res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
               p->echobreak = 0;
            } else {
               p->dialing = 0;
               if (p->sig == SIG_E911) {
                  /* if thru with dialing after offhook */
                  if (ast->_state == AST_STATE_DIALING_OFFHOOK) {
                     ast_setstate(ast, AST_STATE_UP);
                     p->subs[index].f.frametype = AST_FRAME_CONTROL;
                     p->subs[index].f.subclass = AST_CONTROL_ANSWER;
                     break;
                  } else { /* if to state wait for offhook to dial rest */
                     /* we now wait for off hook */
                     ast_setstate(ast,AST_STATE_DIALING_OFFHOOK);
                  }
               }
               if (ast->_state == AST_STATE_DIALING) {
                  if ((p->callprogress & 1) && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
                     ast_log(LOG_DEBUG, "Done dialing, but waiting for progress detection before doing more...\n");
                  } else if (p->confirmanswer || (!p->dialednone && ((p->sig == SIG_EM) || (p->sig == SIG_EM_E1) ||  (p->sig == SIG_EMWINK) || (p->sig == SIG_FEATD) || (p->sig == SIG_FEATDMF) || (p->sig == SIG_E911) || (p->sig == SIG_FEATB) || (p->sig == SIG_SF) || (p->sig == SIG_SFWINK) || (p->sig == SIG_SF_FEATD) || (p->sig == SIG_SF_FEATDMF) || (p->sig == SIG_SF_FEATB)))) {
                     ast_setstate(ast, AST_STATE_RINGING);
                  } else if (!p->answeronpolarityswitch) {
                     ast_setstate(ast, AST_STATE_UP);
                     p->subs[index].f.frametype = AST_FRAME_CONTROL;
                     p->subs[index].f.subclass = AST_CONTROL_ANSWER;
                  }
               }
            }
         }
         break;
      case ZT_EVENT_ALARM:
#ifdef ZAPATA_PRI
         if (p->call) {
            if (p->pri && p->pri->pri) {
               if (!pri_grab(p, p->pri)) {
                  pri_hangup(p->pri->pri, p->call, -1);
                  pri_destroycall(p->pri->pri, p->call);
                  p->call = NULL;
                  pri_rel(p->pri);
               } else
                  ast_log(LOG_WARNING, "Failed to grab PRI!\n");
            } else
               ast_log(LOG_WARNING, "The PRI Call have not been destroyed\n");
         }
         if (p->owner)
            p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
         if (p->bearer)
            p->bearer->inalarm = 1;
         else
#endif
         p->inalarm = 1;
         res = get_alarms(p);
         ast_log(LOG_WARNING, "Detected alarm on channel %d: %s\n", p->channel, alarm2str(res));
         manager_event(EVENT_FLAG_SYSTEM, "Alarm",
                        "Alarm: %s\r\n"
                        "Channel: %d\r\n",
                        alarm2str(res), p->channel);
         /* fall through intentionally */
      case ZT_EVENT_ONHOOK:
         if (p->radio)
         {
            p->subs[index].f.frametype = AST_FRAME_CONTROL;
            p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY;
            break;
         }
         switch(p->sig) {
         case SIG_FXOLS:
         case SIG_FXOGS:
         case SIG_FXOKS:
            p->onhooktime = time(NULL);
            p->msgstate = -1;
            /* Check for some special conditions regarding call waiting */
            if (index == SUB_REAL) {
               /* The normal line was hung up */
               if (p->subs[SUB_CALLWAIT].owner) {
                  /* There's a call waiting call, so ring the phone, but make it unowned in the mean time */
                  swap_subs(p, SUB_CALLWAIT, SUB_REAL);
                  if (option_verbose > 2) 
                     ast_verbose(VERBOSE_PREFIX_3 "Channel %d still has (callwait) call, ringing phone\n", p->channel);
                  unalloc_sub(p, SUB_CALLWAIT); 
#if 0
                  p->subs[index].needanswer = 0;
                  p->subs[index].needringing = 0;
#endif                  
                  p->callwaitingrepeat = 0;
                  p->cidcwexpire = 0;
                  p->owner = NULL;
                  /* Don't start streaming audio yet if the incoming call isn't up yet */
                  if (p->subs[SUB_REAL].owner->_state != AST_STATE_UP)
                     p->dialing = 1;
                  zt_ring_phone(p);
               } else if (p->subs[SUB_THREEWAY].owner) {
                  unsigned int mssinceflash;
                  /* Here we have to retain the lock on both the main channel, the 3-way channel, and
                     the private structure -- not especially easy or clean */
                  while(p->subs[SUB_THREEWAY].owner && ast_mutex_trylock(&p->subs[SUB_THREEWAY].owner->lock)) {
                     /* Yuck, didn't get the lock on the 3-way, gotta release everything and re-grab! */
                     ast_mutex_unlock(&p->lock);
                     ast_mutex_unlock(&ast->lock);
                     usleep(1);
                     /* We can grab ast and p in that order, without worry.  We should make sure
                        nothing seriously bad has happened though like some sort of bizarre double
                        masquerade! */
                     ast_mutex_lock(&ast->lock);
                     ast_mutex_lock(&p->lock);
                     if (p->owner != ast) {
                        ast_log(LOG_WARNING, "This isn't good...\n");
                        return NULL;
                     }
                  }
                  if (!p->subs[SUB_THREEWAY].owner) {
                     ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n");
                     return NULL;
                  }
                  mssinceflash = ast_tvdiff_ms(ast_tvnow(), p->flashtime);
                  ast_log(LOG_DEBUG, "Last flash was %d ms ago\n", mssinceflash);
                  if (mssinceflash < MIN_MS_SINCE_FLASH) {
                     /* It hasn't been long enough since the last flashook.  This is probably a bounce on 
                        hanging up.  Hangup both channels now */
                     if (p->subs[SUB_THREEWAY].owner)
                        ast_queue_hangup(p->subs[SUB_THREEWAY].owner);
                     p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                     ast_log(LOG_DEBUG, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
                     ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                  } else if ((ast->pbx) || (ast->_state == AST_STATE_UP)) {
                     if (p->transfer) {
                        /* In any case this isn't a threeway call anymore */
                        p->subs[SUB_REAL].inthreeway = 0;
                        p->subs[SUB_THREEWAY].inthreeway = 0;
                        /* Only attempt transfer if the phone is ringing; why transfer to busy tone eh? */
                        if (!p->transfertobusy && ast->_state == AST_STATE_BUSY) {
                           ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                           /* Swap subs and dis-own channel */
                           swap_subs(p, SUB_THREEWAY, SUB_REAL);
                           p->owner = NULL;
                           /* Ring the phone */
                           zt_ring_phone(p);
                        } else {
                           if ((res = attempt_transfer(p)) < 0) {
                              p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                              if (p->subs[SUB_THREEWAY].owner)
                                 ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                           } else if (res) {
                              /* Don't actually hang up at this point */
                              if (p->subs[SUB_THREEWAY].owner)
                                 ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                              break;
                           }
                        }
                     } else {
                        p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                        if (p->subs[SUB_THREEWAY].owner)
                           ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                     }
                  } else {
                     ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                     /* Swap subs and dis-own channel */
                     swap_subs(p, SUB_THREEWAY, SUB_REAL);
                     p->owner = NULL;
                     /* Ring the phone */
                     zt_ring_phone(p);
                  }
               }
            } else {
               ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", index);
            }
            /* Fall through */
         default:
            zt_disable_ec(p);
            return NULL;
         }
         break;
      case ZT_EVENT_RINGOFFHOOK:
         if (p->inalarm) break;
         if (p->radio)
         {
            p->subs[index].f.frametype = AST_FRAME_CONTROL;
            p->subs[index].f.subclass = AST_CONTROL_RADIO_KEY;
            break;
         }
         /* for E911, its supposed to wait for offhook then dial
            the second half of the dial string */
         if ((p->sig == SIG_E911) && (ast->_state == AST_STATE_DIALING_OFFHOOK)) {
            c = strchr(p->dialdest, '/');
            if (c)
               c++;
            else
               c = p->dialdest;
            if (*c) snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*0%s#", c);
            else ast_copy_string(p->dop.dialstr,"M*2#", sizeof(p->dop.dialstr));
            if (strlen(p->dop.dialstr) > 4) {
               memset(p->echorest, 'w', sizeof(p->echorest) - 1);
               strcpy(p->echorest + (p->echotraining / 401) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
               p->echorest[sizeof(p->echorest) - 1] = '\0';
               p->echobreak = 1;
               p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
            } else
               p->echobreak = 0;
            if (ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop)) {
               x = ZT_ONHOOK;
               ioctl(p->subs[SUB_REAL].zfd, ZT_HOOK, &x);
               ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
               return NULL;
               }
            p->dialing = 1;
            return &p->subs[index].f;
         }
         switch(p->sig) {
         case SIG_FXOLS:
         case SIG_FXOGS:
         case SIG_FXOKS:
            switch(ast->_state) {
            case AST_STATE_RINGING:
               zt_enable_ec(p);
               zt_train_ec(p);
               p->subs[index].f.frametype = AST_FRAME_CONTROL;
               p->subs[index].f.subclass = AST_CONTROL_ANSWER;
               /* Make sure it stops ringing */
               zt_set_hook(p->subs[index].zfd, ZT_OFFHOOK);
               ast_log(LOG_DEBUG, "channel %d answered\n", p->channel);
               if (p->cidspill) {
                  /* Cancel any running CallerID spill */
                  free(p->cidspill);
                  p->cidspill = NULL;
               }
               p->dialing = 0;
               p->callwaitcas = 0;
               if (p->confirmanswer) {
                  /* Ignore answer if "confirm answer" is enabled */
                  p->subs[index].f.frametype = AST_FRAME_NULL;
                  p->subs[index].f.subclass = 0;
               } else if (!ast_strlen_zero(p->dop.dialstr)) {
                  /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */
                  res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
                  if (res < 0) {
                     ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d\n", p->channel);
                     p->dop.dialstr[0] = '\0';
                     return NULL;
                  } else {
                     ast_log(LOG_DEBUG, "Sent FXO deferred digit string: %s\n", p->dop.dialstr);
                     p->subs[index].f.frametype = AST_FRAME_NULL;
                     p->subs[index].f.subclass = 0;
                     p->dialing = 1;
                  }
                  p->dop.dialstr[0] = '\0';
                  ast_setstate(ast, AST_STATE_DIALING);
               } else
                  ast_setstate(ast, AST_STATE_UP);
               return &p->subs[index].f;
            case AST_STATE_DOWN:
               ast_setstate(ast, AST_STATE_RING);
               ast->rings = 1;
               p->subs[index].f.frametype = AST_FRAME_CONTROL;
               p->subs[index].f.subclass = AST_CONTROL_OFFHOOK;
               ast_log(LOG_DEBUG, "channel %d picked up\n", p->channel);
               return &p->subs[index].f;
            case AST_STATE_UP:
               /* Make sure it stops ringing */
               zt_set_hook(p->subs[index].zfd, ZT_OFFHOOK);
               /* Okay -- probably call waiting*/
               if (ast_bridged_channel(p->owner))
                     ast_moh_stop(ast_bridged_channel(p->owner));
               break;
            case AST_STATE_RESERVED:
               /* Start up dialtone */
               if (has_voicemail(p))
                  res = tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_STUTTER);
               else
                  res = tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_DIALTONE);
               break;
            default:
               ast_log(LOG_WARNING, "FXO phone off hook in weird state %d??\n", ast->_state);
            }
            break;
         case SIG_FXSLS:
         case SIG_FXSGS:
         case SIG_FXSKS:
            if (ast->_state == AST_STATE_RING) {
               p->ringt = p->ringt_base;
            }

            /* If we get a ring then we cannot be in 
             * reversed polarity. So we reset to idle */
            ast_log(LOG_DEBUG, "Setting IDLE polarity due "
               "to ring. Old polarity was %d\n", 
               p->polarity);
            p->polarity = POLARITY_IDLE;

            /* Fall through */
         case SIG_EM:
         case SIG_EM_E1:
         case SIG_EMWINK:
         case SIG_FEATD:
         case SIG_FEATDMF:
         case SIG_FEATDMF_TA:
         case SIG_E911:
         case SIG_FEATB:
         case SIG_SF:
         case SIG_SFWINK:
         case SIG_SF_FEATD:
         case SIG_SF_FEATDMF:
         case SIG_SF_FEATB:
            if (ast->_state == AST_STATE_PRERING)
               ast_setstate(ast, AST_STATE_RING);
            if ((ast->_state == AST_STATE_DOWN) || (ast->_state == AST_STATE_RING)) {
               if (option_debug)
                  ast_log(LOG_DEBUG, "Ring detected\n");
               p->subs[index].f.frametype = AST_FRAME_CONTROL;
               p->subs[index].f.subclass = AST_CONTROL_RING;
            } else if (p->outgoing && ((ast->_state == AST_STATE_RINGING) || (ast->_state == AST_STATE_DIALING))) {
               if (option_debug)
                  ast_log(LOG_DEBUG, "Line answered\n");
               if (p->confirmanswer) {
                  p->subs[index].f.frametype = AST_FRAME_NULL;
                  p->subs[index].f.subclass = 0;
               } else {
                  p->subs[index].f.frametype = AST_FRAME_CONTROL;
                  p->subs[index].f.subclass = AST_CONTROL_ANSWER;
                  ast_setstate(ast, AST_STATE_UP);
               }
            } else if (ast->_state != AST_STATE_RING)
               ast_log(LOG_WARNING, "Ring/Off-hook in strange state %d on channel %d\n", ast->_state, p->channel);
            break;
         default:
            ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig);
         }
         break;
#ifdef ZT_EVENT_RINGBEGIN
      case ZT_EVENT_RINGBEGIN:
         switch(p->sig) {
         case SIG_FXSLS:
         case SIG_FXSGS:
         case SIG_FXSKS:
            if (ast->_state == AST_STATE_RING) {
               p->ringt = p->ringt_base;
            }
            break;
         }
         break;
#endif         
      case ZT_EVENT_RINGEROFF:
         if (p->inalarm) break;
         if (p->radio) break;
         ast->rings++;
         if ((ast->rings > p->cidrings) && (p->cidspill)) {
            ast_log(LOG_WARNING, "Didn't finish Caller-ID spill.  Cancelling.\n");
            free(p->cidspill);
            p->cidspill = NULL;
            p->callwaitcas = 0;
         }
         p->subs[index].f.frametype = AST_FRAME_CONTROL;
         p->subs[index].f.subclass = AST_CONTROL_RINGING;
         break;
      case ZT_EVENT_RINGERON:
         break;
      case ZT_EVENT_NOALARM:
         p->inalarm = 0;
#ifdef ZAPATA_PRI
         /* Extremely unlikely but just in case */
         if (p->bearer)
            p->bearer->inalarm = 0;
#endif            
         ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel);
         manager_event(EVENT_FLAG_SYSTEM, "AlarmClear",
                        "Channel: %d\r\n", p->channel);
         break;
      case ZT_EVENT_WINKFLASH:
         if (p->inalarm) break;
         if (p->radio) break;
         /* Remember last time we got a flash-hook */
         gettimeofday(&p->flashtime, NULL);
         switch(p->sig) {
         case SIG_FXOLS:
         case SIG_FXOGS:
         case SIG_FXOKS:
            ast_log(LOG_DEBUG, "Winkflash, index: %d, normal: %d, callwait: %d, thirdcall: %d\n",
               index, p->subs[SUB_REAL].zfd, p->subs[SUB_CALLWAIT].zfd, p->subs[SUB_THREEWAY].zfd);
            p->callwaitcas = 0;

            if (index != SUB_REAL) {
               ast_log(LOG_WARNING, "Got flash hook with index %d on channel %d?!?\n", index, p->channel);
               goto winkflashdone;
            }
            
            if (p->subs[SUB_CALLWAIT].owner) {
               /* Swap to call-wait */
               swap_subs(p, SUB_REAL, SUB_CALLWAIT);
               tone_zone_play_tone(p->subs[SUB_REAL].zfd, -1);
               p->owner = p->subs[SUB_REAL].owner;
               ast_log(LOG_DEBUG, "Making %s the new owner\n", p->owner->name);
               if (p->owner->_state == AST_STATE_RINGING) {
                  ast_setstate(p->owner, AST_STATE_UP);
                  p->subs[SUB_REAL].needanswer = 1;
               }
               p->callwaitingrepeat = 0;
               p->cidcwexpire = 0;
               /* Start music on hold if appropriate */
               if (!p->subs[SUB_CALLWAIT].inthreeway && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner))
                  ast_moh_start(ast_bridged_channel(p->subs[SUB_CALLWAIT].owner), NULL);
               if (ast_bridged_channel(p->subs[SUB_REAL].owner))
                  ast_moh_stop(ast_bridged_channel(p->subs[SUB_REAL].owner));
            } else if (!p->subs[SUB_THREEWAY].owner) {
               char cid_num[256];
               char cid_name[256];

               if (!p->threewaycalling) {
                  /* Just send a flash if no 3-way calling */
                  p->subs[SUB_REAL].needflash = 1;
                  goto winkflashdone;
               } else if (!check_for_conference(p)) {
                  if (p->zaptrcallerid && p->owner) {
                     if (p->owner->cid.cid_num)
                        ast_copy_string(cid_num, p->owner->cid.cid_num, sizeof(cid_num));
                     if (p->owner->cid.cid_name)
                        ast_copy_string(cid_name, p->owner->cid.cid_name, sizeof(cid_name));
                  }
                  /* XXX This section needs much more error checking!!! XXX */
                  /* Start a 3-way call if feasible */
                  if (!((ast->pbx) ||
                        (ast->_state == AST_STATE_UP) ||
                        (ast->_state == AST_STATE_RING))) {
                     ast_log(LOG_DEBUG, "Flash when call not up or ringing\n");
                        goto winkflashdone;
                  }
                  if (alloc_sub(p, SUB_THREEWAY)) {
                     ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n");
                     goto winkflashdone;
                  }
                  /* Make new channel */
                  chan = zt_new(p, AST_STATE_RESERVED, 0, SUB_THREEWAY, 0, 0);
                  if (p->zaptrcallerid) {
                     if (!p->origcid_num)
                        p->origcid_num = strdup(p->cid_num);
                     if (!p->origcid_name)
                        p->origcid_name = strdup(p->cid_name);
                     ast_copy_string(p->cid_num, cid_num, sizeof(p->cid_num));
                     ast_copy_string(p->cid_name, cid_name, sizeof(p->cid_name));
                  }
                  /* Swap things around between the three-way and real call */
                  swap_subs(p, SUB_THREEWAY, SUB_REAL);
                  /* Disable echo canceller for better dialing */
                  zt_disable_ec(p);
                  res = tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_DIALRECALL);
                  if (res)
                     ast_log(LOG_WARNING, "Unable to start dial recall tone on channel %d\n", p->channel);
                  p->owner = chan;
                  pthread_attr_init(&attr);
                  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
                  if (!chan) {
                     ast_log(LOG_WARNING, "Cannot allocate new structure on channel %d\n", p->channel);
                  } else if (ast_pthread_create(&threadid, &attr, ss_thread, chan)) {
                     ast_log(LOG_WARNING, "Unable to start simple switch on channel %d\n", p->channel);
                     res = tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_CONGESTION);
                     zt_enable_ec(p);
                     ast_hangup(chan);
                  } else {
                     if (option_verbose > 2) 
                        ast_verbose(VERBOSE_PREFIX_3 "Started three way call on channel %d\n", p->channel);
                     /* Start music on hold if appropriate */
                     if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner))
                        ast_moh_start(ast_bridged_channel(p->subs[SUB_THREEWAY].owner), NULL);
                  }
                  pthread_attr_destroy(&attr);
               }
            } else {
               /* Already have a 3 way call */
               if (p->subs[SUB_THREEWAY].inthreeway) {
                  /* Call is already up, drop the last person */
                  if (option_debug)
                     ast_log(LOG_DEBUG, "Got flash with three way call up, dropping last call on %d\n", p->channel);
                  /* If the primary call isn't answered yet, use it */
                  if ((p->subs[SUB_REAL].owner->_state != AST_STATE_UP) && (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_UP)) {
                     /* Swap back -- we're dropping the real 3-way that isn't finished yet*/
                     swap_subs(p, SUB_THREEWAY, SUB_REAL);
                     p->owner = p->subs[SUB_REAL].owner;
                  }
                  /* Drop the last call and stop the conference */
                  if (option_verbose > 2)
                     ast_verbose(VERBOSE_PREFIX_3 "Dropping three-way call on %s\n", p->subs[SUB_THREEWAY].owner->name);
                  p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                  p->subs[SUB_REAL].inthreeway = 0;
                  p->subs[SUB_THREEWAY].inthreeway = 0;
               } else {
                  /* Lets see what we're up to */
                  if (((ast->pbx) || (ast->_state == AST_STATE_UP)) && 
                      (p->transfertobusy || (ast->_state != AST_STATE_BUSY))) {
                     int otherindex = SUB_THREEWAY;

                     if (option_verbose > 2)
                        ast_verbose(VERBOSE_PREFIX_3 "Building conference on call on %s and %s\n", p->subs[SUB_THREEWAY].owner->name, p->subs[SUB_REAL].owner->name);
                     /* Put them in the threeway, and flip */
                     p->subs[SUB_THREEWAY].inthreeway = 1;
                     p->subs[SUB_REAL].inthreeway = 1;
                     if (ast->_state == AST_STATE_UP) {
                        swap_subs(p, SUB_THREEWAY, SUB_REAL);
                        otherindex = SUB_REAL;
                     }
                     if (p->subs[otherindex].owner && ast_bridged_channel(p->subs[otherindex].owner))
                        ast_moh_stop(ast_bridged_channel(p->subs[otherindex].owner));
                     p->owner = p->subs[SUB_REAL].owner;
                     if (ast->_state == AST_STATE_RINGING) {
                        ast_log(LOG_DEBUG, "Enabling ringtone on real and threeway\n");
                        res = tone_zone_play_tone(p->subs[SUB_REAL].zfd, ZT_TONE_RINGTONE);
                        res = tone_zone_play_tone(p->subs[SUB_THREEWAY].zfd, ZT_TONE_RINGTONE);
                     }
                  } else {
                     if (option_verbose > 2)
                        ast_verbose(VERBOSE_PREFIX_3 "Dumping incomplete call on on %s\n", p->subs[SUB_THREEWAY].owner->name);
                     swap_subs(p, SUB_THREEWAY, SUB_REAL);
                     p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                     p->owner = p->subs[SUB_REAL].owner;
                     if (p->subs[SUB_REAL].owner && ast_bridged_channel(p->subs[SUB_REAL].owner))
                        ast_moh_stop(ast_bridged_channel(p->subs[SUB_REAL].owner));
                     zt_enable_ec(p);
                  }
                     
               }
            }
         winkflashdone:              
            update_conf(p);
            break;
         case SIG_EM:
         case SIG_EM_E1:
         case SIG_EMWINK:
         case SIG_FEATD:
         case SIG_SF:
         case SIG_SFWINK:
         case SIG_SF_FEATD:
         case SIG_FXSLS:
         case SIG_FXSGS:
            if (p->dialing)
               ast_log(LOG_DEBUG, "Ignoring wink on channel %d\n", p->channel);
            else
               ast_log(LOG_DEBUG, "Got wink in weird state %d on channel %d\n", ast->_state, p->channel);
            break;
         case SIG_FEATDMF_TA:
            switch (p->whichwink) {
            case 0:
               ast_log(LOG_DEBUG, "ANI2 set to '%d' and ANI is '%s'\n", p->owner->cid.cid_ani2, p->owner->cid.cid_ani);
               snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%d%s#", p->owner->cid.cid_ani2, p->owner->cid.cid_ani);
               break;
            case 1:
               ast_copy_string(p->dop.dialstr, p->finaldial, sizeof(p->dop.dialstr));
               break;
            case 2:
               ast_log(LOG_WARNING, "Received unexpected wink on channel of type SIG_FEATDMF_TA\n");
               return NULL;
            }
            p->whichwink++;
            /* Fall through */
         case SIG_FEATDMF:
         case SIG_E911:
         case SIG_FEATB:
         case SIG_SF_FEATDMF:
         case SIG_SF_FEATB:
            /* FGD MF *Must* wait for wink */
            if (!ast_strlen_zero(p->dop.dialstr))
               res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
            else if (res < 0) {
               ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d\n", p->channel);
               p->dop.dialstr[0] = '\0';
               return NULL;
            } else 
               ast_log(LOG_DEBUG, "Sent deferred digit string: %s\n", p->dop.dialstr);
            p->dop.dialstr[0] = '\0';
            break;
         default:
            ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig);
         }
         break;
      case ZT_EVENT_HOOKCOMPLETE:
         if (p->inalarm) break;
         if (p->radio) break;
         switch(p->sig) {
         case SIG_FXSLS:  /* only interesting for FXS */
         case SIG_FXSGS:
         case SIG_FXSKS:
         case SIG_EM:
         case SIG_EM_E1:
         case SIG_EMWINK:
         case SIG_FEATD:
         case SIG_SF:
         case SIG_SFWINK:
         case SIG_SF_FEATD:
            if (!ast_strlen_zero(p->dop.dialstr)) 
               res = ioctl(p->subs[SUB_REAL].zfd, ZT_DIAL, &p->dop);
            else if (res < 0) {
               ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d\n", p->channel);
               p->dop.dialstr[0] = '\0';
               return NULL;
            } else 
               ast_log(LOG_DEBUG, "Sent deferred digit string: %s\n", p->dop.dialstr);
            p->dop.dialstr[0] = '\0';
            p->dop.op = ZT_DIAL_OP_REPLACE;
            break;
         case SIG_FEATDMF:
         case SIG_E911:
         case SIG_FEATB:
         case SIG_SF_FEATDMF:
         case SIG_SF_FEATB:
            ast_log(LOG_DEBUG, "Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->channel);
            break;
         default:
            break;
         }
         break;
      case ZT_EVENT_POLARITY:
                        /*
                         * If we get a Polarity Switch event, check to see
                         * if we should change the polarity state and
                         * mark the channel as UP or if this is an indication
                         * of remote end disconnect.
                         */
                        if (p->polarity == POLARITY_IDLE) {
                                p->polarity = POLARITY_REV;
                                if (p->answeronpolarityswitch &&
                                    ((ast->_state == AST_STATE_DIALING) ||
                                     (ast->_state == AST_STATE_RINGING))) {
                                        ast_log(LOG_DEBUG, "Answering on polarity switch!\n");
                                        ast_setstate(p->owner, AST_STATE_UP);
               if(p->hanguponpolarityswitch) {
                  gettimeofday(&p->polaritydelaytv, NULL);
               }
               break;
                                } else
                                        ast_log(LOG_DEBUG, "Ignore switch to REVERSED Polarity on channel %d, state %d\n", p->channel, ast->_state);
         } 
         /* Removed else statement from here as it was preventing hangups from ever happening*/
         /* Added AST_STATE_RING in if statement below to deal with calling party hangups that take place when ringing */
         if(p->hanguponpolarityswitch &&
            (p->polarityonanswerdelay > 0) &&
                (p->polarity == POLARITY_REV) &&
            ((ast->_state == AST_STATE_UP) || (ast->_state == AST_STATE_RING)) ) {
                                /* Added log_debug information below to provide a better indication of what is going on */
            ast_log(LOG_DEBUG, "Polarity Reversal event occured - DEBUG 1: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) );
         
            if(ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) > p->polarityonanswerdelay) {
               ast_log(LOG_DEBUG, "Polarity Reversal detected and now Hanging up on channel %d\n", p->channel);
               ast_softhangup(p->owner, AST_SOFTHANGUP_EXPLICIT);
               p->polarity = POLARITY_IDLE;
            } else {
               ast_log(LOG_DEBUG, "Polarity Reversal detected but NOT hanging up (too close to answer event) on channel %d, state %d\n", p->channel, ast->_state);
            }
         } else {
            p->polarity = POLARITY_IDLE;
            ast_log(LOG_DEBUG, "Ignoring Polarity switch to IDLE on channel %d, state %d\n", p->channel, ast->_state);
         }
                        /* Added more log_debug information below to provide a better indication of what is going on */
         ast_log(LOG_DEBUG, "Polarity Reversal event occured - DEBUG 2: channel %d, state %d, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %d\n", p->channel, ast->_state, p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) );
         break;
      default:
         ast_log(LOG_DEBUG, "Dunno what to do with event %d on channel %d\n", res, p->channel);
   }
   return &p->subs[index].f;
}

static struct ast_frame *__zt_exception(struct ast_channel *ast)
{
   struct zt_pvt *p = ast->tech_pvt;
   int res;
   int usedindex=-1;
   int index;
   struct ast_frame *f;


   index = zt_get_index(ast, p, 1);
   
   p->subs[index].f.frametype = AST_FRAME_NULL;
   p->subs[index].f.datalen = 0;
   p->subs[index].f.samples = 0;
   p->subs[index].f.mallocd = 0;
   p->subs[index].f.offset = 0;
   p->subs[index].f.subclass = 0;
   p->subs[index].f.delivery = ast_tv(0,0);
   p->subs[index].f.src = "zt_exception";
   p->subs[index].f.data = NULL;
   
   
   if ((!p->owner) && (!p->radio)) {
      /* If nobody owns us, absorb the event appropriately, otherwise
         we loop indefinitely.  This occurs when, during call waiting, the
         other end hangs up our channel so that it no longer exists, but we
         have neither FLASH'd nor ONHOOK'd to signify our desire to
         change to the other channel. */
      if (p->fake_event) {
         res = p->fake_event;
         p->fake_event = 0;
      } else
         res = zt_get_event(p->subs[SUB_REAL].zfd);
      /* Switch to real if there is one and this isn't something really silly... */
      if ((res != ZT_EVENT_RINGEROFF) && (res != ZT_EVENT_RINGERON) &&
         (res != ZT_EVENT_HOOKCOMPLETE)) {
         ast_log(LOG_DEBUG, "Restoring owner of channel %d on event %d\n", p->channel, res);
         p->owner = p->subs[SUB_REAL].owner;
         if (p->owner && ast_bridged_channel(p->owner))
            ast_moh_stop(ast_bridged_channel(p->owner));
      }
      switch(res) {
      case ZT_EVENT_ONHOOK:
         zt_disable_ec(p);
         if (p->owner) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Channel %s still has call, ringing phone\n", p->owner->name);
            zt_ring_phone(p);
            p->callwaitingrepeat = 0;
            p->cidcwexpire = 0;
         } else
            ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n");
         update_conf(p);
         break;
      case ZT_EVENT_RINGOFFHOOK:
         zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
         if (p->owner && (p->owner->_state == AST_STATE_RINGING)) {
            p->subs[SUB_REAL].needanswer = 1;
            p->dialing = 0;
         }
         break;
      case ZT_EVENT_HOOKCOMPLETE:
      case ZT_EVENT_RINGERON:
      case ZT_EVENT_RINGEROFF:
         /* Do nothing */
         break;
      case ZT_EVENT_WINKFLASH:
         gettimeofday(&p->flashtime, NULL);
         if (p->owner) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Channel %d flashed to other channel %s\n", p->channel, p->owner->name);
            if (p->owner->_state != AST_STATE_UP) {
               /* Answer if necessary */
               usedindex = zt_get_index(p->owner, p, 0);
               if (usedindex > -1) {
                  p->subs[usedindex].needanswer = 1;
               }
               ast_setstate(p->owner, AST_STATE_UP);
            }
            p->callwaitingrepeat = 0;
            p->cidcwexpire = 0;
            if (ast_bridged_channel(p->owner))
               ast_moh_stop(ast_bridged_channel(p->owner));
         } else
            ast_log(LOG_WARNING, "Absorbed on hook, but nobody is left!?!?\n");
         update_conf(p);
         break;
      default:
         ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", event2str(res));
      }
      f = &p->subs[index].f;
      return f;
   }
   if (!p->radio) ast_log(LOG_DEBUG, "Exception on %d, channel %d\n", ast->fds[0],p->channel);
   /* If it's not us, return NULL immediately */
   if (ast != p->owner) {
      ast_log(LOG_WARNING, "We're %s, not %s\n", ast->name, p->owner->name);
      f = &p->subs[index].f;
      return f;
   }
   f = zt_handle_event(ast);
   return f;
}

struct ast_frame *zt_exception(struct ast_channel *ast)
{
   struct zt_pvt *p = ast->tech_pvt;
   struct ast_frame *f;
   ast_mutex_lock(&p->lock);
   f = __zt_exception(ast);
   ast_mutex_unlock(&p->lock);
   return f;
}

struct ast_frame  *zt_read(struct ast_channel *ast)
{
   struct zt_pvt *p = ast->tech_pvt;
   int res;
   int index;
   void *readbuf;
   struct ast_frame *f;
   

   ast_mutex_lock(&p->lock);
   
   index = zt_get_index(ast, p, 0);
   
   /* Hang up if we don't really exist */
   if (index < 0) {
      ast_log(LOG_WARNING, "We dont exist?\n");
      ast_mutex_unlock(&p->lock);
      return NULL;
   }
   
   if (p->radio && p->inalarm) return NULL;

   p->subs[index].f.frametype = AST_FRAME_NULL;
   p->subs[index].f.datalen = 0;
   p->subs[index].f.samples = 0;
   p->subs[index].f.mallocd = 0;
   p->subs[index].f.offset = 0;
   p->subs[index].f.subclass = 0;
   p->subs[index].f.delivery = ast_tv(0,0);
   p->subs[index].f.src = "zt_read";
   p->subs[index].f.data = NULL;
   
   /* make sure it sends initial key state as first frame */
   if (p->radio && (!p->firstradio))
   {
      ZT_PARAMS ps;

      ps.channo = p->channel;
      if (ioctl(p->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &ps) < 0) {
         ast_mutex_unlock(&p->lock);
         return NULL;
      }
      p->firstradio = 1;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      if (ps.rxisoffhook)
      {
         p->subs[index].f.subclass = AST_CONTROL_RADIO_KEY;
      }
      else
      {
         p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY;
      }
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }
   if (p->ringt == 1) {
      ast_mutex_unlock(&p->lock);
      return NULL;
   }
   else if (p->ringt > 0) 
      p->ringt--;

   if (p->subs[index].needringing) {
      /* Send ringing frame if requested */
      p->subs[index].needringing = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_RINGING;
      ast_setstate(ast, AST_STATE_RINGING);
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }

   if (p->subs[index].needbusy) {
      /* Send busy frame if requested */
      p->subs[index].needbusy = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_BUSY;
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }

   if (p->subs[index].needcongestion) {
      /* Send congestion frame if requested */
      p->subs[index].needcongestion = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_CONGESTION;
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }

   if (p->subs[index].needcallerid) {
      ast_set_callerid(ast, !ast_strlen_zero(p->lastcid_num) ? p->lastcid_num : NULL, 
                     !ast_strlen_zero(p->lastcid_name) ? p->lastcid_name : NULL,
                     !ast_strlen_zero(p->lastcid_num) ? p->lastcid_num : NULL
                     );
      p->subs[index].needcallerid = 0;
   }
   
   if (p->subs[index].needanswer) {
      /* Send answer frame if requested */
      p->subs[index].needanswer = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_ANSWER;
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }  
   
   if (p->subs[index].needflash) {
      /* Send answer frame if requested */
      p->subs[index].needflash = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_FLASH;
      ast_mutex_unlock(&p->lock);
      return &p->subs[index].f;
   }  
   
   if (ast->rawreadformat == AST_FORMAT_SLINEAR) {
      if (!p->subs[index].linear) {
         p->subs[index].linear = 1;
         res = zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
         if (res) 
            ast_log(LOG_WARNING, "Unable to set channel %d (index %d) to linear mode.\n", p->channel, index);
      }
   } else if ((ast->rawreadformat == AST_FORMAT_ULAW) ||
         (ast->rawreadformat == AST_FORMAT_ALAW)) {
      if (p->subs[index].linear) {
         p->subs[index].linear = 0;
         res = zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
         if (res) 
            ast_log(LOG_WARNING, "Unable to set channel %d (index %d) to companded mode.\n", p->channel, index);
      }
   } else {
      ast_log(LOG_WARNING, "Don't know how to read frames in format %s\n", ast_getformatname(ast->rawreadformat));
      ast_mutex_unlock(&p->lock);
      return NULL;
   }
   readbuf = ((unsigned char *)p->subs[index].buffer) + AST_FRIENDLY_OFFSET;
   CHECK_BLOCKING(ast);
   res = read(p->subs[index].zfd, readbuf, p->subs[index].linear ? READ_SIZE * 2 : READ_SIZE);
   ast_clear_flag(ast, AST_FLAG_BLOCKING);
   /* Check for hangup */
   if (res < 0) {
      f = NULL;
      if (res == -1)  {
         if (errno == EAGAIN) {
            /* Return "NULL" frame if there is nobody there */
            ast_mutex_unlock(&p->lock);
            return &p->subs[index].f;
         } else if (errno == ELAST) {
            f = __zt_exception(ast);
         } else
            ast_log(LOG_WARNING, "zt_rec: %s\n", strerror(errno));
      }
      ast_mutex_unlock(&p->lock);
      return f;
   }
   if (res != (p->subs[index].linear ? READ_SIZE * 2 : READ_SIZE)) {
      ast_log(LOG_DEBUG, "Short read (%d/%d), must be an event...\n", res, p->subs[index].linear ? READ_SIZE * 2 : READ_SIZE);
      f = __zt_exception(ast);
      ast_mutex_unlock(&p->lock);
      return f;
   }
   if (p->tdd) { /* if in TDD mode, see if we receive that */
      int c;

      c = tdd_feed(p->tdd,readbuf,READ_SIZE);
      if (c < 0) {
         ast_log(LOG_DEBUG,"tdd_feed failed\n");
         ast_mutex_unlock(&p->lock);
         return NULL;
      }
      if (c) { /* if a char to return */
         p->subs[index].f.subclass = 0;
         p->subs[index].f.frametype = AST_FRAME_TEXT;
         p->subs[index].f.mallocd = 0;
         p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
         p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET;
         p->subs[index].f.datalen = 1;
         *((char *) p->subs[index].f.data) = c;
         ast_mutex_unlock(&p->lock);
         return &p->subs[index].f;
      }
   }
   if (p->callwaitingrepeat)
      p->callwaitingrepeat--;
   if (p->cidcwexpire)
      p->cidcwexpire--;
   /* Repeat callwaiting */
   if (p->callwaitingrepeat == 1) {
      p->callwaitrings++;
      zt_callwait(ast);
   }
   /* Expire CID/CW */
   if (p->cidcwexpire == 1) {
      if (option_verbose > 2)
         ast_verbose(VERBOSE_PREFIX_3 "CPE does not support Call Waiting Caller*ID.\n");
      restore_conference(p);
   }
   if (p->subs[index].linear) {
      p->subs[index].f.datalen = READ_SIZE * 2;
   } else 
      p->subs[index].f.datalen = READ_SIZE;

   /* Handle CallerID Transmission */
   if ((p->owner == ast) && p->cidspill &&((ast->_state == AST_STATE_UP) || (ast->rings == p->cidrings))) {
      send_callerid(p);
   }

   p->subs[index].f.frametype = AST_FRAME_VOICE;
   p->subs[index].f.subclass = ast->rawreadformat;
   p->subs[index].f.samples = READ_SIZE;
   p->subs[index].f.mallocd = 0;
   p->subs[index].f.offset = AST_FRIENDLY_OFFSET;
   p->subs[index].f.data = p->subs[index].buffer + AST_FRIENDLY_OFFSET/2;
#if 0
   ast_log(LOG_DEBUG, "Read %d of voice on %s\n", p->subs[index].f.datalen, ast->name);
#endif   
   if (p->dialing || /* Transmitting something */
      (index && (ast->_state != AST_STATE_UP)) || /* Three-way or callwait that isn't up */
      ((index == SUB_CALLWAIT) && !p->subs[SUB_CALLWAIT].inthreeway) /* Inactive and non-confed call-wait */
      ) {
      /* Whoops, we're still dialing, or in a state where we shouldn't transmit....
         don't send anything */
      p->subs[index].f.frametype = AST_FRAME_NULL;
      p->subs[index].f.subclass = 0;
      p->subs[index].f.samples = 0;
      p->subs[index].f.mallocd = 0;
      p->subs[index].f.offset = 0;
      p->subs[index].f.data = NULL;
      p->subs[index].f.datalen= 0;
   }
   if (p->dsp && (!p->ignoredtmf || p->callwaitcas || p->busydetect  || p->callprogress) && !index) {
      /* Perform busy detection. etc on the zap line */
      f = ast_dsp_process(ast, p->dsp, &p->subs[index].f);
      if (f) {
         if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_BUSY)) {
            if ((ast->_state == AST_STATE_UP) && !p->outgoing) {
               /* Treat this as a "hangup" instead of a "busy" on the assumption that
                  a busy  */
               f = NULL;
            }
         } else if (f->frametype == AST_FRAME_DTMF) {
#ifdef ZAPATA_PRI
            if (!p->proceeding && p->sig==SIG_PRI && p->pri && p->pri->overlapdial) {
               /* Don't accept in-band DTMF when in overlap dial mode */
               f->frametype = AST_FRAME_NULL;
               f->subclass = 0;
            }
#endif            
            /* DSP clears us of being pulse */
            p->pulsedial = 0;
         }
      }
   } else 
      f = &p->subs[index].f; 
   if (f && (f->frametype == AST_FRAME_DTMF))
      zt_handle_dtmfup(ast, index, &f);

   /* If we have a fake_event, trigger exception to handle it */
   if (p->fake_event)
      ast_set_flag(ast, AST_FLAG_EXCEPTION);

   ast_mutex_unlock(&p->lock);
   return f;
}

static int my_zt_write(struct zt_pvt *p, unsigned char *buf, int len, int index, int linear)
{
   int sent=0;
   int size;
   int res;
   int fd;
   fd = p->subs[index].zfd;
   while(len) {
      size = len;
      if (size > (linear ? READ_SIZE * 2 : READ_SIZE))
         size = (linear ? READ_SIZE * 2 : READ_SIZE);
      res = write(fd, buf, size);
      if (res != size) {
         if (option_debug)
            ast_log(LOG_DEBUG, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
         return sent;
      }
      len -= size;
      buf += size;
   }
   return sent;
}

static int zt_write(struct ast_channel *ast, struct ast_frame *frame)
{
   struct zt_pvt *p = ast->tech_pvt;
   int res;
   unsigned char outbuf[4096];
   int index;
   index = zt_get_index(ast, p, 0);
   if (index < 0) {
      ast_log(LOG_WARNING, "%s doesn't really exist?\n", ast->name);
      return -1;
   }

#if 0
#ifdef ZAPATA_PRI
   ast_mutex_lock(&p->lock);
   if (!p->proceeding && p->sig==SIG_PRI && p->pri && !p->outgoing) {
      if (p->pri->pri) {      
         if (!pri_grab(p, p->pri)) {
               pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital);
               pri_rel(p->pri);
         } else
               ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
      }
      p->proceeding=1;
   }
   ast_mutex_unlock(&p->lock);
#endif
#endif
   /* Write a frame of (presumably voice) data */
   if (frame->frametype != AST_FRAME_VOICE) {
      if (frame->frametype != AST_FRAME_IMAGE)
         ast_log(LOG_WARNING, "Don't know what to do with frame type '%d'\n", frame->frametype);
      return 0;
   }
   if ((frame->subclass != AST_FORMAT_SLINEAR) && 
       (frame->subclass != AST_FORMAT_ULAW) &&
       (frame->subclass != AST_FORMAT_ALAW)) {
      ast_log(LOG_WARNING, "Cannot handle frames in %d format\n", frame->subclass);
      return -1;
   }
   if (p->dialing) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Dropping frame since I'm still dialing on %s...\n",ast->name);
      return 0;
   }
   if (!p->owner) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Dropping frame since there is no active owner on %s...\n",ast->name);
      return 0;
   }
   if (p->cidspill) {
      if (option_debug)
         ast_log(LOG_DEBUG, "Dropping frame since I've still got a callerid spill\n");
      return 0;
   }
   /* Return if it's not valid data */
   if (!frame->data || !frame->datalen)
      return 0;
   if (frame->datalen > sizeof(outbuf) * 2) {
      ast_log(LOG_WARNING, "Frame too large\n");
      return 0;
   }

   if (frame->subclass == AST_FORMAT_SLINEAR) {
      if (!p->subs[index].linear) {
         p->subs[index].linear = 1;
         res = zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
         if (res)
            ast_log(LOG_WARNING, "Unable to set linear mode on channel %d\n", p->channel);
      }
      res = my_zt_write(p, (unsigned char *)frame->data, frame->datalen, index, 1);
   } else {
      /* x-law already */
      if (p->subs[index].linear) {
         p->subs[index].linear = 0;
         res = zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
         if (res)
            ast_log(LOG_WARNING, "Unable to set companded mode on channel %d\n", p->channel);
      }
      res = my_zt_write(p, (unsigned char *)frame->data, frame->datalen, index, 0);
   }
   if (res < 0) {
      ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
      return -1;
   } 
   return 0;
}

static int zt_indicate(struct ast_channel *chan, int condition)
{
   struct zt_pvt *p = chan->tech_pvt;
   int res=-1;
   int index;
   int func = ZT_FLASH;
   ast_mutex_lock(&p->lock);
   index = zt_get_index(chan, p, 0);
   ast_log(LOG_DEBUG, "Requested indication %d on channel %s\n", condition, chan->name);
   if (index == SUB_REAL) {
      switch(condition) {
      case AST_CONTROL_BUSY:
#ifdef ZAPATA_PRI
         if (p->priindication_oob && p->sig == SIG_PRI) {
            chan->hangupcause = AST_CAUSE_USER_BUSY;
            chan->_softhangup |= AST_SOFTHANGUP_DEV;
            res = 0;
         } else if (!p->progress && p->sig==SIG_PRI && p->pri && !p->outgoing) {
            if (p->pri->pri) {      
               if (!pri_grab(p, p->pri)) {
                  pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
                  pri_rel(p->pri);
               }
               else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
            }
            p->progress = 1;
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_BUSY);
         } else
#endif
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_BUSY);
         break;
      case AST_CONTROL_RINGING:
#ifdef ZAPATA_PRI
         if ((!p->alerting) && p->sig==SIG_PRI && p->pri && !p->outgoing && (chan->_state != AST_STATE_UP)) {
            if (p->pri->pri) {      
               if (!pri_grab(p, p->pri)) {
                  pri_acknowledge(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital);
                  pri_rel(p->pri);
               }
               else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
            }
            p->alerting = 1;
         }
#endif
         res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_RINGTONE);
         if (chan->_state != AST_STATE_UP && chan->_state != AST_STATE_RING) {
            if ((p->sig != SIG_FXSKS) &&
                (p->sig != SIG_FXSLS) &&
                (p->sig != SIG_FXSGS))
               ast_setstate(chan, AST_STATE_RINGING);
         }
         break;
      case AST_CONTROL_PROCEEDING:
         ast_log(LOG_DEBUG,"Received AST_CONTROL_PROCEEDING on %s\n",chan->name);
#ifdef ZAPATA_PRI
         if (!p->proceeding && p->sig==SIG_PRI && p->pri && !p->outgoing) {
            if (p->pri->pri) {      
               if (!pri_grab(p, p->pri)) {
                  pri_proceeding(p->pri->pri,p->call, PVT_TO_CHANNEL(p), !p->digital);
                  pri_rel(p->pri);
               }
               else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
            }
            p->proceeding = 1;
         }
#endif
         /* don't continue in ast_indicate */
         res = 0;
         break;
      case AST_CONTROL_PROGRESS:
         ast_log(LOG_DEBUG,"Received AST_CONTROL_PROGRESS on %s\n",chan->name);
#ifdef ZAPATA_PRI
         p->digital = 0;   /* Digital-only calls isn't allows any inband progress messages */
         if (!p->progress && p->sig==SIG_PRI && p->pri && !p->outgoing) {
            if (p->pri->pri) {      
               if (!pri_grab(p, p->pri)) {
                  pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
                  pri_rel(p->pri);
               }
               else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
            }
            p->progress = 1;
         }
#endif
         /* don't continue in ast_indicate */
         res = 0;
         break;
      case AST_CONTROL_CONGESTION:
         chan->hangupcause = AST_CAUSE_CONGESTION;
#ifdef ZAPATA_PRI
         if (p->priindication_oob && p->sig == SIG_PRI) {
            chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
            chan->_softhangup |= AST_SOFTHANGUP_DEV;
            res = 0;
         } else if (!p->progress && p->sig==SIG_PRI && p->pri && !p->outgoing) {
            if (p->pri) {     
               if (!pri_grab(p, p->pri)) {
                  pri_progress(p->pri->pri,p->call, PVT_TO_CHANNEL(p), 1);
                  pri_rel(p->pri);
               } else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);
            }
            p->progress = 1;
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
         } else
#endif
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
         break;
#ifdef ZAPATA_PRI
      case AST_CONTROL_HOLD:
         if (p->pri) {
            if (!pri_grab(p, p->pri)) {
               res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_HOLD);
               pri_rel(p->pri);
            } else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);       
         }
         break;
      case AST_CONTROL_UNHOLD:
         if (p->pri) {
            if (!pri_grab(p, p->pri)) {
               res = pri_notify(p->pri->pri, p->call, p->prioffset, PRI_NOTIFY_REMOTE_RETRIEVAL);
               pri_rel(p->pri);
            } else
                  ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->span);       
         }
         break;
#endif
      case AST_CONTROL_RADIO_KEY:
         if (p->radio) 
             res =  zt_set_hook(p->subs[index].zfd, ZT_OFFHOOK);
         res = 0;
         break;
      case AST_CONTROL_RADIO_UNKEY:
         if (p->radio)
             res =  zt_set_hook(p->subs[index].zfd, ZT_RINGOFF);
         res = 0;
         break;
      case AST_CONTROL_FLASH:
         /* flash hookswitch */
         if (ISTRUNK(p) && (p->sig != SIG_PRI)) {
            /* Clear out the dial buffer */
            p->dop.dialstr[0] = '\0';
            if ((ioctl(p->subs[SUB_REAL].zfd,ZT_HOOK,&func) == -1) && (errno != EINPROGRESS)) {
               ast_log(LOG_WARNING, "Unable to flash external trunk on channel %s: %s\n", 
                  chan->name, strerror(errno));
            } else
               res = 0;
         } else
            res = 0;
         break;
      case -1:
         res = tone_zone_play_tone(p->subs[index].zfd, -1);
         break;
      }
   } else
      res = 0;
   ast_mutex_unlock(&p->lock);
   return res;
}

static struct ast_channel *zt_new(struct zt_pvt *i, int state, int startpbx, int index, int law, int transfercapability)
{
   struct ast_channel *tmp;
   int deflaw;
   int res;
   int x,y;
   int features;
   ZT_PARAMS ps;
   if (i->subs[index].owner) {
      ast_log(LOG_WARNING, "Channel %d already has a %s call\n", i->channel,subnames[index]);
      return NULL;
   }
   tmp = ast_channel_alloc(0);
   if (tmp) {
      tmp->tech = &zap_tech;
      ps.channo = i->channel;
      res = ioctl(i->subs[SUB_REAL].zfd, ZT_GET_PARAMS, &ps);
      if (res) {
         ast_log(LOG_WARNING, "Unable to get parameters, assuming MULAW\n");
         ps.curlaw = ZT_LAW_MULAW;
      }
      if (ps.curlaw == ZT_LAW_ALAW)
         deflaw = AST_FORMAT_ALAW;
      else
         deflaw = AST_FORMAT_ULAW;
      if (law) {
         if (law == ZT_LAW_ALAW)
            deflaw = AST_FORMAT_ALAW;
         else
            deflaw = AST_FORMAT_ULAW;
      }
      y = 1;
      do {
#ifdef ZAPATA_PRI
         if (i->bearer || (i->pri && (i->sig == SIG_FXSKS)))
            snprintf(tmp->name, sizeof(tmp->name), "Zap/%d:%d-%d", i->pri->trunkgroup, i->channel, y);
         else
#endif
         if (i->channel == CHAN_PSEUDO)
            snprintf(tmp->name, sizeof(tmp->name), "Zap/pseudo-%d", rand());
         else  
            snprintf(tmp->name, sizeof(tmp->name), "Zap/%d-%d", i->channel, y);
         for (x=0;x<3;x++) {
            if ((index != x) && i->subs[x].owner && !strcasecmp(tmp->name, i->subs[x].owner->name))
               break;
         }
         y++;
      } while (x < 3);
      tmp->type = type;
      tmp->fds[0] = i->subs[index].zfd;
      tmp->nativeformats = AST_FORMAT_SLINEAR | deflaw;
      /* Start out assuming ulaw since it's smaller :) */
      tmp->rawreadformat = deflaw;
      tmp->readformat = deflaw;
      tmp->rawwriteformat = deflaw;
      tmp->writeformat = deflaw;
      i->subs[index].linear = 0;
      zt_setlinear(i->subs[index].zfd, i->subs[index].linear);
      features = 0;
      if (index == SUB_REAL) {
         if (i->busydetect && CANBUSYDETECT(i)) {
            features |= DSP_FEATURE_BUSY_DETECT;
         }
         if ((i->callprogress & 1) && CANPROGRESSDETECT(i)) {
            features |= DSP_FEATURE_CALL_PROGRESS;
         }
         if ((!i->outgoing && (i->callprogress & 4)) || 
             (i->outgoing && (i->callprogress & 2))) {
            features |= DSP_FEATURE_FAX_DETECT;
         }
#ifdef ZT_TONEDETECT
         x = ZT_TONEDETECT_ON | ZT_TONEDETECT_MUTE;
         if (ioctl(i->subs[index].zfd, ZT_TONEDETECT, &x)) {
#endif      
            i->hardwaredtmf = 0;
            features |= DSP_FEATURE_DTMF_DETECT;
#ifdef ZT_TONEDETECT
         } else if (NEED_MFDETECT(i)) {
            i->hardwaredtmf = 1;
            features |= DSP_FEATURE_DTMF_DETECT;
         }
#endif
      }
      if (features) {
         if (i->dsp) {
            ast_log(LOG_DEBUG, "Already have a dsp on %s?\n", tmp->name);
         } else {
            if (i->channel != CHAN_PSEUDO)
               i->dsp = ast_dsp_new();
            else
               i->dsp = NULL;
            if (i->dsp) {
               i->dsp_features = features & ~DSP_PROGRESS_TALK;
#ifdef ZAPATA_PRI
               /* We cannot do progress detection until receives PROGRESS message */
               if (i->outgoing && (i->sig == SIG_PRI)) {
                  /* Remember requested DSP features, don't treat
                     talking as ANSWER */
                  features = 0;
               }
#endif
               ast_dsp_set_features(i->dsp, features);
               ast_dsp_digitmode(i->dsp, DSP_DIGITMODE_DTMF | i->dtmfrelax);
               if (!ast_strlen_zero(progzone))
                  ast_dsp_set_call_progress_zone(i->dsp, progzone);
               if (i->busydetect && CANBUSYDETECT(i)) {
                  ast_dsp_set_busy_count(i->dsp, i->busycount);
                  ast_dsp_set_busy_pattern(i->dsp, i->busy_tonelength, i->busy_quietlength);
               }
            }
         }
      }
      
      if (state == AST_STATE_RING)
         tmp->rings = 1;
      tmp->tech_pvt = i;
      if ((i->sig == SIG_FXOKS) || (i->sig == SIG_FXOGS) || (i->sig == SIG_FXOLS)) {
         /* Only FXO signalled stuff can be picked up */
         tmp->callgroup = i->callgroup;
         tmp->pickupgroup = i->pickupgroup;
      }
      if (!ast_strlen_zero(i->language))
         ast_copy_string(tmp->language, i->language, sizeof(tmp->language));
      if (!ast_strlen_zero(i->musicclass))
         ast_copy_string(tmp->musicclass, i->musicclass, sizeof(tmp->musicclass));
      if (!i->owner)
         i->owner = tmp;
      if (!ast_strlen_zero(i->accountcode))
         ast_copy_string(tmp->accountcode, i->accountcode, sizeof(tmp->accountcode));
      if (i->amaflags)
         tmp->amaflags = i->amaflags;
      i->subs[index].owner = tmp;
      ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
      /* Copy call forward info */
      ast_copy_string(tmp->call_forward, i->call_forward, sizeof(tmp->call_forward));
      /* If we've been told "no ADSI" then enforce it */
      if (!i->adsi)
         tmp->adsicpe = AST_ADSI_UNAVAILABLE;
      if (!ast_strlen_zero(i->exten))
         ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
      if (!ast_strlen_zero(i->rdnis))
         tmp->cid.cid_rdnis = strdup(i->rdnis);
      if (!ast_strlen_zero(i->dnid))
         tmp->cid.cid_dnid = strdup(i->dnid);

#ifdef PRI_ANI
      if (!ast_strlen_zero(i->cid_num))
         tmp->cid.cid_num = strdup(i->cid_num);
      if (!ast_strlen_zero(i->cid_name))
         tmp->cid.cid_name = strdup(i->cid_name);
      if (!ast_strlen_zero(i->cid_ani))
         tmp->cid.cid_ani = strdup(i->cid_ani);
      else if (!ast_strlen_zero(i->cid_num)) 
         tmp->cid.cid_ani = strdup(i->cid_num);
#else
      if (!ast_strlen_zero(i->cid_num)) {
         tmp->cid.cid_num = strdup(i->cid_num);
         tmp->cid.cid_ani = strdup(i->cid_num);
      }
      if (!ast_strlen_zero(i->cid_name))
         tmp->cid.cid_name = strdup(i->cid_name);
#endif
      tmp->cid.cid_pres = i->callingpres;
      tmp->cid.cid_ton = i->cid_ton;
#ifdef ZAPATA_PRI
      tmp->transfercapability = transfercapability;
      pbx_builtin_setvar_helper(tmp, "TRANSFERCAPABILITY", ast_transfercapability2str(transfercapability));
      if (transfercapability & PRI_TRANS_CAP_DIGITAL) {
         i->digital = 1;
      }
      /* Assume calls are not idle calls unless we're told differently */
      i->isidlecall = 0;
      i->alreadyhungup = 0;
#endif
      /* clear the fake event in case we posted one before we had ast_channel */
      i->fake_event = 0;
      /* Assure there is no confmute on this channel */
      zt_confmute(i, 0);
      ast_setstate(tmp, state);
      ast_mutex_lock(&usecnt_lock);
      usecnt++;
      ast_mutex_unlock(&usecnt_lock);
      ast_update_use_count();
      if (startpbx) {
         if (ast_pbx_start(tmp)) {
            ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
            ast_hangup(tmp);
            tmp = NULL;
         }
      }
   } else
      ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
   return tmp;
}


static int my_getsigstr(struct ast_channel *chan, char *str, const char *term, int ms)
{
   char c;

   *str = 0; /* start with empty output buffer */
   for (;;)
   {
      /* Wait for the first digit (up to specified ms). */
      c = ast_waitfordigit(chan, ms);
      /* if timeout, hangup or error, return as such */
      if (c < 1)
         return c;
      *str++ = c;
      *str = 0;
      if (strchr(term, c))
         return 1;
   }
}

static int zt_wink(struct zt_pvt *p, int index)
{
   int j;
   zt_set_hook(p->subs[index].zfd, ZT_WINK);
   for(;;)
   {
         /* set bits of interest */
      j = ZT_IOMUX_SIGEVENT;
          /* wait for some happening */
      if (ioctl(p->subs[index].zfd,ZT_IOMUX,&j) == -1) return(-1);
         /* exit loop if we have it */
      if (j & ZT_IOMUX_SIGEVENT) break;
   }
     /* get the event info */
   if (ioctl(p->subs[index].zfd,ZT_GETEVENT,&j) == -1) return(-1);
   return 0;
}

static void *ss_thread(void *data)
{
   struct ast_channel *chan = data;
   struct zt_pvt *p = chan->tech_pvt;
   char exten[AST_MAX_EXTENSION]="";
   char exten2[AST_MAX_EXTENSION]="";
   unsigned char buf[256];
   char dtmfcid[300];
   char dtmfbuf[300];
   struct callerid_state *cs;
   char *name=NULL, *number=NULL;
   int distMatches;
   int curRingData[3];
   int receivedRingT;
   int counter1;
   int counter;
   int samples = 0;

   int flags;
   int i;
   int timeout;
   int getforward=0;
   char *s1, *s2;
   int len = 0;
   int res;
   int index;

   /* in the bizarre case where the channel has become a zombie before we
      even get started here, abort safely
   */
   if (!p) {
      ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name);
      ast_hangup(chan);
      return NULL;
   }

   if (option_verbose > 2) 
      ast_verbose( VERBOSE_PREFIX_3 "Starting simple switch on '%s'\n", chan->name);
   index = zt_get_index(chan, p, 1);
   if (index < 0) {
      ast_log(LOG_WARNING, "Huh?\n");
      ast_hangup(chan);
      return NULL;
   }
   if (p->dsp)
      ast_dsp_digitreset(p->dsp);
   switch(p->sig) {
#ifdef ZAPATA_PRI
   case SIG_PRI:
      /* Now loop looking for an extension */
      ast_copy_string(exten, p->exten, sizeof(exten));
      len = strlen(exten);
      res = 0;
      while((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
         if (len && !ast_ignore_pattern(chan->context, exten))
            tone_zone_play_tone(p->subs[index].zfd, -1);
         else
            tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALTONE);
         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
            timeout = matchdigittimeout;
         else
            timeout = gendigittimeout;
         res = ast_waitfordigit(chan, timeout);
         if (res < 0) {
            ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
            ast_hangup(chan);
            return NULL;
         } else if (res) {
            exten[len++] = res;
            exten[len] = '\0';
         } else
            break;
      }
      /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
      if (ast_strlen_zero(exten)) {
         if (option_verbose > 2)
            ast_verbose(VERBOSE_PREFIX_3 "Going to extension s|1 because of empty extension received on overlap call\n");
         exten[0] = 's';
         exten[1] = '\0';
      }
      tone_zone_play_tone(p->subs[index].zfd, -1);
      if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
         /* Start the real PBX */
         ast_copy_string(chan->exten, exten, sizeof(chan->exten));
         if (p->dsp) ast_dsp_digitreset(p->dsp);
         zt_enable_ec(p);
         ast_setstate(chan, AST_STATE_RING);
         res = ast_pbx_run(chan);
         if (res) {
            ast_log(LOG_WARNING, "PBX exited non-zero!\n");
         }
      } else {
         ast_log(LOG_DEBUG, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
         chan->hangupcause = AST_CAUSE_UNALLOCATED;
         ast_hangup(chan);
         p->exten[0] = '\0';
         /* Since we send release complete here, we won't get one */
         p->call = NULL;
      }
      return NULL;
      break;
#endif
   case SIG_FEATD:
   case SIG_FEATDMF:
   case SIG_E911:
   case SIG_FEATB:
   case SIG_EMWINK:
   case SIG_SF_FEATD:
   case SIG_SF_FEATDMF:
   case SIG_SF_FEATB:
   case SIG_SFWINK:
      if (zt_wink(p, index))  
         return NULL;
      /* Fall through */
   case SIG_EM:
   case SIG_EM_E1:
   case SIG_SF:
      res = tone_zone_play_tone(p->subs[index].zfd, -1);
      if (p->dsp)
         ast_dsp_digitreset(p->dsp);
      /* set digit mode appropriately */
      if (p->dsp) {
         if (NEED_MFDETECT(p))
            ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_MF | p->dtmfrelax); 
         else 
            ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax);
      }
      memset(dtmfbuf, 0, sizeof(dtmfbuf));
      /* Wait for the first digit only if immediate=no */
      if (!p->immediate)
         /* Wait for the first digit (up to 5 seconds). */
         res = ast_waitfordigit(chan, 5000);
      else res = 0;
      if (res > 0) {
         /* save first char */
         dtmfbuf[0] = res;
         switch(p->sig) {
         case SIG_FEATD:
         case SIG_SF_FEATD:
            res = my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
            if (res > 0)
               res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
            if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
            break;
         case SIG_FEATDMF:
         case SIG_E911:
         case SIG_SF_FEATDMF:
            res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
            if (res > 0) {
               /* if E911, take off hook */
               if (p->sig == SIG_E911)
                  zt_set_hook(p->subs[SUB_REAL].zfd, ZT_OFFHOOK);
               res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "#", 3000);
            }
            if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
            break;
         case SIG_FEATB:
         case SIG_SF_FEATB:
            res = my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
            if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
            break;
         case SIG_EMWINK:
            /* if we received a '*', we are actually receiving Feature Group D
               dial syntax, so use that mode; otherwise, fall through to normal
               mode
            */
            if (res == '*') {
               res = my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
               if (res > 0)
                  res = my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
               if ((res < 1) && (p->dsp)) ast_dsp_digitreset(p->dsp);
               break;
            }
         default:
            /* If we got the first digit, get the rest */
            len = 1;
            dtmfbuf[len] = '\0';
            while((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, chan->context, dtmfbuf, 1, p->cid_num)) {
               if (ast_exists_extension(chan, chan->context, dtmfbuf, 1, p->cid_num)) {
                  timeout = matchdigittimeout;
               } else {
                  timeout = gendigittimeout;
               }
               res = ast_waitfordigit(chan, timeout);
               if (res < 0) {
                  ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
                  ast_hangup(chan);
                  return NULL;
               } else if (res) {
                  dtmfbuf[len++] = res;
                  dtmfbuf[len] = '\0';
               } else {
                  break;
               }
            }
            break;
         }
      }
      if (res == -1) {
         ast_log(LOG_WARNING, "getdtmf on channel %d: %s\n", p->channel, strerror(errno));
         ast_hangup(chan);
         return NULL;
      } else if (res < 0) {
         ast_log(LOG_DEBUG, "Got hung up before digits finished\n");
         ast_hangup(chan);
         return NULL;
      }
      ast_copy_string(exten, dtmfbuf, sizeof(exten));
      if (ast_strlen_zero(exten))
         ast_copy_string(exten, "s", sizeof(exten));
      if (p->sig == SIG_FEATD || p->sig == SIG_EMWINK) {
         /* Look for Feature Group D on all E&M Wink and Feature Group D trunks */
         if (exten[0] == '*') {
            char *stringp=NULL;
            ast_copy_string(exten2, exten, sizeof(exten2));
            /* Parse out extension and callerid */
            stringp=exten2 +1;
            s1 = strsep(&stringp, "*");
            s2 = strsep(&stringp, "*");
            if (s2) {
               if (!ast_strlen_zero(p->cid_num))
                  ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
               else
                  ast_set_callerid(chan, s1, NULL, s1);
               ast_copy_string(exten, s2, sizeof(exten));
            } else
               ast_copy_string(exten, s1, sizeof(exten));
         } else if (p->sig == SIG_FEATD)
            ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d.  Assuming E&M Wink instead\n", p->channel);
      }
      if (p->sig == SIG_FEATDMF) {
         if (exten[0] == '*') {
            char *stringp=NULL;
            ast_copy_string(exten2, exten, sizeof(exten2));
            /* Parse out extension and callerid */
            stringp=exten2 +1;
            s1 = strsep(&stringp, "#");
            s2 = strsep(&stringp, "#");
            if (s2) {
               if (!ast_strlen_zero(p->cid_num))
                  ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
               else
                  if(*(s1 + 2))
                     ast_set_callerid(chan, s1 + 2, NULL, s1 + 2);
               ast_copy_string(exten, s2 + 1, sizeof(exten));
            } else
               ast_copy_string(exten, s1 + 2, sizeof(exten));
         } else
            ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d.  Assuming E&M Wink instead\n", p->channel);
      }
      if (p->sig == SIG_E911) {
         if (exten[0] == '*') {
            char *stringp=NULL;
            ast_copy_string(exten2, exten, sizeof(exten2));
            /* Parse out extension and callerid */
            stringp=exten2 +1;
            s1 = strsep(&stringp, "#");
            s2 = strsep(&stringp, "#");
            if (s2 && (*(s2 + 1) == '0')) {
               if(*(s2 + 2))
                  ast_set_callerid(chan, s2 + 2, NULL, s2 + 2);
            }
            if (s1)  ast_copy_string(exten, s1, sizeof(exten));
            else ast_copy_string(exten, "911", sizeof(exten));
         } else
            ast_log(LOG_WARNING, "Got a non-E911 input on channel %d.  Assuming E&M Wink instead\n", p->channel);
      }
      if (p->sig == SIG_FEATB) {
         if (exten[0] == '*') {
            char *stringp=NULL;
            ast_copy_string(exten2, exten, sizeof(exten2));
            /* Parse out extension and callerid */
            stringp=exten2 +1;
            s1 = strsep(&stringp, "#");
            ast_copy_string(exten, exten2 + 1, sizeof(exten));
         } else
            ast_log(LOG_WARNING, "Got a non-Feature Group B input on channel %d.  Assuming E&M Wink instead\n", p->channel);
      }
      if (p->sig == SIG_FEATDMF) {
         zt_wink(p, index);
      }
      zt_enable_ec(p);
      if (NEED_MFDETECT(p)) {
         if (p->dsp) {
            if (!p->hardwaredtmf)
               ast_dsp_digitmode(p->dsp,DSP_DIGITMODE_DTMF | p->dtmfrelax); 
            else {
               ast_dsp_free(p->dsp);
               p->dsp = NULL;
            }
         }
      }

      if (ast_exists_extension(chan, chan->context, exten, 1, chan->cid.cid_num)) {
         ast_copy_string(chan->exten, exten, sizeof(chan->exten));
         if (p->dsp) ast_dsp_digitreset(p->dsp);
         res = ast_pbx_run(chan);
         if (res) {
            ast_log(LOG_WARNING, "PBX exited non-zero\n");
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
         }
         return NULL;
      } else {
         if (option_verbose > 2)
            ast_verbose(VERBOSE_PREFIX_2 "Unknown extension '%s' in context '%s' requested\n", exten, chan->context);
         sleep(2);
         res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_INFO);
         if (res < 0)
            ast_log(LOG_WARNING, "Unable to start special tone on %d\n", p->channel);
         else
            sleep(1);
         res = ast_streamfile(chan, "ss-noservice", chan->language);
         if (res >= 0)
            ast_waitstream(chan, "");
         res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
         ast_hangup(chan);
         return NULL;
      }
      break;
   case SIG_FXOLS:
   case SIG_FXOGS:
   case SIG_FXOKS:
      /* Read the first digit */
      timeout = firstdigittimeout;
      /* If starting a threeway call, never timeout on the first digit so someone
         can use flash-hook as a "hold" feature */
      if (p->subs[SUB_THREEWAY].owner) 
         timeout = 999999;
      while(len < AST_MAX_EXTENSION-1) {
         /* Read digit unless it's supposed to be immediate, in which case the
            only answer is 's' */
         if (p->immediate) 
            res = 's';
         else
            res = ast_waitfordigit(chan, timeout);
         timeout = 0;
         if (res < 0) {
            ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
            res = tone_zone_play_tone(p->subs[index].zfd, -1);
            ast_hangup(chan);
            return NULL;
         } else if (res)  {
            exten[len++]=res;
            exten[len] = '\0';
         }
         if (!ast_ignore_pattern(chan->context, exten))
            tone_zone_play_tone(p->subs[index].zfd, -1);
         else
            tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALTONE);
         if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num) && strcmp(exten, ast_parking_ext())) {
            if (!res || !ast_matchmore_extension(chan, chan->context, exten, 1, p->cid_num)) {
               if (getforward) {
                  /* Record this as the forwarding extension */
                  ast_copy_string(p->call_forward, exten, sizeof(p->call_forward)); 
                  if (option_verbose > 2)
                     ast_verbose(VERBOSE_PREFIX_3 "Setting call forward to '%s' on channel %d\n", p->call_forward, p->channel);
                  res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
                  if (res)
                     break;
                  usleep(500000);
                  res = tone_zone_play_tone(p->subs[index].zfd, -1);
                  sleep(1);
                  memset(exten, 0, sizeof(exten));
                  res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALTONE);
                  len = 0;
                  getforward = 0;
               } else  {
                  res = tone_zone_play_tone(p->subs[index].zfd, -1);
                  ast_copy_string(chan->exten, exten, sizeof(chan->exten));
                  if (!ast_strlen_zero(p->cid_num)) {
                     if (!p->hidecallerid)
                        ast_set_callerid(chan, p->cid_num, NULL, p->cid_num); 
                     else
                        ast_set_callerid(chan, NULL, NULL, p->cid_num); 
                  }
                  if (!ast_strlen_zero(p->cid_name)) {
                     if (!p->hidecallerid)
                        ast_set_callerid(chan, NULL, p->cid_name, NULL);
                  }
                  ast_setstate(chan, AST_STATE_RING);
                  zt_enable_ec(p);
                  res = ast_pbx_run(chan);
                  if (res) {
                     ast_log(LOG_WARNING, "PBX exited non-zero\n");
                     res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
                  }
                  return NULL;
               }
            } else {
               /* It's a match, but they just typed a digit, and there is an ambiguous match,
                  so just set the timeout to matchdigittimeout and wait some more */
               timeout = matchdigittimeout;
            }
         } else if (res == 0) {
            ast_log(LOG_DEBUG, "not enough digits (and no ambiguous match)...\n");
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
            zt_wait_event(p->subs[index].zfd);
            ast_hangup(chan);
            return NULL;
         } else if (p->callwaiting && !strcmp(exten, "*70")) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Disabling call waiting on %s\n", chan->name);
            /* Disable call waiting if enabled */
            p->callwaiting = 0;
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            if (res) {
               ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", 
                  chan->name, strerror(errno));
            }
            len = 0;
            ioctl(p->subs[index].zfd,ZT_CONFDIAG,&len);
            memset(exten, 0, sizeof(exten));
            timeout = firstdigittimeout;
               
         } else if (!strcmp(exten,ast_pickup_ext())) {
            /* Scan all channels and see if any there
             * ringing channqels with that have call groups
             * that equal this channels pickup group  
             */
            if (index == SUB_REAL) {
               /* Switch us from Third call to Call Wait */
               if (p->subs[SUB_THREEWAY].owner) {
                  /* If you make a threeway call and the *8# a call, it should actually 
                     look like a callwait */
                  alloc_sub(p, SUB_CALLWAIT);   
                  swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
                  unalloc_sub(p, SUB_THREEWAY);
               }
               zt_enable_ec(p);
               if (ast_pickup_call(chan)) {
                  ast_log(LOG_DEBUG, "No call pickup possible...\n");
                  res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
                  zt_wait_event(p->subs[index].zfd);
               }
               ast_hangup(chan);
               return NULL;
            } else {
               ast_log(LOG_WARNING, "Huh?  Got *8# on call not on real\n");
               ast_hangup(chan);
               return NULL;
            }
            
         } else if (!p->hidecallerid && !strcmp(exten, "*67")) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Disabling Caller*ID on %s\n", chan->name);
            /* Disable Caller*ID if enabled */
            p->hidecallerid = 1;
            if (chan->cid.cid_num)
               free(chan->cid.cid_num);
            chan->cid.cid_num = NULL;
            if (chan->cid.cid_name)
               free(chan->cid.cid_name);
            chan->cid.cid_name = NULL;
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            if (res) {
               ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", 
                  chan->name, strerror(errno));
            }
            len = 0;
            memset(exten, 0, sizeof(exten));
            timeout = firstdigittimeout;
         } else if (p->callreturn && !strcmp(exten, "*69")) {
            res = 0;
            if (!ast_strlen_zero(p->lastcid_num)) {
               res = ast_say_digit_str(chan, p->lastcid_num, "", chan->language);
            }
            if (!res)
               res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            break;
         } else if (!strcmp(exten, "*78")) {
            /* Do not disturb */
            if (option_verbose > 2) {
               ast_verbose(VERBOSE_PREFIX_3 "Enabled DND on channel %d\n", p->channel);
            }
            manager_event(EVENT_FLAG_SYSTEM, "DNDState",
                     "Channel: Zap/%d\r\n"
                     "Status: enabled\r\n", p->channel);
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            p->dnd = 1;
            getforward = 0;
            memset(exten, 0, sizeof(exten));
            len = 0;
         } else if (!strcmp(exten, "*79")) {
            /* Do not disturb */
            if (option_verbose > 2)
               ast_verbose(VERBOSE_PREFIX_3 "Disabled DND on channel %d\n", p->channel);
            manager_event(EVENT_FLAG_SYSTEM, "DNDState",
                        "Channel: Zap/%d\r\n"
                        "Status: disabled\r\n", p->channel);
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            p->dnd = 0;
            getforward = 0;
            memset(exten, 0, sizeof(exten));
            len = 0;
         } else if (p->cancallforward && !strcmp(exten, "*72")) {
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            getforward = 1;
            memset(exten, 0, sizeof(exten));
            len = 0;
         } else if (p->cancallforward && !strcmp(exten, "*73")) {
            if (option_verbose > 2)
               ast_verbose(VERBOSE_PREFIX_3 "Cancelling call forwarding on channel %d\n", p->channel);
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            memset(p->call_forward, 0, sizeof(p->call_forward));
            getforward = 0;
            memset(exten, 0, sizeof(exten));
            len = 0;
         } else if ((p->transfer || p->canpark) && !strcmp(exten, ast_parking_ext()) && 
                  p->subs[SUB_THREEWAY].owner &&
                  ast_bridged_channel(p->subs[SUB_THREEWAY].owner)) {
            /* This is a three way call, the main call being a real channel, 
               and we're parking the first call. */
            ast_masq_park_call(ast_bridged_channel(p->subs[SUB_THREEWAY].owner), chan, 0, NULL);
            if (option_verbose > 2)
               ast_verbose(VERBOSE_PREFIX_3 "Parking call to '%s'\n", chan->name);
            break;
         } else if (!ast_strlen_zero(p->lastcid_num) && !strcmp(exten, "*60")) {
            if (option_verbose > 2)
               ast_verbose(VERBOSE_PREFIX_3 "Blacklisting number %s\n", p->lastcid_num);
            res = ast_db_put("blacklist", p->lastcid_num, "1");
            if (!res) {
               res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
               memset(exten, 0, sizeof(exten));
               len = 0;
            }
         } else if (p->hidecallerid && !strcmp(exten, "*82")) {
            if (option_verbose > 2) 
               ast_verbose(VERBOSE_PREFIX_3 "Enabling Caller*ID on %s\n", chan->name);
            /* Enable Caller*ID if enabled */
            p->hidecallerid = 0;
            if (chan->cid.cid_num)
               free(chan->cid.cid_num);
            chan->cid.cid_num = NULL;
            if (chan->cid.cid_name)
               free(chan->cid.cid_name);
            chan->cid.cid_name = NULL;
            ast_set_callerid(chan, p->cid_num, p->cid_name, NULL);
            res = tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_DIALRECALL);
            if (res) {
               ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n", 
                  chan->name, strerror(errno));
            }
            len = 0;
            memset(exten, 0, sizeof(exten));
            timeout = firstdigittimeout;
         } else if (!strcmp(exten, "*0")) {
            struct ast_channel *nbridge = 
               p->subs[SUB_THREEWAY].owner;
            struct zt_pvt *pbridge = NULL;
              /* set up the private struct of the bridged one, if any */
            if (nbridge && ast_bridged_channel(nbridge)) 
               pbridge = ast_bridged_channel(nbridge)->tech_pvt;
            if (nbridge && pbridge && 
                (!strcmp(nbridge->type,"Zap")) && 
               (!strcmp(ast_bridged_channel(nbridge)->type, "Zap")) &&
                ISTRUNK(pbridge)) {
               int func = ZT_FLASH;
               /* Clear out the dial buffer */
               p->dop.dialstr[0] = '\0';
               /* flash hookswitch */
               if ((ioctl(pbridge->subs[SUB_REAL].zfd,ZT_HOOK,&func) == -1) && (errno != EINPROGRESS)) {
                  ast_log(LOG_WARNING, "Unable to flash external trunk on channel %s: %s\n", 
                     nbridge->name, strerror(errno));
               }
               swap_subs(p, SUB_REAL, SUB_THREEWAY);
               unalloc_sub(p, SUB_THREEWAY);
               p->owner = p->subs[SUB_REAL].owner;
               if (ast_bridged_channel(p->subs[SUB_REAL].owner))
                  ast_moh_stop(ast_bridged_channel(p->subs[SUB_REAL].owner));
               ast_hangup(chan);
               return NULL;
            } else {
               tone_zone_play_tone(p->subs[index].zfd, ZT_TONE_CONGESTION);
               zt_wait_event(p->subs[index].zfd);
               tone_zone_play_tone(p->subs[index].zfd, -1);
               swap_subs(p, SUB_REAL, SUB_THREEWAY);
               unalloc_sub(p, SUB_THREEWAY);
               p->owner = p->subs[SUB_REAL].owner;
               ast_hangup(chan);
               return NULL;
            }              
         } else if (!ast_canmatch_extension(chan, chan->context, exten, 1, chan->cid.cid_num) &&
                     ((exten[0] != '*') || (strlen(exten) > 2))) {
            if (option_debug)
               ast_log(LOG_DEBUG, "Can't match %s from '%s' in context %s\n", exten, chan->cid.cid_num ? chan->cid.cid_num : "<Unknown Caller>", chan->context);
            break;
         }
         if (!timeout)
            timeout = gendigittimeout;
         if (len && !ast_ignore_pattern(chan->context, exten))
            tone_zone_play_tone(p->subs[index].zfd, -1);
      }
      break;
   case SIG_FXSLS:
   case SIG_FXSGS:
   case SIG_FXSKS:
#ifdef ZAPATA_PRI
      if (p->pri) {
         /* This is a GR-303 trunk actually.  Wait for the first ring... */
         struct ast_frame *f;
         int res;
         time_t start;

         time(&start);
         ast_setstate(chan, AST_STATE_RING);
         while(time(NULL) < start + 3) {
            res = ast_waitfor(chan, 1000);
            if (res) {
               f = ast_read(chan);
               if (!f) {
                  ast_log(LOG_WARNING, "Whoa, hangup while waiting for first ring!\n");
                  ast_hangup(chan);
                  return NULL;
               } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_RING)) {
                  res = 1;
               } else
                  res = 0;
               ast_frfree(f);
               if (res) {
                  ast_log(LOG_DEBUG, "Got ring!\n");
                  res = 0;
                  break;
               }
            }
         }
      }
#endif
      /* If we want caller id, we're in a prering state due to a polarity reversal
       * and we're set to use a polarity reversal to trigger the start of caller id,
       * grab the caller id and wait for ringing to start... */
      if (p->use_callerid && (chan->_state == AST_STATE_PRERING && p->cid_start == CID_START_POLARITY)) {
         /* If set to use DTMF CID signalling, listen for DTMF */
         if (p->cid_signalling == CID_SIG_DTMF) {
            int i = 0;
            cs = NULL;
            ast_log(LOG_DEBUG, "Receiving DTMF cid on "
               "channel %s\n", chan->name);
            zt_setlinear(p->subs[index].zfd, 0);
            res = 2000;
            for (;;) {
               struct ast_frame *f;
               res = ast_waitfor(chan, res);
               if (res <= 0) {
                  ast_log(LOG_WARNING, "DTMFCID timed out waiting for ring. "
                     "Exiting simple switch\n");
                  ast_hangup(chan);
                  return NULL;
               } 
               f = ast_read(chan);
               if (f->frametype == AST_FRAME_DTMF) {
                  dtmfbuf[i++] = f->subclass;
                  ast_log(LOG_DEBUG, "CID got digit '%c'\n", f->subclass);
                  res = 2000;
               }
               ast_frfree(f);
               if (chan->_state == AST_STATE_RING ||
                   chan->_state == AST_STATE_RINGING) 
                  break; /* Got ring */
            }
            dtmfbuf[i] = 0;
            zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
            /* Got cid and ring. */
            ast_log(LOG_DEBUG, "CID got string '%s'\n", dtmfbuf);
            callerid_get_dtmf(dtmfbuf, dtmfcid, &flags);
            ast_log(LOG_DEBUG, "CID is '%s', flags %d\n", 
               dtmfcid, flags);
            /* If first byte is NULL, we have no cid */
            if (dtmfcid[0]) 
               number = dtmfcid;
            else
               number = 0;
         /* If set to use V23 Signalling, launch our FSK gubbins and listen for it */
         } else if (p->cid_signalling == CID_SIG_V23) {
            cs = callerid_new(p->cid_signalling);
            if (cs) {
               samples = 0;
#if 1
               bump_gains(p);
#endif            
               /* Take out of linear mode for Caller*ID processing */
               zt_setlinear(p->subs[index].zfd, 0);
               
               /* First we wait and listen for the Caller*ID */
               for(;;) {   
                  i = ZT_IOMUX_READ | ZT_IOMUX_SIGEVENT;
                  if ((res = ioctl(p->subs[index].zfd, ZT_IOMUX, &i)))  {
                     ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
                     callerid_free(cs);
                     ast_hangup(chan);
                     return NULL;
                  }
                  if (i & ZT_IOMUX_SIGEVENT) {
                     res = zt_get_event(p->subs[index].zfd);
                     ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
                     res = 0;
                     break;
                  } else if (i & ZT_IOMUX_READ) {
                     res = read(p->subs[index].zfd, buf, sizeof(buf));
                     if (res < 0) {
                        if (errno != ELAST) {
                           ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
                           callerid_free(cs);
                           ast_hangup(chan);
                           return NULL;
                        }
                        break;
                     }
                     samples += res;
                     res = callerid_feed(cs, buf, res, AST_LAW(p));
                     if (res < 0) {
                        ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno));
                        break;
                     } else if (res)
                        break;
                     else if (samples > (8000 * 10))
                        break;
                  }
               }
               if (res == 1) {
                  callerid_get(cs, &name, &number, &flags);
                  if (option_debug)
                     ast_log(LOG_DEBUG, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags);
               }
               if (res < 0) {
                  ast_log(LOG_WARNING, "CallerID returned with error on channel '%s'\n", chan->name);
               }

               /* Finished with Caller*ID, now wait for a ring to make sure there really is a call coming */ 
               res = 2000;
               for (;;) {
                  struct ast_frame *f;
                  res = ast_waitfor(chan, res);
                  if (res <= 0) {
                     ast_log(LOG_WARNING, "CID timed out waiting for ring. "
                        "Exiting simple switch\n");
                     ast_hangup(chan);
                     return NULL;
                  } 
                  f = ast_read(chan);
                  ast_frfree(f);
                  if (chan->_state == AST_STATE_RING ||
                      chan->_state == AST_STATE_RINGING) 
                     break; /* Got ring */
               }
   
               /* We must have a ring by now, so, if configured, lets try to listen for
                * distinctive ringing */ 
               if (p->usedistinctiveringdetection == 1) {
                  len = 0;
                  distMatches = 0;
                  /* Clear the current ring data array so we dont have old data in it. */
                  for (receivedRingT=0; receivedRingT < (sizeof(curRingData) / sizeof(curRingData[0])); receivedRingT++)
                     curRingData[receivedRingT] = 0;
                  receivedRingT = 0;
                  counter = 0;
                  counter1 = 0;
                  /* Check to see if context is what it should be, if not set to be. */
                  if (strcmp(p->context,p->defcontext) != 0) {
                     ast_copy_string(p->context, p->defcontext, sizeof(p->context));
                     ast_copy_string(chan->context,p->defcontext,sizeof(chan->context));
                  }
      
                  for(;;) {   
                     i = ZT_IOMUX_READ | ZT_IOMUX_SIGEVENT;
                     if ((res = ioctl(p->subs[index].zfd, ZT_IOMUX, &i)))  {
                        ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
                        callerid_free(cs);
                        ast_hangup(chan);
                        return NULL;
                     }
                     if (i & ZT_IOMUX_SIGEVENT) {
                        res = zt_get_event(p->subs[index].zfd);
                        ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
                        res = 0;
                        /* Let us detect distinctive ring */
      
                        curRingData[receivedRingT] = p->ringt;
      
                        if (p->ringt < p->ringt_base/2)
                           break;
                        /* Increment the ringT counter so we can match it against
                           values in zapata.conf for distinctive ring */
                        if (++receivedRingT == (sizeof(curRingData) / sizeof(curRingData[0])))
                           break;
                     } else if (i & ZT_IOMUX_READ) {
                        res = read(p->subs[index].zfd, buf, sizeof(buf));
                        if (res < 0) {
                           if (errno != ELAST) {
                              ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
                              callerid_free(cs);
                              ast_hangup(chan);
                              return NULL;
                           }
                           break;
                        }
                        if (p->ringt) 
                           p->ringt--;
                        if (p->ringt == 1) {
                           res = -1;
                           break;
                        }
                     }
                  }
                  if(option_verbose > 2)
                     /* this only shows up if you have n of the dring patterns filled in */
                     ast_verbose( VERBOSE_PREFIX_3 "Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);
   
                  for (counter=0; counter < 3; counter++) {
                     /* Check to see if the rings we received match any of the ones in zapata.conf for this
                     channel */
                     distMatches = 0;
                     for (counter1=0; counter1 < 3; counter1++) {
                        if (curRingData[counter1] <= (p->drings.ringnum[counter].ring[counter1]+10) && curRingData[counter1] >=
                        (p->drings.ringnum[counter].ring[counter1]-10)) {
                           distMatches++;
                        }
                     }
                     if (distMatches == 3) {
                        /* The ring matches, set the context to whatever is for distinctive ring.. */
                        ast_copy_string(p->context, p->drings.ringContext[counter].contextData, sizeof(p->context));
                        ast_copy_string(chan->context, p->drings.ringContext[counter].contextData, sizeof(chan->context));
                        if(option_verbose > 2)
                           ast_verbose( VERBOSE_PREFIX_3 "Distinctive Ring matched context %s\n",p->context);
                        break;
                     }
                  }
               }
               /* Restore linear mode (if appropriate) for Caller*ID processing */
               zt_setlinear(p->subs[index].zfd, p->subs[index].linear);
#if 1
               restore_gains(p);
#endif            
            } else
               ast_log(LOG_WARNING, "Unable to get caller ID space\n");       
         } else {
            ast_log(LOG_WARNING, "Channel %s in prering "
               "state, but I have nothing to do. "
               "Terminating simple switch, should be "
               "restarted by the actual ring.\n", 
               chan->name);
            ast_hangup(chan);
            return NULL;
         }
      } else if (p->use_callerid && p->cid_start == CID_START_RING) {
         /* FSK Bell202 callerID */
         cs = callerid_new(p->cid_signalling);
         if (cs) {
#if 1
            bump_gains(p);
#endif            
            samples = 0;
            len = 0;
            distMatches = 0;
            /* Clear the current ring data array so we dont have old data in it. */
            for (receivedRingT=0; receivedRingT < (sizeof(curRingData) / sizeof(curRingData[0])); receivedRingT++)
               curRingData[receivedRingT] = 0;
            receivedRingT = 0;
            counter = 0;
            counter1 = 0;
            /* Check to see if context is what it should be, if not set to be. */
            if (strcmp(p->context,p->defcontext) != 0) {
               ast_copy_string(p->context, p->defcontext, sizeof(p->context));
               ast_copy_string(chan->context,p->defcontext,sizeof(chan->context));
            }

            /* Take out of linear mode for Caller*ID processing */
            zt_setlinear(p->subs[index].zfd, 0);
            for(;;) {   
               i = ZT_IOMUX_READ | ZT_IOMUX_SIGEVENT;
               if ((res = ioctl(p->subs[index].zfd, ZT_IOMUX, &i)))  {
                  ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
                  callerid_free(cs);
                  ast_hangup(chan);
                  return NULL;
               }
               if (i & ZT_IOMUX_SIGEVENT) {
                  res = zt_get_event(p->subs[index].zfd);
                  ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
                  res = 0;
                  /* Let us detect callerid when the telco uses distinctive ring */

                  curRingData[receivedRingT] = p->ringt;

                  if (p->ringt < p->ringt_base/2)
                     break;
                  /* Increment the ringT counter so we can match it against
                     values in zapata.conf for distinctive ring */
                  if (++receivedRingT == (sizeof(curRingData) / sizeof(curRingData[0])))
                     break;
               } else if (i & ZT_IOMUX_READ) {
                  res = read(p->subs[index].zfd, buf, sizeof(buf));
                  if (res < 0) {
                     if (errno != ELAST) {
                        ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
                        callerid_free(cs);
                        ast_hangup(chan);
                        return NULL;
                     }
                     break;
                  }
                  if (p->ringt) 
                     p->ringt--;
                  if (p->ringt == 1) {
                     res = -1;
                     break;
                  }
                  samples += res;
                  res = callerid_feed(cs, buf, res, AST_LAW(p));
                  if (res < 0) {
                     ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno));
                     break;
                  } else if (res)
                     break;
                  else if (samples > (8000 * 10))
                     break;
               }
            }
            if (p->usedistinctiveringdetection == 1) {
               if(option_verbose > 2)
                  /* this only shows up if you have n of the dring patterns filled in */
                  ast_verbose( VERBOSE_PREFIX_3 "Detected ring pattern: %d,%d,%d\n",curRingData[0],curRingData[1],curRingData[2]);