chan_dahdi.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2006, 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 DAHDI Pseudo TDM interface 
 *
 * \author Mark Spencer <markster@digium.com>
 * 
 * Connects to the DAHDI 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 DAHDI channel.
 *
 * \par See also
 * \arg \ref Config_dahdi
 *
 * \ingroup channel_drivers
 *
 * \todo Deprecate the "musiconhold" configuration option post 1.4
 */

/*** MODULEINFO
   <depend>res_smdi</depend>
   <depend>dahdi</depend>
   <depend>tonezone</depend>
   <depend>res_features</depend>
   <use>pri</use>
 ***/

#include "asterisk.h"

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

#include <stdio.h>
#include <string.h>
#if defined(__NetBSD__) || defined(__FreeBSD__)
#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>
#include <math.h>
#include <ctype.h>

#ifdef HAVE_PRI
#include <libpri.h>
#endif

#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"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/smdi.h"
#include "asterisk/astobj.h"
#define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */

#include "asterisk/dahdi_compat.h"
#include "asterisk/tonezone_compat.h"

/*! Global jitterbuffer configuration - by default, jb is disabled */
static struct ast_jb_conf default_jbconf =
{
   .flags = 0,
   .max_size = -1,
   .resync_threshold = -1,
   .impl = ""
};
static struct ast_jb_conf global_jbconf;

#ifndef DAHDI_TONEDETECT
/* Work around older code with no tone detect */
#define DAHDI_EVENT_DTMFDOWN 0
#define DAHDI_EVENT_DTMFUP 0
#endif

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

/*! 
 * Define to make always pick a channel if allowed.  Useful for
 * testing channel shifting.
 */
//#define ALWAYS_PICK_CHANNEL 1

/*!
 * Define to force a RESTART on a channel that returns a cause
 * code of PRI_CAUSE_REQUESTED_CHAN_UNAVAIL(44).  If the cause
 * is because of a stuck channel on the peer and the channel is
 * always the next channel we pick for an outgoing call then
 * this can help.
 */
#define FORCE_RESTART_UNAVAIL_CHANS    1

/*!
 * \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 DAHDI_CHECK_HOOKSTATE */

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

#define AST_LAW(p) (((p)->law == DAHDI_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_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB)) 

static const char tdesc[] = "DAHDI Telephony Driver"
#ifdef HAVE_PRI
               " w/PRI"
#endif
;

#define SIG_EM    DAHDI_SIG_EM
#define SIG_EMWINK   (0x0100000 | DAHDI_SIG_EM)
#define SIG_FEATD (0x0200000 | DAHDI_SIG_EM)
#define  SIG_FEATDMF (0x0400000 | DAHDI_SIG_EM)
#define  SIG_FEATB   (0x0800000 | DAHDI_SIG_EM)
#define  SIG_E911 (0x1000000 | DAHDI_SIG_EM)
#define  SIG_FEATDMF_TA (0x2000000 | DAHDI_SIG_EM)
#define  SIG_FGC_CAMA   (0x4000000 | DAHDI_SIG_EM)
#define  SIG_FGC_CAMAMF (0x8000000 | DAHDI_SIG_EM)
#define SIG_FXSLS DAHDI_SIG_FXSLS
#define SIG_FXSGS DAHDI_SIG_FXSGS
#define SIG_FXSKS DAHDI_SIG_FXSKS
#define SIG_FXOLS DAHDI_SIG_FXOLS
#define SIG_FXOGS DAHDI_SIG_FXOGS
#define SIG_FXOKS DAHDI_SIG_FXOKS
#define SIG_PRI      DAHDI_SIG_CLEAR
#define  SIG_SF      DAHDI_SIG_SF
#define SIG_SFWINK   (0x0100000 | DAHDI_SIG_SF)
#define SIG_SF_FEATD (0x0200000 | DAHDI_SIG_SF)
#define  SIG_SF_FEATDMF (0x0400000 | DAHDI_SIG_SF)
#define  SIG_SF_FEATB   (0x0800000 | DAHDI_SIG_SF)
#define SIG_EM_E1 DAHDI_SIG_EM_E1
#define SIG_GR303FXOKS  (0x0100000 | DAHDI_SIG_FXOKS)
#define SIG_GR303FXSKS  (0x0100000 | DAHDI_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)

/* Overlap dialing option types */
#define DAHDI_OVERLAPDIAL_NONE 0
#define DAHDI_OVERLAPDIAL_OUTGOING 1
#define DAHDI_OVERLAPDIAL_INCOMING 2
#define DAHDI_OVERLAPDIAL_BOTH (DAHDI_OVERLAPDIAL_INCOMING|DAHDI_OVERLAPDIAL_OUTGOING)

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

static char progzone[10] = "";

static int distinctiveringaftercid = 0;

static int numbufs = 4;

#ifdef HAVE_PRI
static struct ast_channel inuse;
#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;

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


static int ifcount = 0;

#ifdef HAVE_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 ast_cond_t ss_thread_complete;
AST_MUTEX_DEFINE_STATIC(ss_thread_lock);
AST_MUTEX_DEFINE_STATIC(restart_lock);
static int ss_thread_count = 0;
static int num_restart_pending = 0;

static int restart_monitor(void);

static enum ast_bridge_result dahdi_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);

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

#define SIG_PRI_LIB_HANDLE_CASES \
   SIG_PRI

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

/*! \brief Avoid the silly dahdi_waitevent which ignores a bunch of events */
static inline int dahdi_wait_event(int fd)
{
   int i, j = 0;
   i = DAHDI_IOMUX_SIGEVENT;
   if (ioctl(fd, DAHDI_IOMUX, &i) == -1)
      return -1;
   if (ioctl(fd, DAHDI_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) /*!< 10,000 ms */
#define CALLWAITING_SUPPRESS_SAMPLES   ((100 * 8) / READ_SIZE) /*!< 100 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) /*!< 8,000 ms */

struct dahdi_pvt;

/*!
 * \brief Configured ring timeout base.
 * \note Value computed from "ringtimeout" read in from chan_dahdi.conf if it exists.
 */
static int ringt_base = DEFAULT_RINGT;

#ifdef HAVE_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)

/*! Call establishment life cycle level for simple comparisons. */
enum dahdi_call_level {
   /*! Call does not exist. */
   DAHDI_CALL_LEVEL_IDLE,
   /*! Call is present but has no response yet. (SETUP) */
   DAHDI_CALL_LEVEL_SETUP,
   /*! Call is collecting digits for overlap dialing. (SETUP ACKNOWLEDGE) */
   DAHDI_CALL_LEVEL_OVERLAP,
   /*! Call routing is happening. (PROCEEDING) */
   DAHDI_CALL_LEVEL_PROCEEDING,
   /*! Called party is being alerted of the call. (ALERTING) */
   DAHDI_CALL_LEVEL_ALERTING,
   /*! Call is connected/answered. (CONNECT) */
   DAHDI_CALL_LEVEL_CONNECT,
};

struct dahdi_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 */
   /*! \brief TRUE if to dump PRI event info (Tested but never set) */
   int debug;
   int fds[NUM_DCHANS];                /*!< FD's for d-channels */
   /*! \brief Value set but not used */
   int offset;
   /*! \brief Span number put into user output messages */
   int span;
   /*! \brief TRUE if span is being reset/restarted */
   int resetting;
   /*! \brief Current position during a reset (-1 if not started) */
   int resetpos;
#ifdef HAVE_PRI_INBANDDISCONNECT
   unsigned int inbanddisconnect:1;          /*!< Should we support inband audio after receiving DISCONNECT? */
#endif
   /*! TRUE if we have already whined about no D channels available. */
   unsigned int no_d_channels:1;
   time_t lastreset;                /*!< time when unused channels were last reset */
   long resetinterval;                 /*!< Interval (in seconds) for resetting unused channels */
   struct dahdi_pvt *pvts[MAX_CHANNELS];           /*!< Member channel pvt structs */
   struct dahdi_pvt *crvs;                /*!< Member CRV structs */
   struct dahdi_pvt *crvend;                 /*!< Pointer to end of CRV structs */
};


static struct dahdi_pri pris[NUM_SPANS];

#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 dahdi_pri *pri)
{
   ast_mutex_unlock(&pri->lock);
}

#else
/*! Shut up the compiler */
struct dahdi_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 dahdi_distRings drings;

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

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

struct dahdi_subchannel {
   int dfd;
   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 needhold:1;
   unsigned int needunhold:1;
   unsigned int linear:1;
   unsigned int inthreeway:1;
   struct dahdi_confinfo curconf;
};

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

#define MAX_SLAVES   4

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

   struct dahdi_pvt *slaves[MAX_SLAVES];     /*!< Slave to us (follows our conferencing) */
   struct dahdi_pvt *master;           /*!< Master to us (we follow their conferencing) */
   int inconference;          /*!< If our real should be in the conference */
   
   int bufsize;                /*!< Size of the buffers */
   int buf_no;             /*!< Number of buffers */
   int buf_policy;            /*!< Buffer policy */
   int sig;             /*!< Signalling style */
   /*!
    * \brief Nonzero if the signaling type is sent over a radio.
    * \note Set to a couple of nonzero values but it is only tested like a boolean.
    */
   int radio;
   int outsigmod;             /*!< Outbound Signalling style (modifier) */
   int oprmode;               /*!< "Operator Services" mode */
   struct dahdi_pvt *oprpeer;          /*!< "Operator Services" peer tech_pvt ptr */
   /*! \brief Rx gain set by chan_dahdi.conf */
   float rxgain;
   /*! \brief Tx gain set by chan_dahdi.conf */
   float txgain;
   int tonezone;              /*!< tone zone for this chan, or -1 for default */
   struct dahdi_pvt *next;          /*!< Next channel in list */
   struct dahdi_pvt *prev;          /*!< Prev channel in list */

   /* flags */

   /*!
    * \brief TRUE if ADSI (Analog Display Services Interface) available
    * \note Set from the "adsi" value read in from chan_dahdi.conf
    */
   unsigned int adsi:1;
   /*!
    * \brief TRUE if we can use a polarity reversal to mark when an outgoing
    * call is answered by the remote party.
    * \note Set from the "answeronpolarityswitch" value read in from chan_dahdi.conf
    */
   unsigned int answeronpolarityswitch:1;
   /*!
    * \brief TRUE if busy detection is enabled.
    * (Listens for the beep-beep busy pattern.)
    * \note Set from the "busydetect" value read in from chan_dahdi.conf
    */
   unsigned int busydetect:1;
   /*!
    * \brief TRUE if call return is enabled.
    * (*69, if your dialplan doesn't catch this first)
    * \note Set from the "callreturn" value read in from chan_dahdi.conf
    */
   unsigned int callreturn:1;
   /*!
    * \brief TRUE if busy extensions will hear the call-waiting tone
    * and can use hook-flash to switch between callers.
    * \note Can be disabled by dialing *70.
    * \note Initialized with the "callwaiting" value read in from chan_dahdi.conf
    */
   unsigned int callwaiting:1;
   /*!
    * \brief TRUE if send caller ID for Call Waiting
    * \note Set from the "callwaitingcallerid" value read in from chan_dahdi.conf
    */
   unsigned int callwaitingcallerid:1;
   /*!
    * \brief TRUE if support for call forwarding enabled.
    * Dial *72 to enable call forwarding.
    * Dial *73 to disable call forwarding.
    * \note Set from the "cancallforward" value read in from chan_dahdi.conf
    */
   unsigned int cancallforward:1;
   /*!
    * \brief TRUE if support for call parking is enabled.
    * \note Set from the "canpark" value read in from chan_dahdi.conf
    */
   unsigned int canpark:1;
   /*! \brief TRUE if to wait for a DTMF digit to confirm answer */
   unsigned int confirmanswer:1;
   /*!
    * \brief TRUE if the channel is to be destroyed on hangup.
    * (Used by pseudo channels.)
    */
   unsigned int destroy:1;
   unsigned int didtdd:1;           /*!< flag to say its done it once */
   /*! \brief TRUE if analog type line dialed no digits in Dial() */
   unsigned int dialednone:1;
   /*! \brief TRUE if in the process of dialing digits or sending something. */
   unsigned int dialing:1;
   /*! \brief TRUE if the transfer capability of the call is digital. */
   unsigned int digital:1;
   /*! \brief TRUE if Do-Not-Disturb is enabled. */
   unsigned int dnd:1;
   /*! \brief XXX BOOLEAN Purpose??? */
   unsigned int echobreak:1;
   /*!
    * \brief TRUE if echo cancellation enabled when bridged.
    * \note Initialized with the "echocancelwhenbridged" value read in from chan_dahdi.conf
    * \note Disabled if the echo canceller is not setup.
    */
   unsigned int echocanbridged:1;
   /*! \brief TRUE if echo cancellation is turned on. */
   unsigned int echocanon:1;
   /*! \brief TRUE if a fax tone has already been handled. */
   unsigned int faxhandled:1;
   /*!< TRUE while buffer configuration override is in use. */
   unsigned int bufferoverrideinuse:1;
   /*! \brief TRUE if over a radio and dahdi_read() has been called. */
   unsigned int firstradio:1;
   /*!
    * \brief TRUE if the call will be considered "hung up" on a polarity reversal.
    * \note Set from the "hanguponpolarityswitch" value read in from chan_dahdi.conf
    */
   unsigned int hanguponpolarityswitch:1;
   /*! \brief TRUE if DTMF detection needs to be done by hardware. */
   unsigned int hardwaredtmf:1;
   /*!
    * \brief TRUE if the outgoing caller ID is blocked/hidden.
    * \note Caller ID can be disabled by dialing *67.
    * \note Caller ID can be enabled by dialing *82.
    * \note Initialized with the "hidecallerid" value read in from chan_dahdi.conf
    */
   unsigned int hidecallerid:1;
   /*!
    * \brief TRUE if hide just the name not the number for legacy PBX use.
    * \note Only applies to PRI channels.
    * \note Set from the "hidecalleridname" value read in from chan_dahdi.conf
    */
   unsigned int hidecalleridname:1;
   /*! \brief TRUE if DTMF detection is disabled. */
   unsigned int ignoredtmf:1;
   /*!
    * \brief TRUE if the channel should be answered immediately
    * without attempting to gather any digits.
    * \note Set from the "immediate" value read in from chan_dahdi.conf
    */
   unsigned int immediate:1;
   /*! \brief TRUE if in an alarm condition. */
   unsigned int inalarm:1;
   unsigned int unknown_alarm:1;
   /*! \brief TRUE if TDD in MATE mode */
   unsigned int mate:1;
#if defined(HAVE_PRI)
   /*!
    * \brief TRUE when this channel is allocated.
    *
    * \details
    * Needed to hold an outgoing channel allocation before the
    * owner pointer is created.
    *
    * \note This is one of several items to check to see if a
    * channel is available for use.
    */
   unsigned int allocated:1;
#endif   /* defined(HAVE_PRI) */
   /*! \brief TRUE if we originated the call leg. */
   unsigned int outgoing:1;
   /* unsigned int overlapdial:1;         unused and potentially confusing */
   /*!
    * \brief TRUE if busy extensions will hear the call-waiting tone
    * and can use hook-flash to switch between callers.
    * \note Set from the "callwaiting" value read in from chan_dahdi.conf
    */
   unsigned int permcallwaiting:1;
   /*!
    * \brief TRUE if the outgoing caller ID is blocked/restricted/hidden.
    * \note Set from the "hidecallerid" value read in from chan_dahdi.conf
    */
   unsigned int permhidecallerid:1;
   /*!
    * \brief TRUE if PRI congestion/busy indications are sent out-of-band.
    * \note Set from the "priindication" value read in from chan_dahdi.conf
    */
   unsigned int priindication_oob:1;
   /*!
    * \brief TRUE if PRI B channels are always exclusively selected.
    * \note Set from the "priexclusive" value read in from chan_dahdi.conf
    */
   unsigned int priexclusive:1;
   /*!
    * \brief TRUE if we will pulse dial.
    * \note Set from the "pulsedial" value read in from chan_dahdi.conf
    */
   unsigned int pulse:1;
   /*! \brief TRUE if a pulsed digit was detected. (Pulse dial phone detected) */
   unsigned int pulsedial:1;
   unsigned int restartpending:1;      /*!< flag to ensure counted only once for restart */
   /*!
    * \brief TRUE if caller ID is restricted.
    * \note Set but not used.  Should be deleted.  Redundant with permhidecallerid.
    * \note Set from the "restrictcid" value read in from chan_dahdi.conf
    */
   unsigned int restrictcid:1;
   /*!
    * \brief TRUE if three way calling is enabled
    * \note Set from the "threewaycalling" value read in from chan_dahdi.conf
    */
   unsigned int threewaycalling:1;
   /*!
    * \brief TRUE if call transfer is enabled
    * \note For FXS ports (either direct analog or over T1/E1):
    *   Support flash-hook call transfer
    * \note For digital ports using ISDN PRI protocols:
    *   Support switch-side transfer (called 2BCT, RLT or other names)
    * \note Set from the "transfer" value read in from chan_dahdi.conf
    */
   unsigned int transfer:1;
   /*!
    * \brief TRUE if caller ID is used on this channel.
    * \note PRI spans will save caller ID from the networking peer.
    * \note FXS ports will generate the caller ID spill.
    * \note FXO ports will listen for the caller ID spill.
    * \note Set from the "usecallerid" value read in from chan_dahdi.conf
    */
   unsigned int use_callerid:1;
   /*!
    * \brief TRUE if we will use the calling presentation setting
    * from the Asterisk channel for outgoing calls.
    * \note Only applies to PRI channels.
    * \note Set from the "usecallingpres" value read in from chan_dahdi.conf
    */
   unsigned int use_callingpres:1;
   /*!
    * \brief TRUE if distinctive rings are to be detected.
    * \note For FXO lines
    * \note Set indirectly from the "usedistinctiveringdetection" value read in from chan_dahdi.conf
    */
   unsigned int usedistinctiveringdetection:1;
   /*!
    * \brief TRUE if we should use the callerid from incoming call on dahdi transfer.
    * \note Set from the "useincomingcalleridondahditransfer" value read in from chan_dahdi.conf
    */
   unsigned int dahditrcallerid:1;
   /*!
    * \brief TRUE if allowed to flash-transfer to busy channels.
    * \note Set from the "transfertobusy" value read in from chan_dahdi.conf
    */
   unsigned int transfertobusy:1;
   /*!
    * \brief TRUE if SMDI (Simplified Message Desk Interface) is enabled
    * \note Set from the "usesmdi" value read in from chan_dahdi.conf
    */
   unsigned int use_smdi:1;
#if defined(HAVE_PRI)
   /*! \brief TRUE if the call has already gone/hungup */
   unsigned int alreadyhungup:1;
   /*!
    * \brief TRUE if this is an idle call
    * \note Applies to PRI channels.
    */
   unsigned int isidlecall:1;
   /*! \brief TRUE if the call has seen inband-information progress through the network. */
   unsigned int progress:1;
   /*!
    * \brief TRUE if this channel is being reset/restarted
    * \note Applies to PRI channels.
    */
   unsigned int resetting:1;

   /*! Call establishment life cycle level for simple comparisons. */
   enum dahdi_call_level call_level;
#endif
   /*! \brief The serial port to listen for SMDI data on */
   struct ast_smdi_interface *smdi_iface;

   /*! \brief Distinctive Ring data */
   struct dahdi_distRings drings;

   /*!
    * \brief The configured context for incoming calls.
    * \note The "context" string read in from chan_dahdi.conf
    */
   char context[AST_MAX_CONTEXT];
   /*!
    * \brief Saved context string.
    */
   char defcontext[AST_MAX_CONTEXT];
   /*! \brief Extension to use in the dialplan. */
   char exten[AST_MAX_EXTENSION];
   /*!
    * \brief Language configured for calls.
    * \note The "language" string read in from chan_dahdi.conf
    */
   char language[MAX_LANGUAGE];
   /*!
    * \brief The configured music-on-hold class to use for calls.
    * \note The "musicclass" or "mohinterpret" or "musiconhold" string read in from chan_dahdi.conf
    */
   char mohinterpret[MAX_MUSICCLASS];
   /*!
    * \brief Sugggested music-on-hold class for peer channel to use for calls.
    * \note The "mohsuggest" string read in from chan_dahdi.conf
    */
   char mohsuggest[MAX_MUSICCLASS];
#ifdef PRI_ANI
   /*! \brief Automatic Number Identification number (Alternate PRI caller ID number) */
   char cid_ani[AST_MAX_EXTENSION];
#endif
   /*! \brief Caller ID number from an incoming call. */
   char cid_num[AST_MAX_EXTENSION];
   /*! \brief Caller ID Q.931 TON/NPI field values.  Set by PRI. Zero otherwise. */
   int cid_ton;
   /*! \brief Caller ID name from an incoming call. */
   char cid_name[AST_MAX_EXTENSION];
   /*! \brief Last Caller ID number from an incoming call. */
   char lastcid_num[AST_MAX_EXTENSION];
   /*! \brief Last Caller ID name from an incoming call. */
   char lastcid_name[AST_MAX_EXTENSION];
   char *origcid_num;            /*!< malloced original callerid */
   char *origcid_name;           /*!< malloced original callerid */
   /*! \brief Call waiting number. */
   char callwait_num[AST_MAX_EXTENSION];
   /*! \brief Call waiting name. */
   char callwait_name[AST_MAX_EXTENSION];
   /*! \brief Redirecting Directory Number Information Service (RDNIS) number */
   char rdnis[AST_MAX_EXTENSION];
   /*! \brief Dialed Number Identifier */
   char dnid[AST_MAX_EXTENSION];
   /*!
    * \brief Bitmapped groups this belongs to.
    * \note The "group" bitmapped group string read in from chan_dahdi.conf
    */
   ast_group_t group;
   /*! \brief Active PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW */
   int law;
   int confno;             /*!< Our conference */
   int confusers;             /*!< Who is using our conference */
   int propconfno;               /*!< Propagated conference number */
   /*!
    * \brief Bitmapped call groups this belongs to.
    * \note The "callgroup" bitmapped group string read in from chan_dahdi.conf
    */
   ast_group_t callgroup;
   /*!
    * \brief Bitmapped pickup groups this belongs to.
    * \note The "pickupgroup" bitmapped group string read in from chan_dahdi.conf
    */
   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 stop waiting for CID/CW CAS response (In samples) */
   int cid_suppress_expire;      /*!< How many samples to suppress after a CID spill. */
   /*! \brief Analog caller ID waveform sample buffer */
   unsigned char *cidspill;
   /*! \brief Position in the cidspill buffer to send out next. */
   int cidpos;
   /*! \brief Length of the cidspill buffer containing samples. */
   int cidlen;
   /*! \brief Ring timeout timer?? */
   int ringt;
   /*!
    * \brief Ring timeout base.
    * \note Value computed indirectly from "ringtimeout" read in from chan_dahdi.conf
    */
   int ringt_base;
   /*!
    * \brief Number of most significant digits/characters to strip from the dialed number.
    * \note Feature is deprecated.  Use dialplan logic.
    * \note The characters are stripped before the PRI TON/NPI prefix
    * characters are processed.
    */
   int stripmsd;
   /*!
    * \brief TRUE if Call Waiting (CW) CPE Alert Signal (CAS) is being sent.
    * \note
    * After CAS is sent, the call waiting caller id will be sent if the phone
    * gives a positive reply.
    */
   int callwaitcas;
   /*! \brief Number of call waiting rings. */
   int callwaitrings;
   /*! \brief Number of echo cancel taps.  0 if echo canceller not requested. */
   int echocancel;
   /*!
    * \brief Echo training time. 0 = disabled
    * \note Set from the "echotraining" value read in from chan_dahdi.conf
    */
   int echotraining;
   /*! \brief Filled with 'w'.  XXX Purpose?? */
   char echorest[20];
   /*!
    * \brief Number of times to see "busy" tone before hanging up.
    * \note Set from the "busycount" value read in from chan_dahdi.conf
    */
   int busycount;
   /*!
    * \brief Length of "busy" tone on time.
    * \note Set from the "busypattern" value read in from chan_dahdi.conf
    */
   int busy_tonelength;
   /*!
    * \brief Length of "busy" tone off time.
    * \note Set from the "busypattern" value read in from chan_dahdi.conf
    */
   int busy_quietlength;
   /*!
    * \brief Bitmapped call progress detection flags. CALLPROGRESS_xxx values.
    * \note Bits set from the "callprogress" and "faxdetect" values read in from chan_dahdi.conf
    */
   int callprogress;
   struct timeval flashtime;        /*!< Last flash-hook time */
   /*! \brief Opaque DSP configuration structure. */
   struct ast_dsp *dsp;
   //int cref;             /*!< Call reference number (Not used) */
   /*! \brief DAHDI dial operation command struct for ioctl() call. */
   struct dahdi_dialoperation dop;
   int whichwink;             /*!< SIG_FEATDMF_TA Which wink are we on? */
   /*! \brief Second part of SIG_FEATDMF_TA wink operation. */
   char finaldial[64];
   char accountcode[AST_MAX_ACCOUNT_CODE];      /*!< Account code */
   int amaflags;              /*!< AMA Flags */
   struct tdd_state *tdd;           /*!< TDD flag */
   /*! \brief Accumulated call forwarding number. */
   char call_forward[AST_MAX_EXTENSION];
   /*!
    * \brief Voice mailbox location.
    * \note Set from the "mailbox" string read in from chan_dahdi.conf
    */
   char mailbox[AST_MAX_EXTENSION];
   /*! \brief Delayed dialing for E911.  Overlap digits for ISDN. */
   char dialdest[256];
   /*! \brief Time the interface went on-hook. */
   int onhooktime;
   /*! \brief -1 = unknown, 0 = no messages, 1 = new messages available */
   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 */
   /*! \brief Holding place for event injected from outside normal operation. */
   int fake_event;
   /*!
    * \brief Minimal time period (ms) between the answer polarity
    * switch and hangup polarity switch.
    */
   int polarityonanswerdelay;
   /*! \brief Start delay time if polarityonanswerdelay is nonzero. */
   struct timeval polaritydelaytv;
   /*!
    * \brief Send caller ID after this many rings.
    * \note Set from the "sendcalleridafter" value read in from chan_dahdi.conf
    */
   int sendcalleridafter;
#ifdef HAVE_PRI
   /*! \brief DAHDI PRI control parameters */
   struct dahdi_pri *pri;
   /*! \brief XXX Purpose??? */
   struct dahdi_pvt *bearer;
   /*! \brief XXX Purpose??? */
   struct dahdi_pvt *realcall;
   /*! \brief Opaque libpri call control structure */
   q931_call *call;
   /*! \brief Channel number in span. */
   int prioffset;
   /*! \brief Logical span number within trunk group */
   int logicalspan;
#endif   
   /*! \brief Current line interface polarity. POLARITY_IDLE, POLARITY_REV */
   int polarity;
   /*! \brief DSP feature flags: DSP_FEATURE_xxx */
   int dsp_features;
   /*! \brief DTMF digit in progress.  0 when no digit in progress. */
   char begindigit;
} *iflist = NULL, *ifend = NULL;

/*! \brief Channel configuration from chan_dahdi.conf .
 * This struct is used for parsing the [channels] section of chan_dahdi.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 dahdi_chan_conf is used to configure the 
 * channel (struct dahdi_pvt)
 *
 * @seealso dahdi_chan_init for the default values.
 */
struct dahdi_chan_conf {
   struct dahdi_pvt chan;
#ifdef HAVE_PRI
   struct dahdi_pri pri;
#endif
   struct dahdi_params timing;

   /*!
    * \brief The serial port to listen for SMDI data on
    * \note Set from the "smdiport" string read in from chan_dahdi.conf
    */
   char smdi_port[SMDI_MAX_FILENAME_LEN];
};

/** returns a new dahdi_chan_conf with default values (by-value) */
static struct dahdi_chan_conf dahdi_chan_conf_default(void) {
   /* recall that if a field is not included here it is initialized
    * to 0 or equivalent
    */
   struct dahdi_chan_conf conf = {
#ifdef HAVE_PRI
      .pri = {
         .nsf = PRI_NSF_NONE,
         .switchtype = PRI_SWITCH_NI2,
         .dialplan = PRI_NATIONAL_ISDN + 1,
         .localdialplan = PRI_NATIONAL_ISDN + 1,
         .nodetype = PRI_CPE,

         .minunused = 2,
         .idleext = "",
         .idledial = "",
         .internationalprefix = "",
         .nationalprefix = "",
         .localprefix = "",
         .privateprefix = "",
         .unknownprefix = "",

         .resetinterval = 3600
      },
#endif
      .chan = {
         .context = "default",
         .cid_num = "",
         .cid_name = "",
         .mohinterpret = "default",
         .mohsuggest = "",
         .transfertobusy = 1,

         .cid_signalling = CID_SIG_BELL,
         .cid_start = CID_START_RING,
         .dahditrcallerid = 0,
         .use_callerid = 1,
         .sig = -1,
         .outsigmod = -1,

         .tonezone = -1,

         .echocancel = 1,

         .busycount = 3,

         .accountcode = "",

         .mailbox = "",


         .polarityonanswerdelay = 600,

         .sendcalleridafter = DEFAULT_CIDRINGS,

         .buf_policy = DAHDI_POLICY_IMMEDIATE,
         .buf_no = numbufs,
      },
      .timing = {
         .prewinktime = -1,
         .preflashtime = -1,
         .winktime = -1,
         .flashtime = -1,
         .starttime = -1,
         .rxwinktime = -1,
         .rxflashtime = -1,
         .debouncetime = -1
      },
      .smdi_port = "/dev/ttyS0",
   };

   return conf;
}


static struct ast_channel *dahdi_request(const char *type, int format, void *data, int *cause);
static int dahdi_digit_begin(struct ast_channel *ast, char digit);
static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
static int dahdi_sendtext(struct ast_channel *c, const char *text);
static int dahdi_call(struct ast_channel *ast, char *rdest, int timeout);
static int dahdi_hangup(struct ast_channel *ast);
static int dahdi_answer(struct ast_channel *ast);
static struct ast_frame *dahdi_read(struct ast_channel *ast);
static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame);
static struct ast_frame *dahdi_exception(struct ast_channel *ast);
static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen);
static int dahdi_func_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len); 
static int dahdi_func_write(struct ast_channel *chan, char *function, char *data, const char *value);

static const struct ast_channel_tech dahdi_tech = {
   .type = "DAHDI",
   .description = tdesc,
   .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
   .requester = dahdi_request,
   .send_digit_begin = dahdi_digit_begin,
   .send_digit_end = dahdi_digit_end,
   .send_text = dahdi_sendtext,
   .call = dahdi_call,
   .hangup = dahdi_hangup,
   .answer = dahdi_answer,
   .read = dahdi_read,
   .write = dahdi_write,
   .bridge = dahdi_bridge,
   .exception = dahdi_exception,
   .indicate = dahdi_indicate,
   .fixup = dahdi_fixup,
   .setoption = dahdi_setoption,
   .func_channel_read = dahdi_func_read,
   .func_channel_write = dahdi_func_write,
};

static const struct ast_channel_tech zap_tech = {
   .type = "Zap",
   .description = tdesc,
   .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
   .requester = dahdi_request,
   .send_digit_begin = dahdi_digit_begin,
   .send_digit_end = dahdi_digit_end,
   .send_text = dahdi_sendtext,
   .call = dahdi_call,
   .hangup = dahdi_hangup,
   .answer = dahdi_answer,
   .read = dahdi_read,
   .write = dahdi_write,
   .bridge = dahdi_bridge,
   .exception = dahdi_exception,
   .indicate = dahdi_indicate,
   .fixup = dahdi_fixup,
   .setoption = dahdi_setoption,
   .func_channel_read = dahdi_func_read,
   .func_channel_write = dahdi_func_write,
};

static const struct ast_channel_tech *chan_tech;

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

struct dahdi_pvt *round_robin[32];

#ifdef HAVE_PRI
static inline int pri_grab(struct dahdi_pvt *pvt, struct dahdi_pri *pri)
{
   int res;
   /* Grab the lock first */
   do {
      res = ast_mutex_trylock(&pri->lock);
      if (res) {
         DEADLOCK_AVOIDANCE(&pvt->lock);
      }
   } while (res);
   /* Then break the poll */
   if (pri->master != AST_PTHREADT_NULL)
      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 dahdi_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 & __DAHDI_SIG_FXO) */)
#define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)

#define dahdi_get_index(ast, p, nullok)   _dahdi_get_index(ast, p, nullok, __PRETTY_FUNCTION__, __LINE__)
static int _dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok, const char *fname, unsigned long line)
{
   int res;
   if (p->subs[SUB_REAL].owner == ast)
      res = 0;
   else if (p->subs[SUB_CALLWAIT].owner == ast)
      res = 1;
   else if (p->subs[SUB_THREEWAY].owner == ast)
      res = 2;
   else {
      res = -1;
      if (!nullok)
         ast_log(LOG_WARNING,
            "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
            ast ? ast->name : "", p->channel, fname, line);
   }
   return res;
}

/*!
 * \internal
 * \brief Obtain the specified subchannel owner lock if the owner exists.
 *
 * \param pvt Channel private struct.
 * \param sub_idx Subchannel owner to lock.
 *
 * \note Assumes the pvt->lock is already obtained.
 *
 * \note
 * Because deadlock avoidance may have been necessary, you need to confirm
 * the state of things before continuing.
 *
 * \return Nothing
 */
static void dahdi_lock_sub_owner(struct dahdi_pvt *pvt, int sub_idx)
{
   for (;;) {
      if (!pvt->subs[sub_idx].owner) {
         /* No subchannel owner pointer */
         break;
      }
      if (!ast_mutex_trylock(&pvt->subs[sub_idx].owner->lock)) {
         /* Got subchannel owner lock */
         break;
      }
      /* We must unlock the private to avoid the possibility of a deadlock */
      DEADLOCK_AVOIDANCE(&pvt->lock);
   }
}

static void wakeup_sub(struct dahdi_pvt *p, int a, struct dahdi_pri *pri)
{
#ifdef HAVE_PRI
   if (pri)
      ast_mutex_unlock(&pri->lock);
#endif         
   dahdi_lock_sub_owner(p, a);
   if (p->subs[a].owner) {
      ast_queue_frame(p->subs[a].owner, &ast_null_frame);
      ast_mutex_unlock(&p->subs[a].owner->lock);
   }
#ifdef HAVE_PRI
   if (pri)
      ast_mutex_lock(&pri->lock);
#endif         
}

#ifdef HAVE_PRI
static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f, struct dahdi_pri *pri)
#else
static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f, void *pri)
#endif
{
   /* We must unlock the PRI to avoid the possibility of a deadlock */
#ifdef HAVE_PRI
   if (pri)
      ast_mutex_unlock(&pri->lock);
#endif      
   for (;;) {
      if (p->owner) {
         if (ast_mutex_trylock(&p->owner->lock)) {
            DEADLOCK_AVOIDANCE(&p->lock);
         } else {
            ast_queue_frame(p->owner, f);
            ast_mutex_unlock(&p->owner->lock);
            break;
         }
      } else
         break;
   }
#ifdef HAVE_PRI
   if (pri)
      ast_mutex_lock(&pri->lock);
#endif      
}

static int restore_gains(struct dahdi_pvt *p);

static void swap_subs(struct dahdi_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].dfd;
   if (p->subs[b].owner) 
      p->subs[b].owner->fds[0] = p->subs[b].dfd;
   wakeup_sub(p, a, NULL);
   wakeup_sub(p, b, NULL);
}

static int dahdi_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 = DAHDI_FILE_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, DAHDI_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, DAHDI_SET_BLOCKSIZE, &bs) == -1) {
      ast_log(LOG_WARNING, "Unable to set blocksize '%d': %s\n", bs,  strerror(errno));
      x = errno;
      close(fd);
      errno = x;
      return -1;
   }
   return fd;
}

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

static void dahdi_close_sub(struct dahdi_pvt *chan_pvt, int sub_num)
{
   dahdi_close(chan_pvt->subs[sub_num].dfd);
   chan_pvt->subs[sub_num].dfd = -1;
}
 
#ifdef HAVE_PRI
static void dahdi_close_pri_fd(struct dahdi_pri *pri, int fd_num)
{
   dahdi_close(pri->fds[fd_num]);
   pri->fds[fd_num] = -1;
}
#endif

static int dahdi_setlinear(int dfd, int linear)
{
   int res;
   res = ioctl(dfd, DAHDI_SETLINEAR, &linear);
   if (res)
      return res;
   return 0;
}


static int alloc_sub(struct dahdi_pvt *p, int x)
{
   struct dahdi_bufferinfo bi;
   int res;
   if (p->subs[x].dfd < 0) {
      p->subs[x].dfd = dahdi_open(DAHDI_FILE_PSEUDO);
      if (p->subs[x].dfd > -1) {
         res = ioctl(p->subs[x].dfd, DAHDI_GET_BUFINFO, &bi);
         if (!res) {
            bi.txbufpolicy = p->buf_policy;
            bi.rxbufpolicy = p->buf_policy;
            bi.numbufs = p->buf_no;
            res = ioctl(p->subs[x].dfd, DAHDI_SET_BUFINFO, &bi);
            if (res < 0) {
               ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d: %s\n", x, strerror(errno));
            }
         } else 
            ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d: %s\n", x, strerror(errno));
         if (ioctl(p->subs[x].dfd, DAHDI_CHANNO, &p->subs[x].chan) == 1) {
            ast_log(LOG_WARNING, "Unable to get channel number for pseudo channel on FD %d: %s\n", p->subs[x].dfd, strerror(errno));
            dahdi_close_sub(p, x);
            return -1;
         }
         if (option_debug)
            ast_log(LOG_DEBUG, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].dfd, 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 dahdi_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);
   dahdi_close_sub(p, x);
   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 digit_to_dtmfindex(char digit)
{
   if (isdigit(digit))
      return DAHDI_TONE_DTMF_BASE + (digit - '0');
   else if (digit >= 'A' && digit <= 'D')
      return DAHDI_TONE_DTMF_A + (digit - 'A');
   else if (digit >= 'a' && digit <= 'd')
      return DAHDI_TONE_DTMF_A + (digit - 'a');
   else if (digit == '*')
      return DAHDI_TONE_DTMF_s;
   else if (digit == '#')
      return DAHDI_TONE_DTMF_p;
   else
      return -1;
}

static int dahdi_digit_begin(struct ast_channel *chan, char digit)
{
   struct dahdi_pvt *pvt;
   int index;
   int dtmf = -1;
   
   pvt = chan->tech_pvt;

   ast_mutex_lock(&pvt->lock);

   index = dahdi_get_index(chan, pvt, 0);

   if ((index != SUB_REAL) || !pvt->owner)
      goto out;

#ifdef HAVE_PRI
   if (pvt->sig == SIG_PRI
      && chan->_state == AST_STATE_DIALING) {
      if (pvt->call_level < DAHDI_CALL_LEVEL_OVERLAP) {
         unsigned int len;

         len = strlen(pvt->dialdest);
         if (len < sizeof(pvt->dialdest) - 1) {
            ast_log(LOG_DEBUG,
               "Queueing digit '%c' since setup_ack not yet received\n", digit);
            pvt->dialdest[len++] = digit;
            pvt->dialdest[len] = '\0';
         } else {
            ast_log(LOG_WARNING,
               "Span %d: Deferred digit buffer overflow for digit '%c'.\n",
               pvt->span, digit);
         }
         goto out;
      }
      if (pvt->call_level < DAHDI_CALL_LEVEL_PROCEEDING) {
         if (!pri_grab(pvt, pvt->pri)) {
            pri_information(pvt->pri->pri, pvt->call, digit);
            pri_rel(pvt->pri);
         } else {
            ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", pvt->span);
         }
         goto out;
      }
      if (pvt->call_level < DAHDI_CALL_LEVEL_CONNECT) {
         ast_log(LOG_WARNING,
            "Span %d: Digit '%c' may be ignored by peer. (Call level:%d)\n",
            pvt->span, digit, pvt->call_level);
      }
   }
#endif
   if ((dtmf = digit_to_dtmfindex(digit)) == -1)
      goto out;

   if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &dtmf)) {
      int res;
      struct dahdi_dialoperation zo = {
         .op = DAHDI_DIAL_OP_APPEND,
         .dialstr[0] = 'T',
         .dialstr[1] = digit,
         .dialstr[2] = 0,
      };
      if ((res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_DIAL, &zo)))
         ast_log(LOG_WARNING, "Couldn't dial digit %c: %s\n", digit, strerror(errno));
      else
         pvt->dialing = 1;
   } else {
      ast_log(LOG_DEBUG, "Started VLDTMF digit '%c'\n", digit);
      pvt->dialing = 1;
      pvt->begindigit = digit;
   }

out:
   ast_mutex_unlock(&pvt->lock);

   return 0;
}

static int dahdi_digit_end(struct ast_channel *chan, char digit, unsigned int duration)
{
   struct dahdi_pvt *pvt;
   int res = 0;
   int index;
   int x;
   
   pvt = chan->tech_pvt;

   ast_mutex_lock(&pvt->lock);
   
   index = dahdi_get_index(chan, pvt, 0);

   if ((index != SUB_REAL) || !pvt->owner || pvt->pulse)
      goto out;

#ifdef HAVE_PRI
   /* This means that the digit was already sent via PRI signalling */
   if (pvt->sig == SIG_PRI && !pvt->begindigit)
      goto out;
#endif

   if (pvt->begindigit) {
      x = -1;
      ast_log(LOG_DEBUG, "Ending VLDTMF digit '%c'\n", digit);
      res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &x);
      pvt->dialing = 0;
      pvt->begindigit = 0;
   }

out:
   ast_mutex_unlock(&pvt->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[] = {
   { DAHDI_ALARM_RED, "Red Alarm" },
   { DAHDI_ALARM_YELLOW, "Yellow Alarm" },
   { DAHDI_ALARM_BLUE, "Blue Alarm" },
   { DAHDI_ALARM_RECOVER, "Recovering" },
   { DAHDI_ALARM_LOOPBACK, "Loopback" },
   { DAHDI_ALARM_NOTOPEN, "Not Open" },
   { DAHDI_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 HAVE_PRI
static char *dialplan2str(int dialplan)
{
   if (dialplan == -1) {
      return("Dynamically set dialplan in ISDN");
   }
   return (pri_plan2str(dialplan));
}
#endif

static char *dahdi_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_FGC_CAMA:
      return "FGC/CAMA (Dialpulse)";
   case SIG_FGC_CAMAMF:
      return "FGC/CAMA (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 "ISDN PRI";
   case SIG_SF:
      return "SF (Tone) Immediate";
   case SIG_SFWINK:
      return "SF (Tone) Wink";
   case SIG_SF_FEATD:
      return "SF (Tone) with Feature Group D (DTMF)";
   case SIG_SF_FEATDMF:
      return "SF (Tone) with Feature Group D (MF)";
   case SIG_SF_FEATB:
      return "SF (Tone) with Feature Group B (MF)";
   case SIG_GR303FXOKS:
      return "GR-303 with FXOKS";
   case SIG_GR303FXSKS:
      return "GR-303 with FXSKS";
   case 0:
      return "Pseudo";
   default:
      snprintf(buf, sizeof(buf), "Unknown signalling %d", sig);
      return buf;
   }
}

#define sig2str dahdi_sig2str

static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel)
{
   /* If the conference already exists, and we're already in it
      don't bother doing anything */
   struct dahdi_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 = DAHDI_CONF_DIGITALMON;
      zi.confno = slavechannel;
   } else {
      if (!index) {
         /* Real-side and pseudo-side both participate in conference */
         zi.confmode = DAHDI_CONF_REALANDPSEUDO | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER |
            DAHDI_CONF_PSEUDO_TALKER | DAHDI_CONF_PSEUDO_LISTENER;
      } else
         zi.confmode = DAHDI_CONF_CONF | DAHDI_CONF_TALKER | DAHDI_CONF_LISTENER;
      zi.confno = p->confno;
   }
   if ((zi.confno == c->curconf.confno) && (zi.confmode == c->curconf.confmode))
      return 0;
   if (c->dfd < 0)
      return 0;
   if (ioctl(c->dfd, DAHDI_SETCONF, &zi)) {
      ast_log(LOG_WARNING, "Failed to add %d to conference %d/%d: %s\n", c->dfd, zi.confmode, zi.confno, strerror(errno));
      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->dfd, c->curconf.confmode, c->curconf.confno);
   return 0;
}

static int isourconf(struct dahdi_pvt *p, struct dahdi_subchannel *c)
{
   /* If they're listening to our channel, they're ours */  
   if ((p->channel == c->curconf.confno) && (c->curconf.confmode == DAHDI_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 & DAHDI_CONF_TALKER))
      return 1;
   return 0;
}

static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index)
{
   struct dahdi_confinfo zi;
   if (/* Can't delete if there's no dfd */
      (c->dfd < 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));
   if (ioctl(c->dfd, DAHDI_SETCONF, &zi)) {
      ast_log(LOG_WARNING, "Failed to drop %d from conference %d/%d: %s\n", c->dfd, c->curconf.confmode, c->curconf.confno, strerror(errno));
      return -1;
   }
   ast_log(LOG_DEBUG, "Removed %d from conference %d/%d\n", c->dfd, c->curconf.confmode, c->curconf.confno);
   memcpy(&c->curconf, &zi, sizeof(c->curconf));
   return 0;
}

static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out)
{
   int x;
   int useslavenative;
   struct dahdi_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].dfd > -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 dahdi_pvt *p)
{
   p->confno = -1;
   memset(&p->subs[SUB_REAL].curconf, 0, sizeof(p->subs[SUB_REAL].curconf));
   if (p->subs[SUB_REAL].dfd > -1) {
      struct dahdi_confinfo zi;

      memset(&zi, 0, sizeof(zi));
      if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCONF, &zi))
         ast_log(LOG_WARNING, "Failed to reset conferencing on channel %d: %s\n", p->channel, strerror(errno));
   }
   return 0;
}

static int update_conf(struct dahdi_pvt *p)
{
   int needconf = 0;
   int x;
   int useslavenative;
   struct dahdi_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].dfd > -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;
   }
   if (option_debug)
      ast_log(LOG_DEBUG, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
   return 0;
}

static void dahdi_enable_ec(struct dahdi_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].dfd, DAHDI_AUDIOMODE, &x);
         if (res)
            ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n", p->channel, strerror(errno));
      }
      x = p->echocancel;
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_ECHOCANCEL, &x);
      if (res) 
         ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d (%s)\n", p->channel, strerror(errno));
      else {
         p->echocanon = 1;
         if (option_debug)
            ast_log(LOG_DEBUG, "Enabled echo cancellation on channel %d\n", p->channel);
      }
   } else if (option_debug)
      ast_log(LOG_DEBUG, "No echo cancellation requested\n");
}

static void dahdi_train_ec(struct dahdi_pvt *p)
{
   int x;
   int res;
   if (p && p->echocancel && p->echotraining) {
      x = p->echotraining;
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_ECHOTRAIN, &x);
      if (res)
         ast_log(LOG_WARNING, "Unable to request echo training on channel %d: %s\n", p->channel, strerror(errno));
      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 dahdi_disable_ec(struct dahdi_pvt *p)
{
   int x;
   int res;
   if (p->echocancel) {
      x = 0;
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_ECHOCANCEL, &x);
      if (res)
         ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d: %s\n", p->channel, strerror(errno));
      else if (option_debug)
         ast_log(LOG_DEBUG, "disabled echo cancellation on channel %d\n", p->channel);
   }
   p->echocanon = 0;
}

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

   switch (law) {
   case DAHDI_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 DAHDI_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 dahdi_gains *g, float gain, int law)
{
   int j;
   int k;
   float linear_gain = pow(10.0, gain / 20.0);

   switch (law) {
   case DAHDI_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 DAHDI_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;
   }
}

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

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

   fill_txgain(&g, gain, law);

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

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

   memset(&g, 0, sizeof(g));
   g.chan = chan;
   res = ioctl(fd, DAHDI_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, DAHDI_SETGAINS, &g);
}

static 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 dahdi_pvt *p)
{
   int res;

   /* Bump receive gain by 5.0db */
   res = set_actual_gain(p->subs[SUB_REAL].dfd, 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 dahdi_pvt *p)
{
   int res;

   res = set_actual_gain(p->subs[SUB_REAL].dfd, 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 dahdi_set_hook(int fd, int hs)
{
   int x, res;

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

   if (res < 0) {
      if (errno == EINPROGRESS)
         return 0;
      ast_log(LOG_WARNING, "DAHDI hook failed returned %d (trying %d): %s\n", res, hs, strerror(errno));
      /* will expectedly fail if phone is off hook during operation, such as during a restart */
   }

   return res;
}

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

static int save_conference(struct dahdi_pvt *p)
{
   struct dahdi_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].dfd, DAHDI_GETCONF, &p->saveconf);
   if (res) {
      ast_log(LOG_WARNING, "Unable to get conference info: %s\n", strerror(errno));
      p->saveconf.confmode = 0;
      return -1;
   }
   memset(&c, 0, sizeof(c));
   c.confmode = DAHDI_CONF_NORMAL;
   res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 dahdi_pvt *p)
{
   int res;
   if (p->saveconf.confmode) {
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 dahdi_pvt *p);

static int send_cwcidspill(struct dahdi_pvt *p)
{
   p->callwaitcas = 0;
   p->cidcwexpire = 0;
   p->cid_suppress_expire = 0;
   if (!(p->cidspill = ast_malloc(MAX_CALLERID_SIZE)))
      return -1;
   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);
   return 0;
}

static int has_voicemail(struct dahdi_pvt *p)
{

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

static int send_callerid(struct dahdi_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;
      dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
   }
   while (p->cidpos < p->cidlen) {
      res = write(p->subs[SUB_REAL].dfd, 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;
   }
   p->cid_suppress_expire = CALLWAITING_SUPPRESS_SAMPLES;
   free(p->cidspill);
   p->cidspill = NULL;
   if (p->callwaitcas) {
      /* Wait for CID/CW to expire */
      p->cidcwexpire = CIDCW_EXPIRE_SAMPLES;
      p->cid_suppress_expire = p->cidcwexpire;
   } else
      restore_conference(p);
   return 0;
}

static int dahdi_callwait(struct ast_channel *ast)
{
   struct dahdi_pvt *p = ast->tech_pvt;
   p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
   if (p->cidspill) {
      ast_log(LOG_WARNING, "Spill already exists?!?\n");
      free(p->cidspill);
   }

   /*
    * SAS: Subscriber Alert Signal, 440Hz for 300ms
    * CAS: CPE Alert Signal, 2130Hz * 2750Hz sine waves
    */
   if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
      return -1;
   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);
   
   return 0;
}

static int dahdi_call(struct ast_channel *ast, char *rdest, int timeout)
{
   struct dahdi_pvt *p = ast->tech_pvt;
   int x, res, index,mysig;
   char *c, *n, *l;
#ifdef HAVE_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, "dahdi_call called on %s, neither down nor reserved\n", ast->name);
      ast_mutex_unlock(&p->lock);
      return -1;
   }
   p->dialednone = 0;
   if ((p->radio || (p->oprmode < 0)))  /* if a radio channel, up immediately */
   {
      /* Special pseudo -- automatically up */
      ast_setstate(ast, AST_STATE_UP); 
      ast_mutex_unlock(&p->lock);
      return 0;
   }
   x = DAHDI_FLUSH_READ | DAHDI_FLUSH_WRITE;
   res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_FLUSH, &x);
   if (res)
      ast_log(LOG_WARNING, "Unable to flush input on channel %d: %s\n", p->channel, strerror(errno));
   p->outgoing = 1;

   if (IS_DIGITAL(ast->transfercapability)) {
      set_actual_gain(p->subs[SUB_REAL].dfd, 0, 0, 0, p->law);
   } else {
      set_actual_gain(p->subs[SUB_REAL].dfd, 0, p->rxgain, p->txgain, p->law);
   }

   mysig = p->sig;
   if (p->outsigmod > -1)
      mysig = p->outsigmod;

   switch (mysig) {
   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->callwaitcas = 0;
            if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
               p->cidlen = ast_callerid_generate(p->cidspill, ast->cid.cid_name, ast->cid.cid_num, AST_LAW(p));
               p->cidpos = 0;
               send_callerid(p);
            }
         }
         /* Choose proper cadence */
         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
            if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
               ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast->name, strerror(errno));
            p->cidrings = cidrings[p->distinctivering - 1];
         } else {
            if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
               ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast->name, strerror(errno));
            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 = DAHDI_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 = DAHDI_RING;
         if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 (dahdi_callwait(ast)) {
            ast_mutex_unlock(&p->lock);
            return -1;
         }
         /* Make ring-back */
         if (tone_zone_play_tone(p->subs[SUB_CALLWAIT].dfd, DAHDI_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 = dahdi_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_FGC_CAMA:
   case SIG_FGC_CAMAMF:
   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 HAVE_PRI
      /* Start the trunk, if not GR-303 */
      if (!p->pri) {
#endif
         x = DAHDI_START;
         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 HAVE_PRI
      }
#endif
      ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
      p->dop.op = DAHDI_DIAL_OP_REPLACE;

      c += p->stripmsd;

      switch (mysig) {
      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:
      {
         const char *cic, *ozz;

         /* 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_FGC_CAMA:
         snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%s", c);
         break;
      case SIG_FGC_CAMAMF:
      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].dfd, DAHDI_DIAL, &p->dop)) {
            int saveerr = errno;

            x = DAHDI_ONHOOK;
            ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
            ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr));
            ast_mutex_unlock(&p->lock);
            return -1;
         }
      } else
         ast_log(LOG_DEBUG, "Deferring dialing... (res %d)\n", res);
      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';
      p->dialing = 1;
      break;
   default:
      ast_log(LOG_DEBUG, "not yet implemented\n");
      ast_mutex_unlock(&p->lock);
      return -1;
   }
#ifdef HAVE_PRI
   if (p->pri) {
      struct pri_sr *sr;
#ifdef SUPPORT_USERUSER
      const char *useruser;
#endif
      int pridialplan;
      int dp_strip;
      int prilocaldialplan;
      int ldp_strip;
      int exclusive;
      const char *rr_str;
      int redirect_reason;

      c = strchr(dest, '/');
      if (c) {
         c++;
      } else {
         c = "";
      }

      l = NULL;
      n = NULL;
      if (!p->hidecallerid) {
         l = ast->cid.cid_num;
         if (!p->hidecalleridname) {
            n = ast->cid.cid_name;
         }
      }


      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 (mysig != SIG_FXSKS) {
         p->dop.op = DAHDI_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_destroycall(p->pri->pri, p->call);
         p->call = NULL;
         pri_rel(p->pri);
         ast_mutex_unlock(&p->lock);
         return -1;
      }
      if (p->bearer || (mysig == 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);

      /* Should the picked channel be used exclusively? */
      if (p->priexclusive || p->pri->nodetype == PRI_NETWORK) {
         exclusive = 1;
      } else {
         exclusive = 0;
      }
      
      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 == DAHDI_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));
      if ((rr_str = pbx_builtin_getvar_helper(ast, "PRIREDIRECTREASON"))) {
         if (!strcasecmp(rr_str, "UNKNOWN"))
            redirect_reason = 0;
         else if (!strcasecmp(rr_str, "BUSY"))
            redirect_reason = 1;
         else if (!strcasecmp(rr_str, "NO_REPLY"))
            redirect_reason = 2;
         else if (!strcasecmp(rr_str, "UNCONDITIONAL"))
            redirect_reason = 15;
         else
            redirect_reason = PRI_REDIR_UNCONDITIONAL;
      } else
         redirect_reason = PRI_REDIR_UNCONDITIONAL;
      pri_sr_set_redirecting(sr, ast->cid.cid_rdnis, p->pri->localdialplan - 1, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, redirect_reason);

#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_destroycall(p->pri->pri, p->call);
         p->call = NULL;
         pri_rel(p->pri);
         ast_mutex_unlock(&p->lock);
         pri_sr_free(sr);
         return -1;
      }
      p->call_level = DAHDI_CALL_LEVEL_SETUP;
      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_dahdi_pvt(struct dahdi_pvt **pvt)
{
   struct dahdi_pvt *p = *pvt;
   /* Remove channel from the list */
   if (p->prev)
      p->prev->next = p->next;
   if (p->next)
      p->next->prev = p->prev;

   free(p->cidspill);
   if (p->use_smdi)
      ast_smdi_interface_unref(p->smdi_iface);
   ast_mutex_destroy(&p->lock);
   dahdi_close_sub(p, SUB_REAL);
   if (p->owner)
      p->owner->tech_pvt = NULL;
   free(p);
   *pvt = NULL;
}

static int destroy_channel(struct dahdi_pvt *prev, struct dahdi_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;
         }
         destroy_dahdi_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;
      }
      destroy_dahdi_pvt(&cur);
   }
   return 0;
}

static void destroy_all_channels(void)
{
   int x;
   struct dahdi_pvt *p, *pl;

   while (num_restart_pending) {
      usleep(1);
   }

   ast_mutex_lock(&iflock);
   /* Destroy all the interfaces and free their memory */
   p = iflist;
   while (p) {
      pl = p;
      p = p->next;
      x = pl->channel;
      /* Free associated memory */
      destroy_dahdi_pvt(&pl);
      if (option_verbose > 2) 
         ast_verbose(VERBOSE_PREFIX_2 "Unregistered channel %d\n", x);
   }
   iflist = NULL;
   ifcount = 0;
   ast_mutex_unlock(&iflock);
}

#ifdef HAVE_PRI
static char *dahdi_send_keypad_facility_app = "DAHDISendKeypadFacility";
static char *zap_send_keypad_facility_app = "ZapSendKeypadFacility";

static char *dahdi_send_keypad_facility_synopsis = "Send digits out of band over a PRI";
static char *zap_send_keypad_facility_synopsis = "Send digits out of band over a PRI";

static char *dahdi_send_keypad_facility_descrip = 
"  DAHDISendKeypadFacility(): This application will send the given string of digits in a Keypad Facility\n"
"  IE over the current channel.\n";
static char *zap_send_keypad_facility_descrip = 
"  ZapSendKeypadFacility(): This application will send the given string of digits in a Keypad Facility\n"
"  IE over the current channel.\n";

static int send_keypad_facility_exec(struct ast_channel *chan, void *data)
{
   /* Data will be our digit string */
   struct dahdi_pvt *p;
   char *digits = (char *) data;

   if (ast_strlen_zero(digits)) {
      ast_log(LOG_DEBUG, "No digit string sent to application!\n");
      return -1;
   }

   p = (struct dahdi_pvt *)chan->tech_pvt;

   if (!p) {
      ast_log(LOG_DEBUG, "Unable to find technology private\n");
      return -1;
   }

   ast_mutex_lock(&p->lock);

   if (!p->pri || !p->call) {
      ast_log(LOG_DEBUG, "Unable to find pri or call on channel!\n");
      ast_mutex_unlock(&p->lock);
      return -1;
   }

   if (!pri_grab(p, p->pri)) {
      pri_keypad_facility(p->pri->pri, p->call, digits);
      pri_rel(p->pri);
   } else {
      ast_log(LOG_DEBUG, "Unable to grab pri to send keypad facility!\n");
      ast_mutex_unlock(&p->lock);
      return -1;
   }

   ast_mutex_unlock(&p->lock);

   return 0;
}

static int dahdi_send_keypad_facility_exec(struct ast_channel *chan, void *data)
{
   return send_keypad_facility_exec(chan, data);
}

static int zap_send_keypad_facility_exec(struct ast_channel *chan, void *data)
{
   ast_log(LOG_WARNING, "Use of the command %s is deprecated, please use %s instead.\n", zap_send_keypad_facility_app, dahdi_send_keypad_facility_app);  
   return send_keypad_facility_exec(chan, data);
}

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

static int pri_assign_bearer(struct dahdi_pvt *crv, struct dahdi_pri *pri, struct dahdi_pvt *bearer)
{
   bearer->owner = &inuse;
   bearer->realcall = crv;
   crv->subs[SUB_REAL].dfd = bearer->subs[SUB_REAL].dfd;
   if (crv->subs[SUB_REAL].owner)
      crv->subs[SUB_REAL].owner->fds[0] = crv->subs[SUB_REAL].dfd;
   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 */
static int pri_active_dchan_fd(struct dahdi_pri *pri)
{
   int x = -1;

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

   return pri->fds[x];
}

static int pri_find_dchan(struct dahdi_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;
      if (!pri->no_d_channels) {
         pri->no_d_channels = 1;
         ast_log(LOG_WARNING,
            "No D-channels available!  Using Primary channel %d as D-channel anyway!\n",
            pri->dchannels[newslot]);
      }
   } else {
      pri->no_d_channels = 0;
   }
   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 dahdi_hangup(struct ast_channel *ast)
{
   int res;
   int index,x, law;
   /*static int restore_gains(struct dahdi_pvt *p);*/
   struct dahdi_pvt *p = ast->tech_pvt;
   struct dahdi_pvt *tmp = NULL;
   struct dahdi_pvt *prev = NULL;
   struct dahdi_params par;

   if (option_debug)
      ast_log(LOG_DEBUG, "dahdi_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 = dahdi_get_index(ast, p, 1);

   if (p->sig == SIG_PRI) {
      x = 1;
      ast_channel_setoption(ast,AST_OPTION_AUDIO_MODE,&x,sizeof(char),0);
      p->cid_num[0] = '\0';
      p->cid_name[0] = '\0';
   }

   x = 0;
   dahdi_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);
   p->exten[0] = '\0';

   if (option_debug)
      ast_log(LOG_DEBUG, "Hangup: channel: %d index = %d, normal = %d, callwait = %d, thirdcall = %d\n",
      p->channel, index, p->subs[SUB_REAL].dfd, p->subs[SUB_CALLWAIT].dfd, p->subs[SUB_THREEWAY].dfd);
   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;
      dahdi_setlinear(p->subs[index].dfd, 0);
      switch (index) {
      case SUB_REAL:
         if ((p->subs[SUB_CALLWAIT].dfd > -1) && (p->subs[SUB_THREEWAY].dfd > -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->subs[SUB_REAL].inthreeway = 0;
                  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;
               }
            }
         } else if (p->subs[SUB_CALLWAIT].dfd > -1) {
            /* Need to hold the lock for real-call, private, and call-waiting call */
            dahdi_lock_sub_owner(p, SUB_CALLWAIT);
            if (!p->subs[SUB_CALLWAIT].owner) {
               /* The call waiting call dissappeared. */
               p->owner = NULL;
               break;
            }

            /* 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_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD);
            /* Unlock the call-waiting call that we swapped to real-call. */
            ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
         } else if (p->subs[SUB_THREEWAY].dfd > -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->subs[SUB_REAL].inthreeway = 0;
               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;
            }
         }
         break;
      case SUB_CALLWAIT:
         /* Ditch the holding callwait call, and immediately make it availabe */
         if (p->subs[SUB_CALLWAIT].inthreeway) {
            /* Need to hold the lock for call-waiting call, private, and 3-way call */
            dahdi_lock_sub_owner(p, SUB_THREEWAY);

            /* 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_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD, 
                  S_OR(p->mohsuggest, NULL),
                  !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
            }
            p->subs[SUB_THREEWAY].inthreeway = 0;
            /* Make it the call wait now */
            swap_subs(p, SUB_CALLWAIT, SUB_THREEWAY);
            unalloc_sub(p, SUB_THREEWAY);
            if (p->subs[SUB_CALLWAIT].owner) {
               /* Unlock the 3-way call that we swapped to call-waiting call. */
               ast_mutex_unlock(&p->subs[SUB_CALLWAIT].owner->lock);
            }
         } else
            unalloc_sub(p, SUB_CALLWAIT);
         break;
      case SUB_THREEWAY:
         /* Need to hold the lock for 3-way call, private, and call-waiting call */
         dahdi_lock_sub_owner(p, SUB_CALLWAIT);
         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 */
            p->subs[SUB_CALLWAIT].inthreeway = 0;
            if (p->subs[SUB_CALLWAIT].owner && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) {
               ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD, 
                  S_OR(p->mohsuggest, NULL),
                  !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
            }
         }
         if (p->subs[SUB_CALLWAIT].owner) {
            ast_mutex_unlock(&p->subs[SUB_CALLWAIT].owner->lock);
         }
         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);
         break;
      default:
         /*
          * Should never happen.
          * This wasn't any sort of call, so how are we an index?
          */
         ast_log(LOG_ERROR, "Index found but not any type of call?\n");
         break;
      }
   }

   if (!p->subs[SUB_REAL].owner && !p->subs[SUB_CALLWAIT].owner && !p->subs[SUB_THREEWAY].owner) {
      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 HAVE_PRI
      p->dialing = 0;
      p->progress = 0;
      p->call_level = DAHDI_CALL_LEVEL_IDLE;
#endif      
      if (p->dsp) {
         ast_dsp_free(p->dsp);
         p->dsp = NULL;
      }

      if (p->bufferoverrideinuse) {
         /* faxbuffers are in use, revert them */
         struct dahdi_bufferinfo bi = {
            .txbufpolicy = p->buf_policy,
            .rxbufpolicy = p->buf_policy,
            .bufsize = p->bufsize,
            .numbufs = p->buf_no
         };
         int bpres;

         if ((bpres = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
            ast_log(LOG_WARNING, "Channel '%s' unable to revert faxbuffer policy: %s\n", ast->name, strerror(errno));
         }
         p->bufferoverrideinuse = 0;   
      }

      law = DAHDI_LAW_DEFAULT;
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
      if (res < 0) 
         ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
      /* Perform low level hangup if no owner left */
#if defined(HAVE_PRI)
      if (p->pri) {
#ifdef SUPPORT_USERUSER
         const 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) */
         pri_grab(p, p->pri);
         if (p->call && (!p->bearer || (p->bearer->call == p->call))) {
            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 {
               const 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);
            }
         } 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;
         }
         p->allocated = 0;
         p->owner = NULL;
         pri_rel(p->pri);
         res = 0;
      } else
#endif   /* defined(HAVE_PRI) */
      {
         p->owner = NULL;
      }
      if (p->sig && (p->sig != SIG_PRI))
         res = dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_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:
         memset(&par, 0, sizeof(par));
         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 || (p->oprmode < 0))))
               tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_CONGESTION);
            else
               tone_zone_play_tone(p->subs[SUB_REAL].dfd, -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].dfd, -1);
      }
      free(p->cidspill);
      p->cidspill = NULL;
      if (p->sig)
         dahdi_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->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 HAVE_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].dfd = -1;
         p->pri = NULL;
      }
#endif
      if (num_restart_pending == 0)
         restart_monitor();
   }

   p->callwaitingrepeat = 0;
   p->cidcwexpire = 0;
   p->cid_suppress_expire = 0;
   p->oprmode = 0;
   ast->tech_pvt = NULL;
   ast_mutex_unlock(&p->lock);
   if (option_verbose > 2) 
      ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);

   ast_mutex_lock(&iflock);
   if (p->restartpending) {
      num_restart_pending--;
   }

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

   ast_module_unref(ast_module_info->self);
   return 0;
}

static int dahdi_answer(struct ast_channel *ast)
{
   struct dahdi_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 = dahdi_get_index(ast, p, 0);
   if (index < 0)
      index = SUB_REAL;
   /* nothing to do if a radio channel */
   if ((p->radio || (p->oprmode < 0))) {
      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_FEATDMF_TA:
   case SIG_E911:
   case SIG_FGC_CAMA:
   case SIG_FGC_CAMAMF:
   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 = dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
      tone_zone_play_tone(p->subs[index].dfd, -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].dfd, -1);
            swap_subs(p, SUB_THREEWAY, SUB_REAL);
            p->owner = p->subs[SUB_REAL].owner;
         }
      }
      if (p->sig & __DAHDI_SIG_FXS) {
         dahdi_enable_ec(p);
         dahdi_train_ec(p);
      }
      break;
#ifdef HAVE_PRI
   case SIG_PRI:
      /* Send a pri acknowledge */
      if (!pri_grab(p, p->pri)) {
         if (p->call_level < DAHDI_CALL_LEVEL_CONNECT) {
            p->call_level = DAHDI_CALL_LEVEL_CONNECT;
         }
         p->dialing = 0;
         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
   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 dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen)
{
   char *cp;
   signed char *scp;
   int x;
   int index;
   struct dahdi_pvt *p = chan->tech_pvt, *pp;
   struct oprmode *oprmode;
   

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

   switch (option) {
   case AST_OPTION_TXGAIN:
      scp = (signed char *) data;
      index = dahdi_get_index(chan, p, 0);
      if (index < 0) {
         ast_log(LOG_WARNING, "No index in TXGAIN?\n");
         return -1;
      }
      if (option_debug)
         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].dfd, 0, p->txgain + (float) *scp, p->law);
   case AST_OPTION_RXGAIN:
      scp = (signed char *) data;
      index = dahdi_get_index(chan, p, 0);
      if (index < 0) {
         ast_log(LOG_WARNING, "No index in RXGAIN?\n");
         return -1;
      }
      if (option_debug)
         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].dfd, 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 */
         if (option_debug)
            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);
      dahdi_disable_ec(p);
      /* otherwise, turn it on */
      if (!p->didtdd) { /* if havent done it yet */
         unsigned char mybuf[41000];/*! \todo XXX This is an abuse of the stack!! */
         unsigned char *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 = dahdi_get_index(chan, p, 0);
         if (index < 0) {
            ast_log(LOG_WARNING, "No index in TDD?\n");
            return -1;
         }
         fd = p->subs[index].dfd;
         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);
                p->dtmfrelax = 0;
                if (*cp) p->dtmfrelax = DSP_DIGITMODE_RELAXDTMF;
                ast_dsp_digitmode(p->dsp, 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;
         dahdi_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].dfd, DAHDI_AUDIOMODE, &x) == -1)
         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n", p->channel, x, strerror(errno));
      break;
   case AST_OPTION_OPRMODE:  /* Operator services mode */
      oprmode = (struct oprmode *) data;
      pp = oprmode->peer->tech_pvt;
      p->oprmode = pp->oprmode = 0;
      /* setup peers */
      p->oprpeer = pp;
      pp->oprpeer = p;
      /* setup modes, if any */
      if (oprmode->mode) 
      {
         pp->oprmode = oprmode->mode;
         p->oprmode = -oprmode->mode;
      }
      ast_log(LOG_DEBUG, "Set Operator Services mode, value: %d on %s/%s\n",
         oprmode->mode, chan->name,oprmode->peer->name);;
      break;
   case AST_OPTION_ECHOCAN:
      cp = (char *) data;
      if (*cp) {
         ast_log(LOG_DEBUG, "Enabling echo cancellation on %s\n", chan->name);
         dahdi_enable_ec(p);
      } else {
         ast_log(LOG_DEBUG, "Disabling echo cancellation on %s\n", chan->name);
         dahdi_disable_ec(p);
      }
      break;
   }
   errno = 0;

   return 0;
}

static int dahdi_func_read(struct ast_channel *chan, char *function, char *data, char *buf, size_t len)
{
   struct dahdi_pvt *p = chan->tech_pvt;
   int res = 0;
   
   if (!strcasecmp(data, "rxgain")) {
      ast_mutex_lock(&p->lock);
      snprintf(buf, len, "%f", p->rxgain);
      ast_mutex_unlock(&p->lock);   
   } else if (!strcasecmp(data, "txgain")) {
      ast_mutex_lock(&p->lock);
      snprintf(buf, len, "%f", p->txgain);
      ast_mutex_unlock(&p->lock);   
   } else {
      ast_copy_string(buf, "", len);
      res = -1;
   }

   return res;
}


static int parse_buffers_policy(const char *parse, int *num_buffers, int *policy)
{
   int res;
   char policy_str[21] = "";
   
   if (((res = sscanf(parse, "%d,%20s", num_buffers, policy_str)) != 2) &&
      ((res = sscanf(parse, "%d|%20s", num_buffers, policy_str)) != 2)) {
      ast_log(LOG_WARNING, "Parsing buffer string '%s' failed.\n", parse);
      return 1;
   }
   if (*num_buffers < 0) {
      ast_log(LOG_WARNING, "Invalid buffer count given '%d'.\n", *num_buffers);
      return -1;
   }
   if (!strcasecmp(policy_str, "full")) {
      *policy = DAHDI_POLICY_WHEN_FULL;
   } else if (!strcasecmp(policy_str, "immediate")) {
      *policy = DAHDI_POLICY_IMMEDIATE;
#ifdef DAHDI_POLICY_HALF_FULL
   } else if (!strcasecmp(policy_str, "half")) {
      *policy = DAHDI_POLICY_HALF_FULL;
#endif
   } else {
      ast_log(LOG_WARNING, "Invalid policy name given '%s'.\n", policy_str);
      return -1;
   }

   return 0;
}

static int dahdi_func_write(struct ast_channel *chan, char *function, char *data, const char *value)
{
   struct dahdi_pvt *p = chan->tech_pvt;
   int res = 0;

   if (!strcasecmp(data, "buffers")) {
      int num_bufs, policy;

      if (!(parse_buffers_policy(value, &num_bufs, &policy))) {
         struct dahdi_bufferinfo bi = {
            .txbufpolicy = policy,
            .rxbufpolicy = policy,
            .bufsize = p->bufsize,
            .numbufs = num_bufs,
         };
         int bpres;

         if ((bpres = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
            ast_log(LOG_WARNING, "Channel '%d' unable to override buffer policy: %s\n", p->channel, strerror(errno));
         } else {
            p->bufferoverrideinuse = 1;
         }
      } else {
         res = -1;
      }
   } else {
      res = -1;
   }

   return res;
}

static void dahdi_unlink(struct dahdi_pvt *slave, struct dahdi_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)) {
            DEADLOCK_AVOIDANCE(&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 dahdi_link(struct dahdi_pvt *slave, struct dahdi_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 dahdi_pvt *p)
{
#ifdef DAHDI_TONEDETECT
   int val;
#endif

   p->ignoredtmf = 1;

#ifdef DAHDI_TONEDETECT
   val = 0;
   ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 dahdi_pvt *p)
{
#ifdef DAHDI_TONEDETECT
   int val;
#endif

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

   p->ignoredtmf = 0;

#ifdef DAHDI_TONEDETECT
   val = DAHDI_TONEDETECT_ON | DAHDI_TONEDETECT_MUTE;
   ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 dahdi_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 dahdi_pvt *p0, *p1, *op0, *op1;
   struct dahdi_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;
#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);
   while (ast_mutex_trylock(&c1->lock)) {
      DEADLOCK_AVOIDANCE(&c0->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 = dahdi_get_index(c0, p0, 0);
   oi1 = dahdi_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 ((p0->callwaiting && p0->callwaitingcallerid)
      || (p1->callwaiting && p1->callwaitingcallerid)) {
      /*
       * Call Waiting Caller ID requires DTMF detection to know if it
       * can send the CID spill.
       *
       * 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...
       */
      ast_mutex_unlock(&p0->lock);
      ast_mutex_unlock(&p1->lock);
      ast_mutex_unlock(&c0->lock);
      ast_mutex_unlock(&c1->lock);
      return AST_BRIDGE_FAILED_NOWARN;
   }

   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].dfd > -1) ? 1 : 0,
               p0->subs[SUB_REAL].inthreeway, p0->channel,
               oi0, (p1->subs[SUB_CALLWAIT].dfd > -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 %d/%d(%s) since %d/%d(%s) is in a ringing three-way\n",
            p0->channel, oi0, c0->name, p1->channel, oi1, c1->name);
         tone_zone_play_tone(p0->subs[oi0].dfd, DAHDI_TONE_RINGTONE);
         os1 = p1->subs[SUB_REAL].owner->_state;
      } else {
         ast_log(LOG_DEBUG, "Stopping tones on %d/%d(%s) talking to %d/%d(%s)\n",
            p0->channel, oi0, c0->name, p1->channel, oi1, c1->name);
         tone_zone_play_tone(p0->subs[oi0].dfd, -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 %d/%d(%s) since %d/%d(%s) is in a ringing three-way\n",
            p1->channel, oi1, c1->name, p0->channel, oi0, c0->name);
         tone_zone_play_tone(p1->subs[oi1].dfd, DAHDI_TONE_RINGTONE);
         os0 = p0->subs[SUB_REAL].owner->_state;
      } else {
         ast_log(LOG_DEBUG, "Stopping tones on %d/%d(%s) talking to %d/%d(%s)\n",
            p1->channel, oi1, c1->name, p0->channel, oi0, c0->name);
         tone_zone_play_tone(p1->subs[oi1].dfd, -1);
      }
      if ((oi0 == SUB_REAL) && (oi1 == SUB_REAL)) {
         if (!p0->echocanbridged || !p1->echocanbridged) {
            /* Disable echo cancellation if appropriate */
            dahdi_disable_ec(p0);
            dahdi_disable_ec(p1);
         }
      }
      dahdi_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) {
      dahdi_enable_ec(p0);
      dahdi_enable_ec(p1);
      return AST_BRIDGE_FAILED;
   }
   
   if (option_verbose > 2) 
      ast_verbose(VERBOSE_PREFIX_3 "Native bridging %s and %s\n", c0->name, c1->name);

   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);
      while (ast_mutex_trylock(&c1->lock)) {
         DEADLOCK_AVOIDANCE(&c0->lock);
      }

      p0 = c0->tech_pvt;
      p1 = c1->tech_pvt;

      if (op0 == p0)
         i0 = dahdi_get_index(c0, p0, 1);
      if (op1 == p1)
         i1 = dahdi_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
      if (!triedtopribridge) {
         triedtopribridge = 1;
         if (p0->pri && p0->pri == p1->pri && p0->transfer && p1->transfer) {
            ast_mutex_lock(&p0->pri->lock);
            if (p0->call && p1->call) {
               pri_channel_bridge(p0->call, p1->call);
            }
            ast_mutex_unlock(&p0->pri->lock);
         }
      }
#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)
      dahdi_enable_ec(p0);

   if (op1 == p1)
      dahdi_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);

   dahdi_unlink(slave, master, 1);

   return res;
}

static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
{
   struct dahdi_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)
            dahdi_unlink(NULL, p, 0);
         p->subs[x].owner = newchan;
      }
   update_conf(p);
   ast_mutex_unlock(&p->lock);
   if (newchan->_state == AST_STATE_RINGING) 
      dahdi_indicate(newchan, AST_CONTROL_RINGING, NULL, 0);
   return 0;
}

static int dahdi_ring_phone(struct dahdi_pvt *p)
{
   int x;
   int res;
   /* Make sure our transmit state is on hook */
   x = 0;
   x = DAHDI_ONHOOK;
   res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
   do {
      x = DAHDI_RING;
      res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_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 *dahdi_new(struct dahdi_pvt *, int, int, int, int, int);

/*!
 * \internal
 * \brief Attempt to transfer 3-way call.
 *
 * \param p private structure.
 *
 * \note
 * On entry these locks are held: real-call, private, 3-way call.
 *
 * \retval 1 Transfer successful.  3-way call is unlocked and subchannel is unalloced.
 *         Swapped real and 3-way subchannel.
 * \retval 0 Transfer successful.  3-way call is unlocked and subchannel is unalloced.
 * \retval -1 on error.  Caller must unlock 3-way call.
 */
static int attempt_transfer(struct dahdi_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 it now if appropriate */
      if (ast_bridged_channel(p->subs[SUB_THREEWAY].owner))
         ast_queue_control(p->subs[SUB_THREEWAY].owner, AST_CONTROL_UNHOLD);
      if (p->subs[SUB_REAL].owner->_state == AST_STATE_RINGING) {
         /*
          * This may not be safe.
          * We currently hold the locks on the real-call, private, and 3-way call.
          * We could possibly avoid this here by using an ast_queue_control() instead.
          * However, the following ast_channel_masquerade() is going to be locking
          * the bridged channel again anyway.
          */
         ast_indicate(ast_bridged_channel(p->subs[SUB_REAL].owner), AST_CONTROL_RINGING);
      }
      if (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_RING) {
         tone_zone_play_tone(p->subs[SUB_THREEWAY].dfd, DAHDI_TONE_RINGTONE);
      }
       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)) {
      ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD);
      if (p->subs[SUB_THREEWAY].owner->_state == AST_STATE_RINGING) {
         /*
          * This may not be safe.
          * We currently hold the locks on the real-call, private, and 3-way call.
          * We could possibly avoid this here by using an ast_queue_control() instead.
          * However, the following ast_channel_masquerade() is going to be locking
          * the bridged channel again anyway.
          */
         ast_indicate(ast_bridged_channel(p->subs[SUB_THREEWAY].owner), AST_CONTROL_RINGING);
      }
      if (p->subs[SUB_REAL].owner->_state == AST_STATE_RING) {
         tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE);
      }
      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);
      return -1;
   }
   return 0;
}

static int check_for_conference(struct dahdi_pvt *p)
{
   struct dahdi_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].dfd, DAHDI_GETCONF, &ci)) {
      ast_log(LOG_WARNING, "Failed to get conference info on channel %d: %s\n", p->channel, strerror(errno));
      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 dahdi_pvt *p)
{
   int res;
   struct dahdi_spaninfo zi;
#if !defined(HAVE_ZAPTEL) || defined(HAVE_ZAPTEL_CHANALARMS)
   /*
    * The conditional compilation is needed only in asterisk-1.4 for
    * backward compatibility with old zaptel drivers that don't have
    * a DAHDI_PARAMS.chan_alarms field.
    */
   struct dahdi_params params;
#endif

   memset(&zi, 0, sizeof(zi));
   zi.spanno = p->span;

   /* First check for span alarms */
   if((res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SPANSTAT, &zi)) < 0) {
      ast_log(LOG_WARNING, "Unable to determine alarm on channel %d: %s\n", p->channel, strerror(errno));
      return 0;
   }
   if (zi.alarms != DAHDI_ALARM_NONE)
      return zi.alarms;
#if !defined(HAVE_ZAPTEL) || defined(HAVE_ZAPTEL_CHANALARMS)
   /* No alarms on the span. Check for channel alarms. */
   memset(&params, 0, sizeof(params));
   if ((res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &params)) >= 0)
      return params.chan_alarms;
   /* ioctl failed */
   ast_log(LOG_WARNING, "Unable to determine alarm on channel %d\n", p->channel);
#endif
   return DAHDI_ALARM_NONE;
}

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

   if (option_debug)
      ast_log(LOG_DEBUG, "%s DTMF digit: 0x%02X '%c' on %s\n",
         f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
         f->subclass, f->subclass, ast->name);

   if (p->confirmanswer) {
      if (f->frametype == AST_FRAME_DTMF_END) {
         if (option_debug)
            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;
         /* Reset confirmanswer so DTMF's will behave properly for the duration of the call */
         p->confirmanswer = 0;
      } else {
         p->subs[index].f.frametype = AST_FRAME_NULL;
         p->subs[index].f.subclass = 0;
      }
      *dest = &p->subs[index].f;
   } else if (p->callwaitcas) {
      if (f->frametype == AST_FRAME_DTMF_END) {
         if ((f->subclass == 'A') || (f->subclass == 'D')) {
            if (option_debug)
               ast_log(LOG_DEBUG, "Got some DTMF, but it's for the CAS\n");
            free(p->cidspill);
            p->cidspill = NULL;
            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') {
      if (f->frametype == AST_FRAME_DTMF_END) {
         /* Fax tone -- Handle and return NULL */
         if ((p->callprogress & 0x6) && !p->faxhandled) {
            p->faxhandled = 1;
            if (strcmp(ast->exten, "fax")) {
               const char *target_context = S_OR(ast->macrocontext, ast->context);

               /* We need to unlock 'ast' here because ast_exists_extension has the
                * potential to start autoservice on the channel. Such action is prone
                * to deadlock.
                */
               ast_mutex_unlock(&p->lock);
               ast_channel_unlock(ast);
               if (ast_exists_extension(ast, target_context, "fax", 1, ast->cid.cid_num)) {
                  ast_channel_lock(ast);
                  ast_mutex_lock(&p->lock);
                  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_channel_lock(ast);
                  ast_mutex_lock(&p->lock);
                  ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
               }
            } else if (option_debug)
               ast_log(LOG_DEBUG, "Already in a fax extension, not redirecting\n");
         } else if (option_debug)
            ast_log(LOG_DEBUG, "Fax already handled\n");
         dahdi_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') {
      if (f->frametype == AST_FRAME_DTMF_END) {
         /* Confmute request */
         dahdi_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') {
      if (f->frametype == AST_FRAME_DTMF_END) {
         /* Unmute */
         dahdi_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->frametype == AST_FRAME_DTMF_END) {
         dahdi_confmute(p, 0);
      }
   }
}
         
static void handle_alarms(struct dahdi_pvt *p, int alarms)
{
   const char *alarm_str = alarm2str(alarms);
   
   /* hack alert! Zaptel 1.4 and DAHDI expose FXO battery as an alarm, but this code
    * doesn't know what to do with it.  Don't confuse users with log messages. */
   if (!strcasecmp(alarm_str, "No Alarm") || !strcasecmp(alarm_str, "Unknown Alarm")) {
      p->unknown_alarm = 1;
      return;
   } else {
      p->unknown_alarm = 0;
   }
   
   ast_log(LOG_WARNING, "Detected alarm on channel %d: %s\n", p->channel, alarm_str);
   manager_event(EVENT_FLAG_SYSTEM, "Alarm",
            "Alarm: %s\r\n"
            "Channel: %d\r\n",
            alarm_str, p->channel);
}

static struct ast_frame *dahdi_handle_event(struct ast_channel *ast)
{
   int res, x;
   int index, mysig;
   char *c;
   struct dahdi_pvt *p = ast->tech_pvt;
   pthread_t threadid;
   pthread_attr_t attr;
   struct ast_channel *chan;
   struct ast_frame *f;

   index = dahdi_get_index(ast, p, 0);
   if (index < 0) {
      return &ast_null_frame;
   }
   if (index != SUB_REAL) {
      ast_log(LOG_ERROR, "We got an event on a non real sub.  Fix it!\n");
   }

   mysig = p->sig;
   if (p->outsigmod > -1)
      mysig = p->outsigmod;

   p->subs[index].f.frametype = AST_FRAME_NULL;
   p->subs[index].f.subclass = 0;
   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 = "dahdi_handle_event";
   p->subs[index].f.data = NULL;
   f = &p->subs[index].f;

   if (p->fake_event) {
      res = p->fake_event;
      p->fake_event = 0;
   } else
      res = dahdi_get_event(p->subs[index].dfd);

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

   if (res & (DAHDI_EVENT_PULSEDIGIT | DAHDI_EVENT_DTMFUP)) {
      p->pulsedial =  (res & DAHDI_EVENT_PULSEDIGIT) ? 1 : 0;

      ast_log(LOG_DEBUG, "Detected %sdigit '%c'\n", p->pulsedial ? "pulse ": "", res & 0xff);
#ifdef HAVE_PRI
      if (p->sig == SIG_PRI
         && p->call_level < DAHDI_CALL_LEVEL_PROCEEDING
         && p->pri
         && (p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)) {
         /* absorb event */
      } else
#endif
      {
         p->subs[index].f.frametype = AST_FRAME_DTMF_END;
         p->subs[index].f.subclass = res & 0xff;
         dahdi_handle_dtmf(ast, index, &f);
      }
      return f;
   }

   if (res & DAHDI_EVENT_DTMFDOWN) {
      if (option_debug)
         ast_log(LOG_DEBUG, "DTMF Down '%c'\n", res & 0xff);
#ifdef HAVE_PRI
      if (p->sig == SIG_PRI
         && p->call_level < DAHDI_CALL_LEVEL_PROCEEDING
         && p->pri
         && (p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)) {
         /* absorb event */
      } else
#endif
      {
         /* Mute conference */
         dahdi_confmute(p, 1);
         p->subs[index].f.frametype = AST_FRAME_DTMF_BEGIN;
         p->subs[index].f.subclass = res & 0xff;
         dahdi_handle_dtmf(ast, index, &f);
      }
      return &p->subs[index].f;
   }

   switch (res) {
#ifdef DAHDI_EVENT_EC_DISABLED
      case DAHDI_EVENT_EC_DISABLED:
         if (option_verbose > 2) 
            ast_verbose(VERBOSE_PREFIX_3 "Channel %d echo canceler disabled due to CED detection\n", p->channel);
         p->echocanon = 0;
         break;
#endif
      case DAHDI_EVENT_BITSCHANGED:
         ast_log(LOG_WARNING, "Received bits changed on %s signalling?\n", sig2str(p->sig));
      case DAHDI_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].dfd, -1);
         break;   
      case DAHDI_EVENT_DIALCOMPLETE:
         if (p->inalarm) break;
         if ((p->radio || (p->oprmode < 0))) break;
         if (ioctl(p->subs[index].dfd,DAHDI_DIALING,&x) == -1) {
            ast_log(LOG_DEBUG, "DAHDI_DIALING ioctl failed on %s: %s\n",ast->name, strerror(errno));
            return NULL;
         }
         if (!x) { /* if not still dialing in driver */
            dahdi_enable_ec(p);
            if (p->echobreak) {
               dahdi_train_ec(p);
               ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr));
               p->dop.op = DAHDI_DIAL_OP_REPLACE;
               res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop);
               p->echobreak = 0;
            } else {
               p->dialing = 0;
               if ((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) {
                  /* 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 && ((mysig == SIG_EM) || (mysig == SIG_EM_E1) ||  (mysig == SIG_EMWINK) || (mysig == SIG_FEATD) || (mysig == SIG_FEATDMF_TA) || (mysig == SIG_FEATDMF) || (mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF) || (mysig == SIG_FEATB) || (mysig == SIG_SF) || (mysig == SIG_SFWINK) || (mysig == SIG_SF_FEATD) || (mysig == SIG_SF_FEATDMF) || (mysig == 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;
                     /* If aops=0 and hops=1, this is necessary */
                     p->polarity = POLARITY_REV;
                  } else {
                     /* Start clean, so we can catch the change to REV polarity when party answers */
                     p->polarity = POLARITY_IDLE;
                  }
               }
            }
         }
         break;
      case DAHDI_EVENT_ALARM:
#ifdef HAVE_PRI
         if (!p->pri || !p->pri->pri || (pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0)) {
            /* T309 is not enabled : destroy calls when alarm occurs */
            if (p->call) {
               if (p->pri && p->pri->pri) {
                  pri_grab(p, p->pri);
                  pri_destroycall(p->pri->pri, p->call);
                  p->call = NULL;
                  pri_rel(p->pri);
               } else
                  ast_log(LOG_WARNING, "The PRI Call has not been destroyed\n");
            }
            if (p->owner)
               p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
         }
         if (p->bearer) {
            p->bearer->inalarm = 1;
            p->bearer->resetting = 0;
         } else
#endif
         {
            p->inalarm = 1;
#if defined(HAVE_PRI)
            p->resetting = 0;
#endif   /* defined(HAVE_PRI) */
         }
         res = get_alarms(p);
         handle_alarms(p, res);
#ifdef HAVE_PRI
         if (!p->pri || !p->pri->pri || pri_get_timer(p->pri->pri, PRI_TIMER_T309) < 0) {
            /* fall through intentionally */
         } else {
            break;
         }
#endif
      case DAHDI_EVENT_ONHOOK:
         if (p->radio) {
            p->subs[index].f.frametype = AST_FRAME_CONTROL;
            p->subs[index].f.subclass = AST_CONTROL_RADIO_UNKEY;
            break;
         }
         if (p->oprmode < 0)
         {
            if (p->oprmode != -1) break;
            if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS))
            {
               /* Make sure it starts ringing */
               dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF);
               dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RING);
               save_conference(p->oprpeer);
               tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE);
            }
            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) {
                  /* Need to hold the lock for real-call, private, and call-waiting call */
                  dahdi_lock_sub_owner(p, SUB_CALLWAIT);
                  if (!p->subs[SUB_CALLWAIT].owner) {
                     /*
                      * The call waiting call dissappeared.
                      * This is now a normal hangup.
                      */
                     dahdi_disable_ec(p);
                     return NULL;
                  }

                  /* 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->cid_suppress_expire = 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;
                  /* Unlock the call-waiting call that we swapped to real-call. */
                  ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
                  dahdi_ring_phone(p);
               } else if (p->subs[SUB_THREEWAY].owner) {
                  unsigned int mssinceflash;

                  /* Need to hold the lock for real-call, private, and 3-way call */
                  dahdi_lock_sub_owner(p, SUB_THREEWAY);
                  if (!p->subs[SUB_THREEWAY].owner) {
                     ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n");
                     /* Just hangup */
                     return NULL;
                  }
                  if (p->owner != ast) {
                     ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                     ast_log(LOG_WARNING, "This isn't good...\n");
                     /* Just hangup */
                     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 */
                     ast_log(LOG_DEBUG, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
                     ast_queue_hangup(p->subs[SUB_THREEWAY].owner);
                     p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                     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) {
                           /* Swap subs and dis-own channel */
                           swap_subs(p, SUB_THREEWAY, SUB_REAL);
                           /* Unlock the 3-way call that we swapped to real-call. */
                           ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
                           p->owner = NULL;
                           /* Ring the phone */
                           dahdi_ring_phone(p);
                        } else {
                           res = attempt_transfer(p);
                           if (res < 0) {
                              /* Transfer attempt failed. */
                              p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                              ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                           } else if (res) {
                              /* Don't actually hang up at this point */
                              break;
                           }
                        }
                     } else {
                        p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                        ast_mutex_unlock(&p->subs[SUB_THREEWAY].owner->lock);
                     }
                  } else {
                     /* Swap subs and dis-own channel */
                     swap_subs(p, SUB_THREEWAY, SUB_REAL);
                     /* Unlock the 3-way call that we swapped to real-call. */
                     ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
                     p->owner = NULL;
                     /* Ring the phone */
                     dahdi_ring_phone(p);
                  }
               }
            } else {
               ast_log(LOG_WARNING, "Got a hangup and my index is %d?\n", index);
            }
            /* Fall through */
         default:
            dahdi_disable_ec(p);
            return NULL;
         }
         break;
      case DAHDI_EVENT_RINGOFFHOOK:
         if (p->inalarm) break;
         if (p->oprmode < 0)
         {
            if ((p->sig == SIG_FXOLS) || (p->sig == SIG_FXOKS) || (p->sig == SIG_FXOGS))
            {
               /* Make sure it stops ringing */
               dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_RINGOFF);
               tone_zone_play_tone(p->oprpeer->subs[SUB_REAL].dfd, -1);
               restore_conference(p->oprpeer);
            }
            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 (((mysig == SIG_E911) || (mysig == SIG_FGC_CAMA) || (mysig == SIG_FGC_CAMAMF)) && (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].dfd, DAHDI_DIAL, &p->dop)) {
               int saveerr = errno;

               x = DAHDI_ONHOOK;
               ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
               ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(saveerr));
               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:
               dahdi_enable_ec(p);
               dahdi_train_ec(p);
               p->subs[index].f.frametype = AST_FRAME_CONTROL;
               p->subs[index].f.subclass = AST_CONTROL_ANSWER;
               /* Make sure it stops ringing */
               dahdi_set_hook(p->subs[index].dfd, DAHDI_OFFHOOK);
               p->subs[SUB_REAL].needringing = 0;
               ast_log(LOG_DEBUG, "channel %d answered\n", p->channel);

               /* Cancel any running CallerID spill */
               free(p->cidspill);
               p->cidspill = NULL;
               restore_conference(p);

               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].dfd, DAHDI_DIAL, &p->dop);
                  if (res < 0) {
                     ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno));
                     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 */
               dahdi_set_hook(p->subs[index].dfd, DAHDI_OFFHOOK);
               /* Okay -- probably call waiting*/
               if (ast_bridged_channel(p->owner))
                  ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
               p->subs[index].needunhold = 1;
               break;
            case AST_STATE_RESERVED:
               /* Start up dialtone */
               if (has_voicemail(p))
                  res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_STUTTER);
               else
                  res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_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;
            }

            /* 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_FGC_CAMA:
         case SIG_FGC_CAMAMF:
         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 DAHDI_EVENT_RINGBEGIN
      case DAHDI_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 DAHDI_EVENT_RINGEROFF:
         if (p->inalarm) break;
         if ((p->radio || (p->oprmode < 0))) 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 DAHDI_EVENT_RINGERON:
         break;
      case DAHDI_EVENT_NOALARM:
         p->inalarm = 0;
#ifdef HAVE_PRI
         p->resetting = 0;
         /* Extremely unlikely but just in case */
         if (p->bearer) {
            p->bearer->inalarm = 0;
            p->bearer->resetting = 0;
         }
#endif            
         if (!p->unknown_alarm) {
            ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel);
            manager_event(EVENT_FLAG_SYSTEM, "AlarmClear",
               "Channel: %d\r\n", p->channel);
         } else {
            p->unknown_alarm = 0;
         }
         break;
      case DAHDI_EVENT_WINKFLASH:
         if (p->inalarm) break;
         if (p->radio) break;
         if (p->oprmode < 0) break;
         if (p->oprmode > 1)
         {
            struct dahdi_params par;

            memset(&par, 0, sizeof(par));
            if (ioctl(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par) != -1)
            {
               if (!par.rxisoffhook)
               {
                  /* Make sure it stops ringing */
                  dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RINGOFF);
                  dahdi_set_hook(p->oprpeer->subs[SUB_REAL].dfd, DAHDI_RING);
                  save_conference(p);
                  tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_TONE_RINGTONE);
               }
            }
            break;
         }
         /* Remember last time we got a flash-hook */
         gettimeofday(&p->flashtime, NULL);
         switch (mysig) {
         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].dfd, p->subs[SUB_CALLWAIT].dfd, p->subs[SUB_THREEWAY].dfd);

            /* Cancel any running CallerID spill */
            free(p->cidspill);
            p->cidspill = NULL;
            restore_conference(p);
            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) {
               /* Need to hold the lock for real-call, private, and call-waiting call */
               dahdi_lock_sub_owner(p, SUB_CALLWAIT);
               if (!p->subs[SUB_CALLWAIT].owner) {
                  /*
                   * The call waiting call dissappeared.
                   * Let's just ignore this flash-hook.
                   */
                  ast_log(LOG_NOTICE, "Whoa, the call-waiting call disappeared.\n");
                  goto winkflashdone;
               }

               /* Swap to call-wait */
               swap_subs(p, SUB_REAL, SUB_CALLWAIT);
               tone_zone_play_tone(p->subs[SUB_REAL].dfd, -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;
               p->cid_suppress_expire = 0;

               /* Start music on hold if appropriate */
               if (!p->subs[SUB_CALLWAIT].inthreeway && ast_bridged_channel(p->subs[SUB_CALLWAIT].owner)) {
                  ast_queue_control_data(p->subs[SUB_CALLWAIT].owner, AST_CONTROL_HOLD,
                     S_OR(p->mohsuggest, NULL),
                     !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
               }
               p->subs[SUB_CALLWAIT].needhold = 1;
               if (ast_bridged_channel(p->subs[SUB_REAL].owner)) {
                  ast_queue_control_data(p->subs[SUB_REAL].owner, AST_CONTROL_HOLD,
                     S_OR(p->mohsuggest, NULL),
                     !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
               }
               p->subs[SUB_REAL].needunhold = 1;

               /* Unlock the call-waiting call that we swapped to real-call. */
               ast_mutex_unlock(&p->subs[SUB_REAL].owner->lock);
            } else if (!p->subs[SUB_THREEWAY].owner) {
               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)) {
                  char cid_num[256];
                  char cid_name[256];

                  cid_num[0] = 0;
                  cid_name[0] = 0;
                  if (p->dahditrcallerid && 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 = dahdi_new(p, AST_STATE_RESERVED, 0, SUB_THREEWAY, 0, 0);
                  if (!chan) {
                     ast_log(LOG_WARNING,
                        "Cannot allocate new call structure on channel %d\n",
                        p->channel);
                     unalloc_sub(p, SUB_THREEWAY);
                     goto winkflashdone;
                  }
                  if (p->dahditrcallerid) {
                     if (!p->origcid_num)
                        p->origcid_num = ast_strdup(p->cid_num);
                     if (!p->origcid_name)
                        p->origcid_name = ast_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 */
                  dahdi_disable_ec(p);
                  res = tone_zone_play_tone(p->subs[SUB_REAL].dfd, DAHDI_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 (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].dfd, DAHDI_TONE_CONGESTION);
                     dahdi_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_queue_control_data(p->subs[SUB_THREEWAY].owner, AST_CONTROL_HOLD,
                           S_OR(p->mohsuggest, NULL),
                           !ast_strlen_zero(p->mohsuggest) ? strlen(p->mohsuggest) + 1 : 0);
                     }
                     p->subs[SUB_THREEWAY].needhold = 1;
                  }
                  pthread_attr_destroy(&attr);
               }
            } else {
               /* Already have a 3 way call */
               int orig_3way_sub;

               /* Need to hold the lock for real-call, private, and 3-way call */
               dahdi_lock_sub_owner(p, SUB_THREEWAY);
               if (!p->subs[SUB_THREEWAY].owner) {
                  /*
                   * The 3-way call dissappeared.
                   * Let's just ignore this flash-hook.
                   */
                  ast_log(LOG_NOTICE, "Whoa, the 3-way call disappeared.\n");
                  goto winkflashdone;
               }
               orig_3way_sub = SUB_THREEWAY;

               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);
                     orig_3way_sub = 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))) {
                     if (option_verbose > 2) {
                        ast_verbose(VERBOSE_PREFIX_3 "Building conference call with %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);
                        orig_3way_sub = SUB_REAL;
                     }
                     if (ast_bridged_channel(p->subs[orig_3way_sub].owner)) {
                        ast_queue_control(p->subs[orig_3way_sub].owner, AST_CONTROL_UNHOLD);
                     }
                     p->subs[orig_3way_sub].needunhold = 1;
                     p->owner = p->subs[SUB_REAL].owner;
                  } else {
                     if (option_verbose > 2)
                        ast_verbose(VERBOSE_PREFIX_3 "Dumping incomplete call on %s\n", p->subs[SUB_THREEWAY].owner->name);
                     swap_subs(p, SUB_THREEWAY, SUB_REAL);
                     orig_3way_sub = SUB_REAL;
                     p->subs[SUB_THREEWAY].owner->_softhangup |= AST_SOFTHANGUP_DEV;
                     p->owner = p->subs[SUB_REAL].owner;
                     if (ast_bridged_channel(p->subs[SUB_REAL].owner)) {
                        ast_queue_control(p->subs[SUB_REAL].owner, AST_CONTROL_UNHOLD);
                     }
                     p->subs[SUB_REAL].needunhold = 1;
                     dahdi_enable_ec(p);
                  }
                     
               }
               ast_mutex_unlock(&p->subs[orig_3way_sub].owner->lock);
            }
winkflashdone:
            update_conf(p);
            break;
         case SIG_EM:
         case SIG_EM_E1:
         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_FGC_CAMAMF:
         case SIG_FGC_CAMA:
         case SIG_FEATB:
         case SIG_SF_FEATDMF:
         case SIG_SF_FEATB:
         case SIG_EMWINK:
            /* FGD MF and EMWINK *Must* wait for wink */
            if (!ast_strlen_zero(p->dop.dialstr)) {
               res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_DIAL, &p->dop);
               if (res < 0) {
                  ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno));
                  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 DAHDI_EVENT_HOOKCOMPLETE:
         if (p->inalarm) break;
         if ((p->radio || (p->oprmode < 0))) break;
         switch (mysig) {
         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].dfd, DAHDI_DIAL, &p->dop);
               if (res < 0) {
                  ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d: %s\n", p->channel, strerror(errno));
                  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 = DAHDI_DIAL_OP_REPLACE;
            break;
         case SIG_FEATDMF:
         case SIG_FEATDMF_TA:
         case SIG_E911:
         case SIG_FGC_CAMA:
         case SIG_FGC_CAMAMF:
         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 DAHDI_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);
               }
            } 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 *__dahdi_exception(struct ast_channel *ast)
{
   struct dahdi_pvt *p = ast->tech_pvt;
   int res;
   int index;
   struct ast_frame *f;


   index = dahdi_get_index(ast, p, 1);
   if (index < 0) {
      index = SUB_REAL;
   }
   
   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 = "dahdi_exception";
   p->subs[index].f.data = NULL;
   
   if ((!p->owner) && (!(p->radio || (p->oprmode < 0)))) {
      /* 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 = dahdi_get_event(p->subs[SUB_REAL].dfd);
      /* Switch to real if there is one and this isn't something really silly... */
      if ((res != DAHDI_EVENT_RINGEROFF) && (res != DAHDI_EVENT_RINGERON) &&
         (res != DAHDI_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 != p->owner) {
            /*
             * Could this even happen?
             * Possible deadlock because we do not have the real-call lock.
             */
            ast_log(LOG_WARNING, "Event %s on %s is not restored owner %s\n",
               event2str(res), ast->name, p->owner->name);
         }
         if (p->owner && ast_bridged_channel(p->owner))
            ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
         p->subs[SUB_REAL].needunhold = 1;
      }
      switch (res) {
      case DAHDI_EVENT_ONHOOK:
         dahdi_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);
            dahdi_ring_phone(p);
            p->callwaitingrepeat = 0;
            p->cidcwexpire = 0;
            p->cid_suppress_expire = 0;
         } else {
            ast_log(LOG_WARNING, "Absorbed %s, but nobody is left!?!?\n",
               event2str(res));
         }
         update_conf(p);
         break;
      case DAHDI_EVENT_RINGOFFHOOK:
         dahdi_enable_ec(p);
         dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
         if (p->owner && (p->owner->_state == AST_STATE_RINGING)) {
            p->subs[SUB_REAL].needanswer = 1;
            p->dialing = 0;
         }
         break;
      case DAHDI_EVENT_HOOKCOMPLETE:
      case DAHDI_EVENT_RINGERON:
      case DAHDI_EVENT_RINGEROFF:
         /* Do nothing */
         break;
      case DAHDI_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 */
               p->subs[SUB_REAL].needanswer = 1;
               ast_setstate(p->owner, AST_STATE_UP);
            }
            p->callwaitingrepeat = 0;
            p->cidcwexpire = 0;
            p->cid_suppress_expire = 0;
            if (ast_bridged_channel(p->owner))
               ast_queue_control(p->owner, AST_CONTROL_UNHOLD);
            p->subs[SUB_REAL].needunhold = 1;
         } else {
            ast_log(LOG_WARNING, "Absorbed %s, but nobody is left!?!?\n",
               event2str(res));
         }
         update_conf(p);
         break;
      default:
         ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", event2str(res));
         break;
      }
      f = &p->subs[index].f;
      return f;
   }
   if (!(p->radio || (p->oprmode < 0)) && option_debug) 
      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 = dahdi_handle_event(ast);
   return f;
}

static struct ast_frame *dahdi_exception(struct ast_channel *ast)
{
   struct dahdi_pvt *p = ast->tech_pvt;
   struct ast_frame *f;
   ast_mutex_lock(&p->lock);
   f = __dahdi_exception(ast);
   ast_mutex_unlock(&p->lock);
   return f;
}

static struct ast_frame  *dahdi_read(struct ast_channel *ast)
{
   struct dahdi_pvt *p;
   int res;
   int index;
   void *readbuf;
   struct ast_frame *f;

   /*
    * For analog channels, we must do deadlock avoidance because
    * analog ports can have more than one Asterisk channel using
    * the same private structure.
    */
   p = ast->tech_pvt;
   while (ast_mutex_trylock(&p->lock)) {
      DEADLOCK_AVOIDANCE(&ast->lock);

      /*
       * For PRI channels, we must refresh the private pointer because
       * the call could move to another B channel while the Asterisk
       * channel is unlocked.
       */
      p = ast->tech_pvt;
   }

   index = dahdi_get_index(ast, p, 0);
   
   /* Hang up if we don't really exist */
   if (index < 0) {
      ast_log(LOG_WARNING, "We don't exist?\n");
      ast_mutex_unlock(&p->lock);
      return NULL;
   }
   
   if ((p->radio || (p->oprmode < 0)) && p->inalarm) {
      ast_mutex_unlock(&p->lock);
      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 = "dahdi_read";
   p->subs[index].f.data = NULL;
   
   /* make sure it sends initial key state as first frame */
   if ((p->radio || (p->oprmode < 0)) && (!p->firstradio))
   {
      struct dahdi_params ps;

      memset(&ps, 0, sizeof(ps));
      ps.channo = p->channel;
      if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_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->cid.cid_tns) {
      ast_set_callerid(ast, S_OR(p->lastcid_num, NULL),
                     S_OR(p->lastcid_name, NULL),
                     S_OR(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 (p->subs[index].needhold) {
      /* Send answer frame if requested */
      p->subs[index].needhold = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_HOLD;
      ast_mutex_unlock(&p->lock);
      ast_log(LOG_DEBUG, "Sending hold on '%s'\n", ast->name);
      return &p->subs[index].f;
   }  
   
   if (p->subs[index].needunhold) {
      /* Send answer frame if requested */
      p->subs[index].needunhold = 0;
      p->subs[index].f.frametype = AST_FRAME_CONTROL;
      p->subs[index].f.subclass = AST_CONTROL_UNHOLD;
      ast_mutex_unlock(&p->lock);
      ast_log(LOG_DEBUG, "Sending unhold on '%s'\n", ast->name);
      return &p->subs[index].f;
   }  
   
   if (ast->rawreadformat == AST_FORMAT_SLINEAR) {
      if (!p->subs[index].linear) {
         p->subs[index].linear = 1;
         res = dahdi_setlinear(p->subs[index].dfd, 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 = dahdi_setlinear(p->subs[index].dfd, 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].dfd, 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 = __dahdi_exception(ast);
         } else
            ast_log(LOG_WARNING, "dahdi_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 = __dahdi_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 (index == SUB_REAL) {
      /* Ensure the CW timers decrement only on a single subchannel */
      if (p->cidcwexpire) {
         if (!--p->cidcwexpire) {
            /* Expired CID/CW */
            if (option_verbose > 2)
               ast_verbose(VERBOSE_PREFIX_3 "CPE does not support Call Waiting Caller*ID.\n");
            restore_conference(p);
         }
      }
      if (p->cid_suppress_expire) {
         --p->cid_suppress_expire;
      }
      if (p->callwaitingrepeat) {
         if (!--p->callwaitingrepeat) {
            /* Expired, Repeat callwaiting tone */
            ++p->callwaitrings;
            dahdi_callwait(ast);
         }
      }
   }
   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 / sizeof(p->subs[index].buffer[0]);
#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 dahdi 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_BEGIN
            || f->frametype == AST_FRAME_DTMF_END) {
#ifdef HAVE_PRI
            if (p->sig == SIG_PRI
               && p->call_level < DAHDI_CALL_LEVEL_PROCEEDING
               && p->pri
               && ((!p->outgoing && (p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING))
                  || (p->outgoing && (p->pri->overlapdial & DAHDI_OVERLAPDIAL_OUTGOING)))) {
               /* Don't accept in-band DTMF when in overlap dial mode */
               ast_log(LOG_DEBUG,
                  "Absorbing inband %s DTMF digit: 0x%02X '%c' on %s\n",
                  f->frametype == AST_FRAME_DTMF_BEGIN ? "begin" : "end",
                  f->subclass, f->subclass, ast->name);

               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) {
      switch (f->frametype) {
      case AST_FRAME_DTMF_BEGIN:
      case AST_FRAME_DTMF_END:
         dahdi_handle_dtmf(ast, index, &f);
         break;
      case AST_FRAME_VOICE:
         if (p->cidspill || p->cid_suppress_expire) {
            /* We are/were sending a caller id spill.  Suppress any echo. */
            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;
         }
         break;
      default:
         break;
      }
   }

   /* 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_dahdi_write(struct dahdi_pvt *p, unsigned char *buf, int len, int index, int linear)
{
   int sent=0;
   int size;
   int res;
   int fd;
   fd = p->subs[index].dfd;
   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 dahdi_write(struct ast_channel *ast, struct ast_frame *frame)
{
   struct dahdi_pvt *p = ast->tech_pvt;
   int res;
   int index;
   index = dahdi_get_index(ast, p, 0);
   if (index < 0) {
      ast_log(LOG_WARNING, "%s doesn't really exist?\n", ast->name);
      return -1;
   }

   /* 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 on %s...\n",
            ast->name);
      }
      return 0;
   }
   /* Return if it's not valid data */
   if (!frame->data || !frame->datalen)
      return 0;

   if (frame->subclass == AST_FORMAT_SLINEAR) {
      if (!p->subs[index].linear) {
         p->subs[index].linear = 1;
         res = dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
         if (res)
            ast_log(LOG_WARNING, "Unable to set linear mode on channel %d\n", p->channel);
      }
      res = my_dahdi_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 = dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
         if (res)
            ast_log(LOG_WARNING, "Unable to set companded mode on channel %d\n", p->channel);
      }
      res = my_dahdi_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 dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen)
{
   struct dahdi_pvt *p = chan->tech_pvt;
   int res=-1;
   int index;
   int func = DAHDI_FLASH;
   ast_mutex_lock(&p->lock);
   index = dahdi_get_index(chan, p, 0);
   if (option_debug)
      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 HAVE_PRI
         if (p->sig == SIG_PRI) {
            if (p->priindication_oob) {
               chan->hangupcause = AST_CAUSE_USER_BUSY;
               chan->_softhangup |= AST_SOFTHANGUP_DEV;
               res = 0;
               break;
            }
            res = tone_zone_play_tone(p->subs[index].dfd, DAHDI_TONE_BUSY);
            if (p->call_level < DAHDI_CALL_LEVEL_ALERTING && !p->outgoing) {
               chan->hangupcause = AST_CAUSE_USER_BUSY;
               p->progress = 1;/* No need to send plain PROGRESS after this. */
               if (p->pri && 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);
                  }
               }
            }
            break;
         }
#endif
         res = tone_zone_play_tone(p->subs[index].dfd, DAHDI_TONE_BUSY);
         break;
      case AST_CONTROL_RINGING:
#ifdef HAVE_PRI
         if (p->sig == SIG_PRI
            && p->call_level < DAHDI_CALL_LEVEL_ALERTING && !p->outgoing) {
            p->call_level = DAHDI_CALL_LEVEL_ALERTING;
            if (p->pri && 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);
               }
            }
         }
#endif
         res = tone_zone_play_tone(p->subs[index].dfd, DAHDI_TONE_RINGTONE);
         if (chan->_state != AST_STATE_UP) {
            if ((chan->_state != AST_STATE_RING) ||
               ((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 HAVE_PRI
         if (p->sig == SIG_PRI
            && p->call_level < DAHDI_CALL_LEVEL_PROCEEDING && !p->outgoing) {
            p->call_level = DAHDI_CALL_LEVEL_PROCEEDING;
            if (p->pri && 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->dialing = 0;
         }
#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 HAVE_PRI
         p->digital = 0;   /* Digital-only calls isn't allows any inband progress messages */
         if (p->sig == SIG_PRI
            && !p->progress && p->call_level < DAHDI_CALL_LEVEL_ALERTING
            && !p->outgoing) {
            p->progress = 1;/* No need to send plain PROGRESS again. */
            if (p->pri && 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);
               }
            }
         }
#endif
         /* don't continue in ast_indicate */
         res = 0;
         break;
      case AST_CONTROL_CONGESTION:
#ifdef HAVE_PRI
         if (p->sig == SIG_PRI) {
            if (p->priindication_oob) {
               /* There are many cause codes that generate an AST_CONTROL_CONGESTION. */
               switch (chan->hangupcause) {
               case AST_CAUSE_USER_BUSY:
               case AST_CAUSE_NORMAL_CLEARING:
               case 0:/* Cause has not been set. */
                  /* Supply a more appropriate cause. */
                  chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
                  break;
               default:
                  break;
               }
               chan->_softhangup |= AST_SOFTHANGUP_DEV;
               res = 0;
               break;
            }
            res = tone_zone_play_tone(p->subs[index].dfd, DAHDI_TONE_CONGESTION);
            if (p->call_level < DAHDI_CALL_LEVEL_ALERTING && !p->outgoing) {
               /* There are many cause codes that generate an AST_CONTROL_CONGESTION. */
               switch (chan->hangupcause) {
               case AST_CAUSE_USER_BUSY:
               case AST_CAUSE_NORMAL_CLEARING:
               case 0:/* Cause has not been set. */
                  /* Supply a more appropriate cause. */
                  chan->hangupcause = AST_CAUSE_SWITCH_CONGESTION;
                  break;
               default:
                  break;
               }
               p->progress = 1;/* No need to send plain PROGRESS after this. */
               if (p->pri && 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);
                  }
               }
            }
            break;
         }
#endif
         /* There are many cause codes that generate an AST_CONTROL_CONGESTION. */
         switch (chan->hangupcause) {
         case AST_CAUSE_USER_BUSY:
         case AST_CAUSE_NORMAL_CLEARING:
         case 0:/* Cause has not been set. */
            /* Supply a more appropriate cause. */
            chan->hangupcause = AST_CAUSE_CONGESTION;
            break;
         default:
            break;
         }
         res = tone_zone_play_tone(p->subs[index].dfd, DAHDI_TONE_CONGESTION);
         break;
      case AST_CONTROL_HOLD:
#ifdef HAVE_PRI
         if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) {
            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);       
         } else
#endif
            ast_moh_start(chan, data, p->mohinterpret);
         break;
      case AST_CONTROL_UNHOLD:
#ifdef HAVE_PRI
         if (p->pri && !strcasecmp(p->mohinterpret, "passthrough")) {
            if (!pri_grab(p, p->pri)) {
               res = pri_notify(p