chan_dahdi.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2008, Digium, Inc.
 *
 * Mark Spencer <[email protected]>
 *
 * 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 for Pseudo TDM
 *
 * \author Mark Spencer <[email protected]>
 *
 * 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.
 *
 * \ingroup channel_drivers
 *
 * \todo Deprecate the "musiconhold" configuration option post 1.4
 */

/*! \li \ref chan_dahdi.c uses the configuration file \ref chan_dahdi.conf
 * \addtogroup configuration_file
 */

/*! \page chan_dahdi.conf chan_dahdi.conf
 * \verbinclude chan_dahdi.conf.sample
 */

/*** MODULEINFO
 <depend>dahdi</depend>
 <depend>tonezone</depend>
 <use type="module">res_smdi</use>
 <use type="external">pri</use>
 <use type="external">ss7</use>
 <use type="external">openr2</use>
 <support_level>core</support_level>
 ***/

#include "asterisk.h"

#if defined(__NetBSD__) || defined(__FreeBSD__)
#include <pthread.h>
#else
#include <sys/sysmacros.h>
#endif
#include <signal.h>
#include <sys/stat.h>
#include <math.h>

#include "sig_analog.h"
/* Analog signaling is currently still present in chan_dahdi for use with
 * radio. Sig_analog does not currently handle any radio operations. If
 * radio only uses analog signaling, then the radio handling logic could
 * be placed in sig_analog and the duplicated code could be removed.
 */

#if defined(HAVE_PRI)
#include "sig_pri.h"
#ifndef PRI_RESTART
#error "Upgrade your libpri"
#endif
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_SS7)
#include "sig_ss7.h"
#if !defined(LIBSS7_ABI_COMPATIBILITY)
#error "Upgrade your libss7"
#elif LIBSS7_ABI_COMPATIBILITY != 2
#error "Your installed libss7 is not compatible"
#endif
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_OPENR2)
/* put this here until sig_mfcr2 comes along */
#define SIG_MFCR2_MAX_CHANNELS 672 /*!< No more than a DS3 per trunk group */
#endif /* defined(HAVE_OPENR2) */

#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.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/pickup.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/tdd.h"
#include "asterisk/mwi.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/devicestate.h"
#include "asterisk/paths.h"
#include "asterisk/ccss.h"
#include "asterisk/features_config.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/parking.h"
#include "asterisk/format_cache.h"
#include "chan_dahdi.h"
#include "dahdi/bridge_native_dahdi.h"

/*** DOCUMENTATION
 <application name="DAHDISendKeypadFacility" language="en_US">
 <synopsis>
 Send digits out of band over a PRI.
 </synopsis>
 <syntax>
 <parameter name="digits" required="true" />
 </syntax>
 <description>
 <para>This application will send the given string of digits in a Keypad
 Facility IE over the current channel.</para>
 </description>
 </application>
 <application name="DAHDISendCallreroutingFacility" language="en_US">
 <synopsis>
 Send an ISDN call rerouting/deflection facility message.
 </synopsis>
 <syntax argsep=",">
 <parameter name="destination" required="true">
 <para>Destination number.</para>
 </parameter>
 <parameter name="original">
 <para>Original called number.</para>
 </parameter>
 <parameter name="reason">
 <para>Diversion reason, if not specified defaults to <literal>unknown</literal></para>
 </parameter>
 </syntax>
 <description>
 <para>This application will send an ISDN switch specific call
 rerouting/deflection facility message over the current channel.
 Supported switches depend upon the version of libpri in use.</para>
 </description>
 </application>
 <application name="DAHDIAcceptR2Call" language="en_US">
 <synopsis>
 Accept an R2 call if its not already accepted (you still need to answer it)
 </synopsis>
 <syntax>
 <parameter name="charge" required="true">
 <para>Yes or No.</para>
 <para>Whether you want to accept the call with charge or without charge.</para>
 </parameter>
 </syntax>
 <description>
 <para>This application will Accept the R2 call either with charge or no charge.</para>
 </description>
 </application>
 <info name="CHANNEL" language="en_US" tech="DAHDI">
 <enumlist>
 <enum name="dahdi_channel">
 <para>R/O DAHDI channel related to this channel.</para>
 </enum>
 <enum name="dahdi_span">
 <para>R/O DAHDI span related to this channel.</para>
 </enum>
 <enum name="dahdi_group">
 <para>R/O DAHDI logical group related to this channel.</para>
 </enum>
 <enum name="dahdi_type">
 <para>R/O DAHDI channel type, one of:</para>
 <enumlist>
 <enum name="analog" />
 <enum name="mfc/r2" />
 <enum name="pri" />
 <enum name="pseudo" />
 <enum name="ss7" />
 </enumlist>
 </enum>
 <enum name="keypad_digits">
 <para>R/O PRI Keypad digits that came in with the SETUP message.</para>
 </enum>
 <enum name="reversecharge">
 <para>R/O PRI Reverse Charging Indication, one of:</para>
 <enumlist>
 <enum name="-1"> <para>None</para></enum>
 <enum name=" 1"> <para>Reverse Charging Requested</para></enum>
 </enumlist>
 </enum>
 <enum name="no_media_path">
 <para>R/O PRI Nonzero if the channel has no B channel.
 The channel is either on hold or a call waiting call.</para>
 </enum>
 <enum name="buffers">
 <para>W/O Change the channel's buffer policy (for the current call only)</para>
 <para>This option takes two arguments:</para>
 <para> Number of buffers,</para>
 <para> Buffer policy being one of:</para>
 <para> <literal>full</literal></para>
 <para> <literal>immediate</literal></para>
 <para> <literal>half</literal></para>
 </enum>
 <enum name="echocan_mode">
 <para>W/O Change the configuration of the active echo
 canceller on the channel (if any), for the current call
 only.</para>
 <para>Possible values are:</para>
 <para> <literal>on</literal> Normal mode (the echo canceller is actually reinitalized)</para>
 <para> <literal>off</literal> Disabled</para>
 <para> <literal>fax</literal> FAX/data mode (NLP disabled if possible, otherwise
 completely disabled)</para>
 <para> <literal>voice</literal> Voice mode (returns from FAX mode, reverting the changes that were made)</para>
 </enum>
 </enumlist>
 </info>
 <manager name="DAHDITransfer" language="en_US">
 <synopsis>
 Transfer DAHDI Channel.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel" required="true">
 <para>DAHDI channel number to transfer.</para>
 </parameter>
 </syntax>
 <description>
 <para>Simulate a flash hook event by the user connected to the channel.</para>
 <note><para>Valid only for analog channels.</para></note>
 </description>
 </manager>
 <manager name="DAHDIHangup" language="en_US">
 <synopsis>
 Hangup DAHDI Channel.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel" required="true">
 <para>DAHDI channel number to hangup.</para>
 </parameter>
 </syntax>
 <description>
 <para>Simulate an on-hook event by the user connected to the channel.</para>
 <note><para>Valid only for analog channels.</para></note>
 </description>
 </manager>
 <manager name="DAHDIDialOffhook" language="en_US">
 <synopsis>
 Dial over DAHDI channel while offhook.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel" required="true">
 <para>DAHDI channel number to dial digits.</para>
 </parameter>
 <parameter name="Number" required="true">
 <para>Digits to dial.</para>
 </parameter>
 </syntax>
 <description>
 <para>Generate DTMF control frames to the bridged peer.</para>
 </description>
 </manager>
 <manager name="DAHDIDNDon" language="en_US">
 <synopsis>
 Toggle DAHDI channel Do Not Disturb status ON.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel" required="true">
 <para>DAHDI channel number to set DND on.</para>
 </parameter>
 </syntax>
 <description>
 <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> on".</para>
 <note><para>Feature only supported by analog channels.</para></note>
 </description>
 </manager>
 <manager name="DAHDIDNDoff" language="en_US">
 <synopsis>
 Toggle DAHDI channel Do Not Disturb status OFF.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel" required="true">
 <para>DAHDI channel number to set DND off.</para>
 </parameter>
 </syntax>
 <description>
 <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> off".</para>
 <note><para>Feature only supported by analog channels.</para></note>
 </description>
 </manager>
 <manager name="DAHDIShowChannels" language="en_US">
 <synopsis>
 Show status of DAHDI channels.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="DAHDIChannel">
 <para>Specify the specific channel number to show. Show all channels if zero or not present.</para>
 </parameter>
 </syntax>
 <description>
 <para>Similar to the CLI command "dahdi show channels".</para>
 </description>
 </manager>
 <manager name="DAHDIRestart" language="en_US">
 <synopsis>
 Fully Restart DAHDI channels (terminates calls).
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 </syntax>
 <description>
 <para>Equivalent to the CLI command "dahdi restart".</para>
 </description>
 </manager>
 <manager name="PRIShowSpans" language="en_US">
 <synopsis>
 Show status of PRI spans.
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="Span">
 <para>Specify the specific span to show. Show all spans if zero or not present.</para>
 </parameter>
 </syntax>
 <description>
 <para>Similar to the CLI command "pri show spans".</para>
 </description>
 </manager>
 <manager name="PRIDebugSet" language="en_US">
 <synopsis>
 Set PRI debug levels for a span
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="Span" required="true">
 <para>Which span to affect.</para>
 </parameter>
 <parameter name="Level" required="true">
 <para>What debug level to set. May be a numerical value or a text value from the list below</para>
 <enumlist>
 <enum name="off" />
 <enum name="on" />
 <enum name="hex" />
 <enum name="intense" />
 </enumlist>
 </parameter>
 </syntax>
 <description>
 <para>Equivalent to the CLI command "pri set debug &lt;level&gt; span &lt;span&gt;".</para>
 </description>
 </manager>
 <manager name="PRIDebugFileSet" language="en_US">
 <synopsis>
 Set the file used for PRI debug message output
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 <parameter name="File" required="true">
 <para>Path of file to write debug output.</para>
 </parameter>
 </syntax>
 <description>
 <para>Equivalent to the CLI command "pri set debug file &lt;output-file&gt;"</para>
 </description>
 </manager>
 <manager name="PRIDebugFileUnset" language="en_US">
 <synopsis>
 Disables file output for PRI debug messages
 </synopsis>
 <syntax>
 <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 </syntax>
 </manager>
 <managerEvent language="en_US" name="AlarmClear">
 <managerEventInstance class="EVENT_FLAG_SYSTEM">
 <synopsis>Raised when an alarm is cleared on a DAHDI channel.</synopsis>
 <syntax>
 <parameter name="DAHDIChannel">
 <para>The DAHDI channel on which the alarm was cleared.</para>
 <note><para>This is not an Asterisk channel identifier.</para></note>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 <managerEvent language="en_US" name="SpanAlarmClear">
 <managerEventInstance class="EVENT_FLAG_SYSTEM">
 <synopsis>Raised when an alarm is cleared on a DAHDI span.</synopsis>
 <syntax>
 <parameter name="Span">
 <para>The span on which the alarm was cleared.</para>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 <managerEvent language="en_US" name="DNDState">
 <managerEventInstance class="EVENT_FLAG_SYSTEM">
 <synopsis>Raised when the Do Not Disturb state is changed on a DAHDI channel.</synopsis>
 <syntax>
 <parameter name="DAHDIChannel">
 <para>The DAHDI channel on which DND status changed.</para>
 <note><para>This is not an Asterisk channel identifier.</para></note>
 </parameter>
 <parameter name="Status">
 <enumlist>
 <enum name="enabled"/>
 <enum name="disabled"/>
 </enumlist>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 <managerEvent language="en_US" name="Alarm">
 <managerEventInstance class="EVENT_FLAG_SYSTEM">
 <synopsis>Raised when an alarm is set on a DAHDI channel.</synopsis>
 <syntax>
 <parameter name="DAHDIChannel">
 <para>The channel on which the alarm occurred.</para>
 <note><para>This is not an Asterisk channel identifier.</para></note>
 </parameter>
 <parameter name="Alarm">
 <para>A textual description of the alarm that occurred.</para>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 <managerEvent language="en_US" name="SpanAlarm">
 <managerEventInstance class="EVENT_FLAG_SYSTEM">
 <synopsis>Raised when an alarm is set on a DAHDI span.</synopsis>
 <syntax>
 <parameter name="Span">
 <para>The span on which the alarm occurred.</para>
 </parameter>
 <parameter name="Alarm">
 <para>A textual description of the alarm that occurred.</para>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 <managerEvent language="en_US" name="DAHDIChannel">
 <managerEventInstance class="EVENT_FLAG_CALL">
 <synopsis>Raised when a DAHDI channel is created or an underlying technology is associated with a DAHDI channel.</synopsis>
 <syntax>
 <channel_snapshot/>
 <parameter name="DAHDIGroup">
 <para>The DAHDI logical group associated with this channel.</para>
 </parameter>
 <parameter name="DAHDISpan">
 <para>The DAHDI span associated with this channel.</para>
 </parameter>
 <parameter name="DAHDIChannel">
 <para>The DAHDI channel associated with this channel.</para>
 </parameter>
 </syntax>
 </managerEventInstance>
 </managerEvent>
 ***/

#define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */

static const char * const lbostr[] = {
"0 db (CSU)/0-133 feet (DSX-1)",
"133-266 feet (DSX-1)",
"266-399 feet (DSX-1)",
"399-533 feet (DSX-1)",
"533-655 feet (DSX-1)",
"-7.5db (CSU)",
"-15db (CSU)",
"-22.5db (CSU)"
};

/*! Global jitterbuffer configuration - by default, jb is disabled
 * \note Values shown here match the defaults shown in chan_dahdi.conf.sample */
static struct ast_jb_conf default_jbconf =
{
 .flags = 0,
 .max_size = 200,
 .resync_threshold = 1000,
 .impl = "fixed",
 .target_extra = 40,
};
static struct ast_jb_conf global_jbconf;

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

/*! \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"
#if defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2)
 " w/"
 #if defined(HAVE_PRI)
 "PRI"
 #endif /* defined(HAVE_PRI) */
 #if defined(HAVE_SS7)
 #if defined(HAVE_PRI)
 " & "
 #endif /* defined(HAVE_PRI) */
 "SS7"
 #endif /* defined(HAVE_SS7) */
 #if defined(HAVE_OPENR2)
 #if defined(HAVE_PRI) || defined(HAVE_SS7)
 " & "
 #endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */
 "MFC/R2"
 #endif /* defined(HAVE_OPENR2) */
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2) */
;

static const char config[] = "chan_dahdi.conf";

#ifdef LOTS_OF_SPANS
#define NUM_SPANS DAHDI_MAX_SPANS
#else
#define NUM_SPANS 32
#endif

#define CHAN_PSEUDO -2

#define CALLPROGRESS_PROGRESS 1
#define CALLPROGRESS_FAX_OUTGOING 2
#define CALLPROGRESS_FAX_INCOMING 4
#define CALLPROGRESS_FAX (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)

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

static int has_pseudo;

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 */
};

/* ETSI EN300 659-1 specifies the ring pulse between 200 and 300 mS */
static struct dahdi_ring_cadence AS_RP_cadence = {{250, 10000}};

#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) */)

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

/*! Run this script when the MWI state changes on an FXO line, if mwimonitor is enabled */
static char mwimonitornotify[PATH_MAX] = "";
#ifndef HAVE_DAHDI_LINEREVERSE_VMWI
static int mwisend_rpas = 0;
#endif

static char progzone[10] = "";

static int usedistinctiveringdetection = 0;
static int distinctiveringaftercid = 0;

static int numbufs = 4;

static int mwilevel = 512;
static int dtmfcid_level = 256;

#define REPORT_CHANNEL_ALARMS 1
#define REPORT_SPAN_ALARMS 2
static int report_alarms = REPORT_CHANNEL_ALARMS;

#ifdef HAVE_PRI
static int pridebugfd = -1;
static char pridebugfilename[1024] = "";
#endif

/*! \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 int dahdi_sendtext(struct ast_channel *c, const char *text);

/*! \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 */
#define DEFAULT_DIALTONE_DETECT_TIMEOUT ((10000 * 8) / READ_SIZE) /*!< 10,000 ms */

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

#if defined(HAVE_SS7)

struct dahdi_ss7 {
 struct sig_ss7_linkset ss7;
};

static struct dahdi_ss7 linksets[NUM_SPANS];

static int cur_ss7type = -1;
static int cur_slc = -1;
static int cur_linkset = -1;
static int cur_pointcode = -1;
static int cur_cicbeginswith = -1;
static int cur_adjpointcode = -1;
static int cur_networkindicator = -1;
static int cur_defaultdpc = -1;
#endif /* defined(HAVE_SS7) */

#ifdef HAVE_OPENR2
struct dahdi_mfcr2_conf {
 openr2_variant_t variant;
 int mfback_timeout;
 int metering_pulse_timeout;
 int max_ani;
 int max_dnis;
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
 int dtmf_time_on;
 int dtmf_time_off;
#endif
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
 int dtmf_end_timeout;
#endif
 signed int get_ani_first:2;
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
 signed int skip_category_request:2;
#endif
 unsigned int call_files:1;
 unsigned int allow_collect_calls:1;
 unsigned int charge_calls:1;
 unsigned int accept_on_offer:1;
 unsigned int forced_release:1;
 unsigned int double_answer:1;
 signed int immediate_accept:2;
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
 signed int dtmf_dialing:2;
 signed int dtmf_detection:2;
#endif
 char logdir[OR2_MAX_PATH];
 char r2proto_file[OR2_MAX_PATH];
 openr2_log_level_t loglevel;
 openr2_calling_party_category_t category;
};

/* MFC-R2 pseudo-link structure */
struct dahdi_mfcr2 {
 int index; /*!< Unique index for CLI */
 pthread_t r2master; /*!< Thread of master */
 openr2_context_t *protocol_context; /*!< OpenR2 context handle */
 struct dahdi_pvt *pvts[SIG_MFCR2_MAX_CHANNELS]; /*!< Member channel pvt structs */
 int numchans; /*!< Number of channels in this R2 block */
 int live_chans; /*!< Number of unremoved channels in this R2 block */
 int nodev; /*!< Link disconnected? */
 struct dahdi_mfcr2_conf conf; /*!< Configuration used to setup this pseudo-link */
};

struct r2link_entry {
 struct dahdi_mfcr2 mfcr2;
 AST_LIST_ENTRY(r2link_entry) list;
};
static AST_LIST_HEAD_STATIC(r2links, r2link_entry);
static struct r2links nodev_r2links = AST_LIST_HEAD_INIT_VALUE;


/* how many r2links have been malloc'd */
static int r2links_count = 0;

#endif /* HAVE_OPENR2 */

#ifdef HAVE_PRI

struct dahdi_pri {
 int dchannels[SIG_PRI_NUM_DCHANS]; /*!< What channel are the dchannels on */
 int mastertrunkgroup; /*!< What trunk group is our master */
 int prilogicalspan; /*!< Logical span number within trunk group */
 struct sig_pri_span pri;
};

static struct dahdi_pri pris[NUM_SPANS];

#if defined(HAVE_PRI_CCSS)
/*! DAHDI PRI CCSS agent and monitor type name. */
static const char dahdi_pri_cc_type[] = "DAHDI/PRI";
#endif /* defined(HAVE_PRI_CCSS) */

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

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

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

static struct dahdi_pvt *iflist = NULL; /*!< Main interface list start */
static struct dahdi_pvt *ifend = NULL; /*!< Main interface list end */

#if defined(HAVE_PRI)
struct doomed_pri {
 struct sig_pri_span *pri;
 AST_LIST_ENTRY(doomed_pri) list;
};
static AST_LIST_HEAD_STATIC(doomed_pris, doomed_pri);

static void pri_destroy_span(struct sig_pri_span *pri);

static struct dahdi_parms_pseudo {
 int buf_no; /*!< Number of buffers */
 int buf_policy; /*!< Buffer policy */
 int faxbuf_no; /*!< Number of Fax buffers */
 int faxbuf_policy; /*!< Fax buffer policy */
} dahdi_pseudo_parms;
#endif /* defined(HAVE_PRI) */

/*! \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)
 *
 * \see dahdi_chan_init for the default values.
 */
struct dahdi_chan_conf {
 struct dahdi_pvt chan;
#ifdef HAVE_PRI
 struct dahdi_pri pri;
#endif

#if defined(HAVE_SS7)
 struct dahdi_ss7 ss7;
#endif /* defined(HAVE_SS7) */

#ifdef HAVE_OPENR2
 struct dahdi_mfcr2_conf mfcr2;
#endif
 struct dahdi_params timing;
 int is_sig_auto; /*!< Use channel signalling from DAHDI? */
 /*! Continue configuration even if a channel is not there. */
 int ignore_failed_channels;

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

 /*!
 * \brief Don't create channels below this number
 * \note by default is 0 (no limit)
 */
 int wanted_channels_start;

 /*!
 * \brief Don't create channels above this number (infinity by default)
 * \note by default is 0 (special value that means "no limit").
 */
 int wanted_channels_end;
};

/*! 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.pri = {
 .nsf = PRI_NSF_NONE,
 .switchtype = PRI_SWITCH_NI2,
 .dialplan = PRI_UNKNOWN + 1,
 .localdialplan = PRI_NATIONAL_ISDN + 1,
 .nodetype = PRI_CPE,
 .qsigchannelmapping = DAHDI_CHAN_MAPPING_PHYSICAL,

#if defined(HAVE_PRI_CCSS)
 .cc_ptmp_recall_mode = 1,/* specificRecall */
 .cc_qsig_signaling_link_req = 1,/* retain */
 .cc_qsig_signaling_link_rsp = 1,/* retain */
#endif /* defined(HAVE_PRI_CCSS) */

 .minunused = 2,
 .idleext = "",
 .idledial = "",
 .internationalprefix = "",
 .nationalprefix = "",
 .localprefix = "",
 .privateprefix = "",
 .unknownprefix = "",
 .colp_send = SIG_PRI_COLP_UPDATE,
 .resetinterval = -1,
 },
#endif
#if defined(HAVE_SS7)
 .ss7.ss7 = {
 .called_nai = SS7_NAI_NATIONAL,
 .calling_nai = SS7_NAI_NATIONAL,
 .internationalprefix = "",
 .nationalprefix = "",
 .subscriberprefix = "",
 .unknownprefix = "",
 .networkroutedprefix = ""
 },
#endif /* defined(HAVE_SS7) */
#ifdef HAVE_OPENR2
 .mfcr2 = {
 .variant = OR2_VAR_ITU,
 .mfback_timeout = -1,
 .metering_pulse_timeout = -1,
 .max_ani = 10,
 .max_dnis = 4,
 .get_ani_first = -1,
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
 .skip_category_request = -1,
#endif
 .call_files = 0,
 .allow_collect_calls = 0,
 .charge_calls = 1,
 .accept_on_offer = 1,
 .forced_release = 0,
 .double_answer = 0,
 .immediate_accept = -1,
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
 .dtmf_dialing = -1,
 .dtmf_detection = -1,
 .dtmf_time_on = OR2_DEFAULT_DTMF_ON,
 .dtmf_time_off = OR2_DEFAULT_DTMF_OFF,
#endif
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
 .dtmf_end_timeout = -1,
#endif
 .logdir = "",
 .r2proto_file = "",
 .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING,
 .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER
 },
#endif
 .chan = {
 .context = "default",
 .cid_num = "",
 .cid_name = "",
 .cid_tag = "",
 .mohinterpret = "default",
 .mohsuggest = "",
 .parkinglot = "",
 .transfertobusy = 1,

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

 .cid_rxgain = +5.0,

 .tonezone = -1,

 .echocancel.head.tap_length = 1,

 .busycount = 3,

 .accountcode = "",

 .mailbox = "",

#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
 .mwisend_fsk = 1,
#endif
 .polarityonanswerdelay = 600,

 .sendcalleridafter = DEFAULT_CIDRINGS,

 .buf_policy = DAHDI_POLICY_IMMEDIATE,
 .buf_no = numbufs,
 .usefaxbuffers = 0,
 .cc_params = ast_cc_config_params_init(),
 .firstdigit_timeout = ANALOG_FIRST_DIGIT_TIMEOUT,
 .interdigit_timeout = ANALOG_INTER_DIGIT_TIMEOUT,
 .matchdigit_timeout = ANALOG_MATCH_DIGIT_TIMEOUT,
 },
 .timing = {
 .prewinktime = -1,
 .preflashtime = -1,
 .winktime = -1,
 .flashtime = -1,
 .starttime = -1,
 .rxwinktime = -1,
 .rxflashtime = -1,
 .debouncetime = -1
 },
 .is_sig_auto = 1,
 .ignore_failed_channels = 1,
 .smdi_port = "/dev/ttyS0",
 };

 return conf;
}


static struct ast_channel *dahdi_request(const char *type, struct ast_format_cap *cap,
 const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor,
 const char *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, const 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_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
static int dahdi_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len);
static int dahdi_func_write(struct ast_channel *chan, const char *function, char *data, const char *value);
static int dahdi_devicestate(const char *data);
static int dahdi_cc_callback(struct ast_channel *inbound, const char *dest, ast_cc_callback_fn callback);

static struct ast_channel_tech dahdi_tech = {
 .type = "DAHDI",
 .description = tdesc,
 .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,
 .exception = dahdi_exception,
 .indicate = dahdi_indicate,
 .fixup = dahdi_fixup,
 .setoption = dahdi_setoption,
 .queryoption = dahdi_queryoption,
 .func_channel_read = dahdi_func_read,
 .func_channel_write = dahdi_func_write,
 .devicestate = dahdi_devicestate,
 .cc_callback = dahdi_cc_callback,
};

#define GET_CHANNEL(p) ((p)->channel)

static enum analog_sigtype dahdisig_to_analogsig(int sig)
{
 switch (sig) {
 case SIG_FXOLS:
 return ANALOG_SIG_FXOLS;
 case SIG_FXOGS:
 return ANALOG_SIG_FXOGS;
 case SIG_FXOKS:
 return ANALOG_SIG_FXOKS;
 case SIG_FXSLS:
 return ANALOG_SIG_FXSLS;
 case SIG_FXSGS:
 return ANALOG_SIG_FXSGS;
 case SIG_FXSKS:
 return ANALOG_SIG_FXSKS;
 case SIG_EMWINK:
 return ANALOG_SIG_EMWINK;
 case SIG_EM:
 return ANALOG_SIG_EM;
 case SIG_EM_E1:
 return ANALOG_SIG_EM_E1;
 case SIG_FEATD:
 return ANALOG_SIG_FEATD;
 case SIG_FEATDMF:
 return ANALOG_SIG_FEATDMF;
 case SIG_E911:
 return SIG_E911;
 case SIG_FGC_CAMA:
 return ANALOG_SIG_FGC_CAMA;
 case SIG_FGC_CAMAMF:
 return ANALOG_SIG_FGC_CAMAMF;
 case SIG_FEATB:
 return ANALOG_SIG_FEATB;
 case SIG_SFWINK:
 return ANALOG_SIG_SFWINK;
 case SIG_SF:
 return ANALOG_SIG_SF;
 case SIG_SF_FEATD:
 return ANALOG_SIG_SF_FEATD;
 case SIG_SF_FEATDMF:
 return ANALOG_SIG_SF_FEATDMF;
 case SIG_FEATDMF_TA:
 return ANALOG_SIG_FEATDMF_TA;
 case SIG_SF_FEATB:
 return ANALOG_SIG_FEATB;
 default:
 return -1;
 }
}


static int analog_tone_to_dahditone(enum analog_tone tone)
{
 switch (tone) {
 case ANALOG_TONE_RINGTONE:
 return DAHDI_TONE_RINGTONE;
 case ANALOG_TONE_STUTTER:
 return DAHDI_TONE_STUTTER;
 case ANALOG_TONE_CONGESTION:
 return DAHDI_TONE_CONGESTION;
 case ANALOG_TONE_DIALTONE:
 return DAHDI_TONE_DIALTONE;
 case ANALOG_TONE_DIALRECALL:
 return DAHDI_TONE_DIALRECALL;
 case ANALOG_TONE_INFO:
 return DAHDI_TONE_INFO;
 default:
 return -1;
 }
}

static int analogsub_to_dahdisub(enum analog_sub analogsub)
{
 int index;

 switch (analogsub) {
 case ANALOG_SUB_REAL:
 index = SUB_REAL;
 break;
 case ANALOG_SUB_CALLWAIT:
 index = SUB_CALLWAIT;
 break;
 case ANALOG_SUB_THREEWAY:
 index = SUB_THREEWAY;
 break;
 default:
 ast_log(LOG_ERROR, "Unidentified sub!\n");
 index = SUB_REAL;
 }

 return index;
}

/*!
 * \internal
 * \brief release all members on the doomed pris list
 * \since 13.0
 *
 * Called priodically by the monitor threads to release spans marked for
 * removal.
 */
static void release_doomed_pris(void)
{
#ifdef HAVE_PRI
 struct doomed_pri *entry;

 AST_LIST_LOCK(&doomed_pris);
 while ((entry = AST_LIST_REMOVE_HEAD(&doomed_pris, list))) {
 /* The span destruction must be done with this lock not held */
 AST_LIST_UNLOCK(&doomed_pris);
 ast_debug(4, "Destroying span %d from doomed queue.\n",
 entry->pri->span);
 pri_destroy_span(entry->pri);
 ast_free(entry);
 AST_LIST_LOCK(&doomed_pris);
 }
 AST_LIST_UNLOCK(&doomed_pris);
#endif
}

#ifdef HAVE_PRI
/*!
 * \brief Queue a span for destruction
 * \since 13.0
 *
 * \param pri the span to destroy
 *
 * Add a span to the list of spans to be destroyed later on
 * by the monitor thread. Allows destroying a span while holding its
 * lock.
 */
static void pri_queue_for_destruction(struct sig_pri_span *pri)
{
 struct doomed_pri *entry;

 AST_LIST_LOCK(&doomed_pris);
 AST_LIST_TRAVERSE(&doomed_pris, entry, list) {
 if (entry->pri == pri) {
 AST_LIST_UNLOCK(&doomed_pris);
 return;
 }
 }
 entry = ast_calloc(sizeof(struct doomed_pri), 1);
 if (!entry) {
 /* Nothing useful to do here. Panic? */
 ast_log(LOG_WARNING, "Failed allocating memory for a doomed_pri.\n");
 AST_LIST_UNLOCK(&doomed_pris);
 return;
 }
 entry->pri = pri;
 ast_debug(4, "Queue span %d for destruction.\n", pri->span);
 AST_LIST_INSERT_TAIL(&doomed_pris, entry, list);
 AST_LIST_UNLOCK(&doomed_pris);
}
#endif

/*!
 * \internal
 * \brief Send a dial string to DAHDI.
 * \since 12.0.0
 *
 * \param pvt DAHDI private pointer
 * \param operation DAHDI dial operation to do to string
 * \param dial_str Dial string to send
 *
 * \retval 0 on success.
 * \retval non-zero on error.
 */
static int dahdi_dial_str(struct dahdi_pvt *pvt, int operation, const char *dial_str)
{
 int res;
 int offset;
 const char *pos;
 struct dahdi_dialoperation zo = {
 .op = operation,
 };

 /* Convert the W's to ww. */
 pos = dial_str;
 for (offset = 0; offset < sizeof(zo.dialstr) - 1; ++offset) {
 if (!*pos) {
 break;
 }
 if (*pos == 'W') {
 /* Convert 'W' to "ww" */
 ++pos;
 if (offset >= sizeof(zo.dialstr) - 3) {
 /* No room to expand */
 break;
 }
 zo.dialstr[offset] = 'w';
 ++offset;
 zo.dialstr[offset] = 'w';
 continue;
 }
 zo.dialstr[offset] = *pos++;
 }
 /* The zo initialization has already terminated the dialstr. */

 ast_debug(1, "Channel %d: Dial str '%s' expanded to '%s' sent to DAHDI_DIAL.\n",
 pvt->channel, dial_str, zo.dialstr);
 res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_DIAL, &zo);
 if (res) {
 ast_log(LOG_WARNING, "Channel %d: Couldn't dial '%s': %s\n",
 pvt->channel, dial_str, strerror(errno));
 }

 return res;
}

static enum analog_event dahdievent_to_analogevent(int event);
static int bump_gains(struct dahdi_pvt *p);
static int dahdi_setlinear(int dfd, int linear);

static int my_start_cid_detect(void *pvt, int cid_signalling)
{
 struct dahdi_pvt *p = pvt;
 int index = SUB_REAL;
 p->cs = callerid_new(cid_signalling);
 if (!p->cs) {
 ast_log(LOG_ERROR, "Unable to alloc callerid\n");
 return -1;
 }
 bump_gains(p);
 dahdi_setlinear(p->subs[index].dfd, 0);

 return 0;
}

static int restore_gains(struct dahdi_pvt *p);

static int my_stop_cid_detect(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int index = SUB_REAL;

 if (p->cs) {
 callerid_free(p->cs);
 }

 /* Restore linear mode after Caller*ID processing */
 dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
 restore_gains(p);

 return 0;
}

static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
{
 struct dahdi_pvt *p = pvt;
 struct analog_pvt *analog_p = p->sig_pvt;
 struct pollfd poller;
 char *name, *num;
 int index = SUB_REAL;
 int res;
 unsigned char buf[256];
 int flags;

 poller.fd = p->subs[SUB_REAL].dfd;
 poller.events = POLLPRI | POLLIN;
 poller.revents = 0;

 res = poll(&poller, 1, timeout);

 if (poller.revents & POLLPRI) {
 *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd));
 return 1;
 }

 if (poller.revents & POLLIN) {
 /*** NOTES ***/
 /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function
 * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until
 * either a timeout occurs or CID is detected (returns 0). returning 1 should be event received, and -1 should be
 * a failure and die, and returning 2 means no event was received. */
 res = read(p->subs[index].dfd, buf, sizeof(buf));
 if (res < 0) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 return -1;
 }

 if (analog_p->ringt > 0) {
 if (!(--analog_p->ringt)) {
 /* only return if we timeout from a ring event */
 return -1;
 }
 }

 if (p->cid_signalling == CID_SIG_V23_JP) {
 res = callerid_feed_jp(p->cs, buf, res, AST_LAW(p));
 } else {
 res = callerid_feed(p->cs, buf, res, AST_LAW(p));
 }
 if (res < 0) {
 /*
 * The previous diagnostic message output likely
 * explains why it failed.
 */
 ast_log(LOG_WARNING, "Failed to decode CallerID\n");
 return -1;
 }

 if (res == 1) {
 callerid_get(p->cs, &name, &num, &flags);
 if (name)
 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
 if (num)
 ast_copy_string(numbuf, num, ANALOG_MAX_CID);

 ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
 return 0;
 }
 }

 *ev = ANALOG_EVENT_NONE;
 return 2;
}

static const char *event2str(int event);

static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
{
 unsigned char buf[256];
 int distMatches;
 int curRingData[RING_PATTERNS];
 int receivedRingT;
 int counter1;
 int counter;
 int i;
 int res;
 int checkaftercid = 0;
 const char *matched_context;
 struct dahdi_pvt *p = pvt;
 struct analog_pvt *analog_p = p->sig_pvt;

 if (ringdata == NULL) {
 ringdata = curRingData;
 } else {
 checkaftercid = 1;
 }

 /* We must have a ring by now so lets try to listen for distinctive ringing */
 if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
 /* Clear the current ring data array so we don't have old data in it. */
 for (receivedRingT = 0; receivedRingT < RING_PATTERNS; receivedRingT++)
 ringdata[receivedRingT] = 0;
 receivedRingT = 0;

 if (checkaftercid && distinctiveringaftercid) {
 ast_verb(3, "Detecting post-CID distinctive ring\n");
 }

 for (;;) {
 i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
 res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i);
 if (res) {
 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
 ast_hangup(chan);
 return 1;
 }
 if (i & DAHDI_IOMUX_SIGEVENT) {
 res = dahdi_get_event(p->subs[idx].dfd);
 ast_debug(3, "Got event %d (%s)...\n", res, event2str(res));
 if (res == DAHDI_EVENT_NOALARM) {
 p->inalarm = 0;
 analog_p->inalarm = 0;
 } else if (res == DAHDI_EVENT_RINGOFFHOOK) {
 /* Let us detect distinctive ring */
 ringdata[receivedRingT] = analog_p->ringt;

 if (analog_p->ringt < analog_p->ringt_base / 2) {
 break;
 }
 /* Increment the ringT counter so we can match it against
 values in chan_dahdi.conf for distinctive ring */
 if (++receivedRingT == RING_PATTERNS) {
 break;
 }
 }
 } else if (i & DAHDI_IOMUX_READ) {
 res = read(p->subs[idx].dfd, buf, sizeof(buf));
 if (res < 0) {
 if (errno != ELAST) {
 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
 ast_hangup(chan);
 return 1;
 }
 break;
 }
 if (analog_p->ringt > 0) {
 if (!(--analog_p->ringt)) {
 break;
 }
 }
 }
 }
 }

 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
 ast_verb(3, "Detected ring pattern: %d,%d,%d\n", ringdata[0], ringdata[1], ringdata[2]);
 matched_context = p->defcontext;
 for (counter = 0; counter < 3; counter++) {
 int range = p->drings.ringnum[counter].range;

 distMatches = 0;
 ast_verb(3, "Checking %d,%d,%d with +/- %d range\n",
 p->drings.ringnum[counter].ring[0],
 p->drings.ringnum[counter].ring[1],
 p->drings.ringnum[counter].ring[2],
 range);
 for (counter1 = 0; counter1 < 3; counter1++) {
 int ring = p->drings.ringnum[counter].ring[counter1];

 if (ring == -1) {
 ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
 ringdata[counter1]);
 distMatches++;
 } else if (ring - range <= ringdata[counter1] && ringdata[counter1] <= ring + range) {
 ast_verb(3, "Ring pattern %d is in range: %d to %d\n",
 ringdata[counter1], ring - range, ring + range);
 distMatches++;
 } else {
 /* The current dring pattern cannot match. */
 break;
 }
 }

 if (distMatches == 3) {
 /* The ring matches, set the context to whatever is for distinctive ring.. */
 matched_context = S_OR(p->drings.ringContext[counter].contextData, p->defcontext);
 ast_verb(3, "Matched Distinctive Ring context %s\n", matched_context);
 break;
 }
 }

 /* Set selected distinctive ring context if not already set. */
 if (strcmp(p->context, matched_context) != 0) {
 ast_copy_string(p->context, matched_context, sizeof(p->context));
 ast_channel_context_set(chan, matched_context);
 }

 return 0;
}

static int my_stop_callwait(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 p->callwaitingrepeat = 0;
 p->cidcwexpire = 0;
 p->cid_suppress_expire = 0;

 return 0;
}

static int send_callerid(struct dahdi_pvt *p);
static int save_conference(struct dahdi_pvt *p);
static int restore_conference(struct dahdi_pvt *p);

static int my_callwait(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
 if (p->cidspill) {
 ast_log(LOG_WARNING, "Spill already exists?!?\n");
 ast_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 my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
{
 struct dahdi_pvt *p = pvt;

 ast_debug(2, "Starting cid spill\n");

 if (p->cidspill) {
 ast_log(LOG_WARNING, "cidspill already exists??\n");
 ast_free(p->cidspill);
 }

 if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
 if (cwcid == 0) {
 p->cidlen = ast_callerid_generate(p->cidspill,
 caller->id.name.str,
 caller->id.number.str,
 AST_LAW(p));
 } else {
 ast_verb(3, "CPE supports Call Waiting Caller*ID. Sending '%s/%s'\n",
 caller->id.name.str, caller->id.number.str);
 p->callwaitcas = 0;
 p->cidcwexpire = 0;
 p->cidlen = ast_callerid_callwaiting_generate(p->cidspill,
 caller->id.name.str,
 caller->id.number.str,
 AST_LAW(p));
 p->cidlen += READ_SIZE * 4;
 }
 p->cidpos = 0;
 p->cid_suppress_expire = 0;
 send_callerid(p);
 }
 return 0;
}

static int my_dsp_reset_and_flush_digits(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 if (p->dsp)
 ast_dsp_digitreset(p->dsp);

 return 0;
}

static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
{
 struct dahdi_pvt *p = pvt;

 if (p->channel == CHAN_PSEUDO)
 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");

 if (mode == ANALOG_DIGITMODE_DTMF) {
 /* If we do hardware dtmf, no need for a DSP */
 if (p->hardwaredtmf) {
 if (p->dsp) {
 ast_dsp_free(p->dsp);
 p->dsp = NULL;
 }
 return 0;
 }

 if (!p->dsp) {
 p->dsp = ast_dsp_new();
 if (!p->dsp) {
 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
 return -1;
 }
 }

 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
 } else if (mode == ANALOG_DIGITMODE_MF) {
 if (!p->dsp) {
 p->dsp = ast_dsp_new();
 if (!p->dsp) {
 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
 return -1;
 }
 }
 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
 }
 return 0;
}

static int dahdi_wink(struct dahdi_pvt *p, int index);

static int my_wink(void *pvt, enum analog_sub sub)
{
 struct dahdi_pvt *p = pvt;
 int index = analogsub_to_dahdisub(sub);
 if (index != SUB_REAL) {
 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
 }
 return dahdi_wink(p, index);
}

static void wakeup_sub(struct dahdi_pvt *p, int a);

static int reset_conf(struct dahdi_pvt *p);

static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);

static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
{
 struct ast_frame *f = *dest;
 struct dahdi_pvt *p = pvt;
 int idx = analogsub_to_dahdisub(analog_index);

 ast_debug(1, "%s DTMF digit: 0x%02X '%c' on %s\n",
 f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
 (unsigned)f->subclass.integer, f->subclass.integer, ast_channel_name(ast));

 if (f->subclass.integer == 'f') {
 if (f->frametype == AST_FRAME_DTMF_END) {
 /* Fax tone -- Handle and return NULL */
 if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
 /* If faxbuffers are configured, use them for the fax transmission */
 if (p->usefaxbuffers && !p->bufferoverrideinuse) {
 struct dahdi_bufferinfo bi = {
 .txbufpolicy = p->faxbuf_policy,
 .bufsize = p->bufsize,
 .numbufs = p->faxbuf_no
 };
 int res;

 if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
 ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast_channel_name(ast), strerror(errno));
 } else {
 p->bufferoverrideinuse = 1;
 }
 }
 p->faxhandled = 1;
 if (p->dsp) {
 p->dsp_features &= ~DSP_FEATURE_FAX_DETECT;
 ast_dsp_set_features(p->dsp, p->dsp_features);
 ast_debug(1, "Disabling FAX tone detection on %s after tone received\n", ast_channel_name(ast));
 }
 if (strcmp(ast_channel_exten(ast), "fax")) {
 const char *target_context = S_OR(ast_channel_macrocontext(ast), ast_channel_context(ast));

 /*
 * 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 if the channel is locked.
 *
 * ast_async_goto() has its own restriction on not holding the
 * channel lock.
 */
 ast_mutex_unlock(&p->lock);
 ast_channel_unlock(ast);
 if (ast_exists_extension(ast, target_context, "fax", 1,
 S_COR(ast_channel_caller(ast)->id.number.valid, ast_channel_caller(ast)->id.number.str, NULL))) {
 ast_verb(3, "Redirecting %s to fax extension\n", ast_channel_name(ast));
 /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
 if (ast_async_goto(ast, target_context, "fax", 1))
 ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(ast), target_context);
 } else {
 ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
 }
 ast_channel_lock(ast);
 ast_mutex_lock(&p->lock);
 } else {
 ast_debug(1, "Already in a fax extension, not redirecting\n");
 }
 } else {
 ast_debug(1, "Fax already handled\n");
 }
 dahdi_confmute(p, 0);
 }
 p->subs[idx].f.frametype = AST_FRAME_NULL;
 p->subs[idx].f.subclass.integer = 0;
 *dest = &p->subs[idx].f;
 }
}

static void my_lock_private(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 ast_mutex_lock(&p->lock);
}

static void my_unlock_private(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 ast_mutex_unlock(&p->lock);
}

static void my_deadlock_avoidance_private(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 DEADLOCK_AVOIDANCE(&p->lock);
}

static struct ast_manager_event_blob *dahdichannel_to_ami(struct stasis_message *msg)
{
 RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
 struct ast_channel_blob *obj = stasis_message_data(msg);
 struct ast_json *group, *span, *channel;

 channel_string = ast_manager_build_channel_state_string(obj->snapshot);
 if (!channel_string) {
 return NULL;
 }

 group = ast_json_object_get(obj->blob, "group");
 span = ast_json_object_get(obj->blob, "span");
 channel = ast_json_object_get(obj->blob, "channel");

 return ast_manager_event_blob_create(EVENT_FLAG_CALL, "DAHDIChannel",
 "%s"
 "DAHDIGroup: %llu\r\n"
 "DAHDISpan: %u\r\n"
 "DAHDIChannel: %s\r\n",
 ast_str_buffer(channel_string),
 (ast_group_t)ast_json_integer_get(group),
 (unsigned int)ast_json_integer_get(span),
 ast_json_string_get(channel));
}

STASIS_MESSAGE_TYPE_DEFN_LOCAL(dahdichannel_type,
 .to_ami = dahdichannel_to_ami,
 );

/*! \brief Sends a DAHDIChannel channel blob used to produce DAHDIChannel AMI messages */
static void publish_dahdichannel(struct ast_channel *chan, ast_group_t group, int span, const char *dahdi_channel)
{
 RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);

 ast_assert(dahdi_channel != NULL);

 blob = ast_json_pack("{s: I, s: i, s: s}",
 "group", (ast_json_int_t)group,
 "span", span,
 "channel", dahdi_channel);
 if (!blob) {
 return;
 }

 ast_channel_lock(chan);
 ast_channel_publish_blob(chan, dahdichannel_type(), blob);
 ast_channel_unlock(chan);
}

/*!
 * \internal
 * \brief Post an AMI DAHDI channel association event.
 * \since 1.8
 *
 * \param p DAHDI private pointer
 * \param chan Channel associated with the private pointer
 *
 * \return Nothing
 */
static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
{
 char ch_name[23];

 if (p->channel < CHAN_PSEUDO) {
 /* No B channel */
 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
 } else if (p->channel == CHAN_PSEUDO) {
 /* Pseudo channel */
 strcpy(ch_name, "pseudo");
 } else {
 /* Real channel */
 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
 }
 publish_dahdichannel(chan, p->group, p->span, ch_name);
}

#ifdef HAVE_PRI
/*!
 * \internal
 * \brief Post an AMI DAHDI channel association event.
 * \since 1.8
 *
 * \param pvt DAHDI private pointer
 * \param chan Channel associated with the private pointer
 *
 * \return Nothing
 */
static void my_ami_channel_event(void *pvt, struct ast_channel *chan)
{
 struct dahdi_pvt *p = pvt;

 dahdi_ami_channel_event(p, chan);
}
#endif

/* linear_mode = 0 - turn linear mode off, >0 - turn linear mode on
* returns the last value of the linear setting
*/
static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
{
 struct dahdi_pvt *p = pvt;
 int oldval;
 int idx = analogsub_to_dahdisub(sub);

 dahdi_setlinear(p->subs[idx].dfd, linear_mode);
 oldval = p->subs[idx].linear;
 p->subs[idx].linear = linear_mode ? 1 : 0;
 return oldval;
}

static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
{
 struct dahdi_pvt *p = pvt;
 int idx = analogsub_to_dahdisub(sub);

 p->subs[idx].inthreeway = inthreeway;
}

static int get_alarms(struct dahdi_pvt *p);
static void handle_alarms(struct dahdi_pvt *p, int alms);
static void my_get_and_handle_alarms(void *pvt)
{
 int res;
 struct dahdi_pvt *p = pvt;

 res = get_alarms(p);
 handle_alarms(p, res);
}

static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
{
 RAII_VAR(struct ast_channel *, bridged, ast_channel_bridge_peer(chan), ast_channel_cleanup);

 if (bridged && ast_channel_tech(bridged) == &dahdi_tech) {
 struct dahdi_pvt *p = ast_channel_tech_pvt(bridged);

 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
 return p->sig_pvt;
 }
 }
 return NULL;
}

static int my_get_sub_fd(void *pvt, enum analog_sub sub)
{
 struct dahdi_pvt *p = pvt;
 int dahdi_sub = analogsub_to_dahdisub(sub);
 return p->subs[dahdi_sub].dfd;
}

static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
{
 struct dahdi_pvt *p = pvt;

 /* 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_channel_name(ast), strerror(errno));
 *cid_rings = 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_channel_name(ast), strerror(errno));
 *cid_rings = p->sendcalleridafter;
 }
}

static void my_set_alarm(void *pvt, int in_alarm)
{
 struct dahdi_pvt *p = pvt;

 p->inalarm = in_alarm;
}

static void my_set_dialing(void *pvt, int is_dialing)
{
 struct dahdi_pvt *p = pvt;

 p->dialing = is_dialing;
}

static void my_set_outgoing(void *pvt, int is_outgoing)
{
 struct dahdi_pvt *p = pvt;

 p->outgoing = is_outgoing;
}

#if defined(HAVE_PRI) || defined(HAVE_SS7)
static void my_set_digital(void *pvt, int is_digital)
{
 struct dahdi_pvt *p = pvt;

 p->digital = is_digital;
}
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static void my_set_inservice(void *pvt, int is_inservice)
{
 struct dahdi_pvt *p = pvt;

 p->inservice = is_inservice;
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static void my_set_locallyblocked(void *pvt, int is_blocked)
{
 struct dahdi_pvt *p = pvt;

 p->locallyblocked = is_blocked;
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static void my_set_remotelyblocked(void *pvt, int is_blocked)
{
 struct dahdi_pvt *p = pvt;

 p->remotelyblocked = is_blocked;
}
#endif /* defined(HAVE_SS7) */

static void my_set_ringtimeout(void *pvt, int ringt)
{
 struct dahdi_pvt *p = pvt;
 p->ringt = ringt;
}

static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
{
 struct dahdi_pvt *p = pvt;

 if (p->waitfordialtone && CANPROGRESSDETECT(p) && p->dsp) {
 ast_debug(1, "Defer dialing for %dms or dialtone\n", p->waitfordialtone);
 gettimeofday(&p->waitingfordt, NULL);
 ast_setstate(ast, AST_STATE_OFFHOOK);
 }
}

static int my_check_waitingfordt(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 if (p->waitingfordt.tv_sec) {
 return 1;
 }

 return 0;
}

static void my_set_confirmanswer(void *pvt, int flag)
{
 struct dahdi_pvt *p = pvt;
 p->confirmanswer = flag;
}

static int my_check_confirmanswer(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 if (p->confirmanswer) {
 return 1;
 }

 return 0;
}

static void my_set_callwaiting(void *pvt, int callwaiting_enable)
{
 struct dahdi_pvt *p = pvt;

 p->callwaiting = callwaiting_enable;
}

static void my_cancel_cidspill(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 ast_free(p->cidspill);
 p->cidspill = NULL;
 restore_conference(p);
}

static int my_confmute(void *pvt, int mute)
{
 struct dahdi_pvt *p = pvt;
 return dahdi_confmute(p, mute);
}

static void my_set_pulsedial(void *pvt, int flag)
{
 struct dahdi_pvt *p = pvt;
 p->pulsedial = flag;
}

static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
{
 struct dahdi_pvt *p = pvt;

 p->owner = new_owner;
}

static const char *my_get_orig_dialstring(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 return p->dialstring;
}

static void my_increase_ss_count(void)
{
 ast_mutex_lock(&ss_thread_lock);
 ss_thread_count++;
 ast_mutex_unlock(&ss_thread_lock);
}

static void my_decrease_ss_count(void)
{
 ast_mutex_lock(&ss_thread_lock);
 ss_thread_count--;
 ast_cond_signal(&ss_thread_complete);
 ast_mutex_unlock(&ss_thread_lock);
}

static void my_all_subchannels_hungup(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int res, law;

 p->faxhandled = 0;
 p->didtdd = 0;

 if (p->dsp) {
 ast_dsp_free(p->dsp);
 p->dsp = NULL;
 }

 p->law = p->law_default;
 law = p->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));

 dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);

#if 1
 {
 int i;
 p->owner = NULL;
 /* Cleanup owners here */
 for (i = 0; i < 3; i++) {
 p->subs[i].owner = NULL;
 }
 }
#endif

 reset_conf(p);
 if (num_restart_pending == 0) {
 restart_monitor();
 }
}

static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);

static int my_conf_del(void *pvt, enum analog_sub sub)
{
 struct dahdi_pvt *p = pvt;
 int x = analogsub_to_dahdisub(sub);

 return conf_del(p, &p->subs[x], x);
}

static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);

static int my_conf_add(void *pvt, enum analog_sub sub)
{
 struct dahdi_pvt *p = pvt;
 int x = analogsub_to_dahdisub(sub);

 return conf_add(p, &p->subs[x], x, 0);
}

static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);

static int my_complete_conference_update(void *pvt, int needconference)
{
 struct dahdi_pvt *p = pvt;
 int needconf = needconference;
 int x;
 int useslavenative;
 struct dahdi_pvt *slave = NULL;

 useslavenative = isslavenative(p, &slave);

 /* 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;
 }

 return 0;
}

static int check_for_conference(struct dahdi_pvt *p);

static int my_check_for_conference(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 return check_for_conference(p);
}

static void my_swap_subchannels(void *pvt, enum analog_sub a, struct ast_channel *ast_a, enum analog_sub b, struct ast_channel *ast_b)
{
 struct dahdi_pvt *p = pvt;
 int da, db;
 int tchan;
 int tinthreeway;

 da = analogsub_to_dahdisub(a);
 db = analogsub_to_dahdisub(b);

 tchan = p->subs[da].chan;
 p->subs[da].chan = p->subs[db].chan;
 p->subs[db].chan = tchan;

 tinthreeway = p->subs[da].inthreeway;
 p->subs[da].inthreeway = p->subs[db].inthreeway;
 p->subs[db].inthreeway = tinthreeway;

 p->subs[da].owner = ast_a;
 p->subs[db].owner = ast_b;

 if (ast_a)
 ast_channel_set_fd(ast_a, 0, p->subs[da].dfd);
 if (ast_b)
 ast_channel_set_fd(ast_b, 0, p->subs[db].dfd);

 wakeup_sub(p, a);
 wakeup_sub(p, b);

 return;
}

/*!
 * \internal
 * \brief performs duties of dahdi_new, but also removes and possibly unbinds (if callid_created is 1) before returning
 * \note this variant of dahdi should only be used in conjunction with ast_callid_threadstorage_auto()
 *
 * \param callid_created value returned from ast_callid_threadstorage_auto()
 */
static struct ast_channel *dahdi_new_callid_clean(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid, int callid_created);

static struct ast_channel *dahdi_new(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, ast_callid callid);

static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
{
 ast_callid callid = 0;
 int callid_created = ast_callid_threadstorage_auto(&callid);
 struct dahdi_pvt *p = pvt;
 int dsub = analogsub_to_dahdisub(sub);

 return dahdi_new_callid_clean(p, state, startpbx, dsub, 0, NULL, requestor, callid, callid_created);
}

#if defined(HAVE_PRI) || defined(HAVE_SS7)
static int dahdi_setlaw(int dfd, int law)
{
 int res;
 res = ioctl(dfd, DAHDI_SETLAW, &law);
 if (res)
 return res;
 return 0;
}
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#if defined(HAVE_PRI)
static struct ast_channel *my_new_pri_ast_channel(void *pvt, int state,
 enum sig_pri_law law, char *exten, const struct ast_assigned_ids *assignedids,
 const struct ast_channel *requestor)
{
 struct dahdi_pvt *p = pvt;
 int audio;
 int newlaw = -1;
 ast_callid callid = 0;
 int callid_created = ast_callid_threadstorage_auto(&callid);

 switch (p->sig) {
 case SIG_PRI_LIB_HANDLE_CASES:
 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
 /* PRI nobch pseudo channel. Does not handle ioctl(DAHDI_AUDIOMODE) */
 break;
 }
 /* Fall through */
 default:
 /* Set to audio mode at this point */
 audio = 1;
 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1) {
 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
 p->channel, audio, strerror(errno));
 }
 break;
 }

 if (law != SIG_PRI_DEFLAW) {
 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
 }

 ast_copy_string(p->exten, exten, sizeof(p->exten));

 switch (law) {
 case SIG_PRI_DEFLAW:
 newlaw = 0;
 break;
 case SIG_PRI_ALAW:
 newlaw = DAHDI_LAW_ALAW;
 break;
 case SIG_PRI_ULAW:
 newlaw = DAHDI_LAW_MULAW;
 break;
 }

 return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
}
#endif /* defined(HAVE_PRI) */

static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law);

#if defined(HAVE_PRI) || defined(HAVE_SS7)
/*!
 * \internal
 * \brief Open the PRI/SS7 channel media path.
 * \since 1.8
 *
 * \param p Channel private control structure.
 *
 * \return Nothing
 */
static void my_pri_ss7_open_media(void *p)
{
 struct dahdi_pvt *pvt = p;
 int res;
 int dfd;
 int set_val;

 dfd = pvt->subs[SUB_REAL].dfd;

 /* Open the media path. */
 set_val = 1;
 res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
 if (res < 0) {
 ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n",
 pvt->channel, strerror(errno));
 }

 /* Set correct companding law for this call. */
 res = dahdi_setlaw(dfd, pvt->law);
 if (res < 0) {
 ast_log(LOG_WARNING, "Unable to set law on channel %d\n", pvt->channel);
 }

 /* Set correct gain for this call. */
 if (pvt->digital) {
 res = set_actual_gain(dfd, 0, 0, pvt->rxdrc, pvt->txdrc, pvt->law);
 } else {
 res = set_actual_gain(dfd, pvt->rxgain, pvt->txgain, pvt->rxdrc, pvt->txdrc,
 pvt->law);
 }
 if (res < 0) {
 ast_log(LOG_WARNING, "Unable to set gains on channel %d\n", pvt->channel);
 }

 if (pvt->dsp_features && pvt->dsp) {
 ast_dsp_set_features(pvt->dsp, pvt->dsp_features);
 }
}
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Ask DAHDI to dial the given dial string.
 * \since 1.8.11
 *
 * \param p Channel private control structure.
 * \param dial_string String to pass to DAHDI to dial.
 *
 * \note The channel private lock needs to be held when calling.
 *
 * \return Nothing
 */
static void my_pri_dial_digits(void *p, const char *dial_string)
{
 char dial_str[DAHDI_MAX_DTMF_BUF];
 struct dahdi_pvt *pvt = p;
 int res;

 snprintf(dial_str, sizeof(dial_str), "T%s", dial_string);
 res = dahdi_dial_str(pvt, DAHDI_DIAL_OP_APPEND, dial_str);
 if (!res) {
 pvt->dialing = 1;
 }
}
#endif /* defined(HAVE_PRI) */

static int unalloc_sub(struct dahdi_pvt *p, int x);

static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
{
 struct dahdi_pvt *p = pvt;

 return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
}

static int alloc_sub(struct dahdi_pvt *p, int x);

static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
{
 struct dahdi_pvt *p = pvt;

 return alloc_sub(p, analogsub_to_dahdisub(analogsub));
}

static int has_voicemail(struct dahdi_pvt *p);

static int my_has_voicemail(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 return has_voicemail(p);
}

static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
{
 struct dahdi_pvt *p = pvt;
 int index;

 index = analogsub_to_dahdisub(sub);

 return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
}

static enum analog_event dahdievent_to_analogevent(int event)
{
 enum analog_event res;

 switch (event) {
 case DAHDI_EVENT_ONHOOK:
 res = ANALOG_EVENT_ONHOOK;
 break;
 case DAHDI_EVENT_RINGOFFHOOK:
 res = ANALOG_EVENT_RINGOFFHOOK;
 break;
 case DAHDI_EVENT_WINKFLASH:
 res = ANALOG_EVENT_WINKFLASH;
 break;
 case DAHDI_EVENT_ALARM:
 res = ANALOG_EVENT_ALARM;
 break;
 case DAHDI_EVENT_NOALARM:
 res = ANALOG_EVENT_NOALARM;
 break;
 case DAHDI_EVENT_DIALCOMPLETE:
 res = ANALOG_EVENT_DIALCOMPLETE;
 break;
 case DAHDI_EVENT_RINGERON:
 res = ANALOG_EVENT_RINGERON;
 break;
 case DAHDI_EVENT_RINGEROFF:
 res = ANALOG_EVENT_RINGEROFF;
 break;
 case DAHDI_EVENT_HOOKCOMPLETE:
 res = ANALOG_EVENT_HOOKCOMPLETE;
 break;
 case DAHDI_EVENT_PULSE_START:
 res = ANALOG_EVENT_PULSE_START;
 break;
 case DAHDI_EVENT_POLARITY:
 res = ANALOG_EVENT_POLARITY;
 break;
 case DAHDI_EVENT_RINGBEGIN:
 res = ANALOG_EVENT_RINGBEGIN;
 break;
 case DAHDI_EVENT_EC_DISABLED:
 res = ANALOG_EVENT_EC_DISABLED;
 break;
 case DAHDI_EVENT_REMOVED:
 res = ANALOG_EVENT_REMOVED;
 break;
 case DAHDI_EVENT_NEONMWI_ACTIVE:
 res = ANALOG_EVENT_NEONMWI_ACTIVE;
 break;
 case DAHDI_EVENT_NEONMWI_INACTIVE:
 res = ANALOG_EVENT_NEONMWI_INACTIVE;
 break;
#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
 case DAHDI_EVENT_TX_CED_DETECTED:
 res = ANALOG_EVENT_TX_CED_DETECTED;
 break;
 case DAHDI_EVENT_RX_CED_DETECTED:
 res = ANALOG_EVENT_RX_CED_DETECTED;
 break;
 case DAHDI_EVENT_EC_NLP_DISABLED:
 res = ANALOG_EVENT_EC_NLP_DISABLED;
 break;
 case DAHDI_EVENT_EC_NLP_ENABLED:
 res = ANALOG_EVENT_EC_NLP_ENABLED;
 break;
#endif
 case DAHDI_EVENT_PULSEDIGIT:
 res = ANALOG_EVENT_PULSEDIGIT;
 break;
 case DAHDI_EVENT_DTMFDOWN:
 res = ANALOG_EVENT_DTMFDOWN;
 break;
 case DAHDI_EVENT_DTMFUP:
 res = ANALOG_EVENT_DTMFUP;
 break;
 default:
 switch(event & 0xFFFF0000) {
 case DAHDI_EVENT_PULSEDIGIT:
 case DAHDI_EVENT_DTMFDOWN:
 case DAHDI_EVENT_DTMFUP:
 /* The event includes a digit number in the low word.
 * Converting it to a 'enum analog_event' would remove
 * that information. Thus it is returned as-is.
 */
 return event;
 }

 res = ANALOG_EVENT_ERROR;
 break;
 }

 return res;
}

static inline int dahdi_wait_event(int fd);

static int my_wait_event(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 return dahdi_wait_event(p->subs[SUB_REAL].dfd);
}

static int my_get_event(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int res;

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

 return dahdievent_to_analogevent(res);
}

static int my_is_off_hook(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int res;
 struct dahdi_params par;

 memset(&par, 0, sizeof(par));

 if (p->subs[SUB_REAL].dfd > -1)
 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
 else {
 /* Assume not off hook on CVRS */
 res = 0;
 par.rxisoffhook = 0;
 }
 if (res) {
 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
 }

 if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
 /* When "onhook" that means no battery on the line, and thus
 it is out of service..., if it's on a TDM card... If it's a channel
 bank, there is no telling... */
 return (par.rxbits > -1) || par.rxisoffhook;
 }

 return par.rxisoffhook;
}

static int my_set_echocanceller(void *pvt, int enable)
{
 struct dahdi_pvt *p = pvt;

 if (enable)
 dahdi_ec_enable(p);
 else
 dahdi_ec_disable(p);

 return 0;
}

static int dahdi_ring_phone(struct dahdi_pvt *p);

static int my_ring(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 return dahdi_ring_phone(p);
}

static int my_flash(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int func = DAHDI_FLASH;
 return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
}

static inline int dahdi_set_hook(int fd, int hs);

static int my_off_hook(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
}

static void my_set_needringing(void *pvt, int value)
{
 struct dahdi_pvt *p = pvt;
 p->subs[SUB_REAL].needringing = value;
}

static void my_set_polarity(void *pvt, int value)
{
 struct dahdi_pvt *p = pvt;

 if (p->channel == CHAN_PSEUDO) {
 return;
 }
 p->polarity = value;
 ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETPOLARITY, &value);
}

static void my_start_polarityswitch(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 if (p->answeronpolarityswitch || p->hanguponpolarityswitch) {
 my_set_polarity(pvt, 0);
 }
}

static void my_answer_polarityswitch(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 if (!p->answeronpolarityswitch) {
 return;
 }

 my_set_polarity(pvt, 1);
}

static void my_hangup_polarityswitch(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 if (!p->hanguponpolarityswitch) {
 return;
 }

 if (p->answeronpolarityswitch) {
 my_set_polarity(pvt, 0);
 } else {
 my_set_polarity(pvt, 1);
 }
}

static int my_start(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 int x = DAHDI_START;

 return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
}

static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
{
 struct dahdi_pvt *p = pvt;

 if (dop->op != ANALOG_DIAL_OP_REPLACE) {
 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
 return -1;
 }

 if (sub != ANALOG_SUB_REAL) {
 ast_log(LOG_ERROR, "Trying to dial_digits '%s' on channel %d subchannel %u\n",
 dop->dialstr, p->channel, sub);
 return -1;
 }

 return dahdi_dial_str(p, DAHDI_DIAL_OP_REPLACE, dop->dialstr);
}

static void dahdi_train_ec(struct dahdi_pvt *p);

static int my_train_echocanceller(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 dahdi_train_ec(p);

 return 0;
}

static int my_is_dialing(void *pvt, enum analog_sub sub)
{
 struct dahdi_pvt *p = pvt;
 int index;
 int x;

 index = analogsub_to_dahdisub(sub);

 if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
 ast_debug(1, "DAHDI_DIALING ioctl failed!\n");
 return -1;
 }

 return x;
}

static int my_on_hook(void *pvt)
{
 struct dahdi_pvt *p = pvt;
 return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
}

#if defined(HAVE_PRI)
static void my_pri_fixup_chans(void *chan_old, void *chan_new)
{
 struct dahdi_pvt *old_chan = chan_old;
 struct dahdi_pvt *new_chan = chan_new;

 new_chan->owner = old_chan->owner;
 old_chan->owner = NULL;
 if (new_chan->owner) {
 ast_channel_tech_pvt_set(new_chan->owner, new_chan);
 ast_channel_internal_fd_set(new_chan->owner, 0, new_chan->subs[SUB_REAL].dfd);
 new_chan->subs[SUB_REAL].owner = old_chan->subs[SUB_REAL].owner;
 old_chan->subs[SUB_REAL].owner = NULL;
 }
 /* Copy any DSP that may be present */
 new_chan->dsp = old_chan->dsp;
 new_chan->dsp_features = old_chan->dsp_features;
 old_chan->dsp = NULL;
 old_chan->dsp_features = 0;

 /* Transfer flags from the old channel. */
 new_chan->dialing = old_chan->dialing;
 new_chan->digital = old_chan->digital;
 new_chan->outgoing = old_chan->outgoing;
 old_chan->dialing = 0;
 old_chan->digital = 0;
 old_chan->outgoing = 0;

 /* More stuff to transfer to the new channel. */
 new_chan->law = old_chan->law;
 strcpy(new_chan->dialstring, old_chan->dialstring);
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
{
 switch (tone) {
 case SIG_PRI_TONE_RINGTONE:
 return DAHDI_TONE_RINGTONE;
 case SIG_PRI_TONE_STUTTER:
 return DAHDI_TONE_STUTTER;
 case SIG_PRI_TONE_CONGESTION:
 return DAHDI_TONE_CONGESTION;
 case SIG_PRI_TONE_DIALTONE:
 return DAHDI_TONE_DIALTONE;
 case SIG_PRI_TONE_DIALRECALL:
 return DAHDI_TONE_DIALRECALL;
 case SIG_PRI_TONE_INFO:
 return DAHDI_TONE_INFO;
 case SIG_PRI_TONE_BUSY:
 return DAHDI_TONE_BUSY;
 default:
 return -1;
 }
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
static void my_handle_dchan_exception(struct sig_pri_span *pri, int index)
{
 int x;

 ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
 switch (x) {
 case DAHDI_EVENT_NONE:
 break;
 case DAHDI_EVENT_ALARM:
 case DAHDI_EVENT_NOALARM:
 if (sig_pri_is_alarm_ignored(pri)) {
 break;
 }
 /* Fall through */
 default:
 ast_log(LOG_NOTICE, "Got DAHDI event: %s (%d) on D-channel of span %d\n",
 event2str(x), x, pri->span);
 break;
 }
 /* Keep track of alarm state */
 switch (x) {
 case DAHDI_EVENT_ALARM:
 pri_event_alarm(pri, index, 0);
 break;
 case DAHDI_EVENT_NOALARM:
 pri_event_noalarm(pri, index, 0);
 break;
 case DAHDI_EVENT_REMOVED:
 pri_queue_for_destruction(pri);
 break;
 default:
 break;
 }
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
{
 struct dahdi_pvt *p = pvt;

 return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI) || defined(HAVE_SS7)
/*!
 * \internal
 * \brief Set the caller id information.
 * \since 1.8
 *
 * \param pvt DAHDI private structure
 * \param caller Caller-id information to set.
 *
 * \return Nothing
 */
static void my_set_callerid(void *pvt, const struct ast_party_caller *caller)
{
 struct dahdi_pvt *p = pvt;

 ast_copy_string(p->cid_num,
 S_COR(caller->id.number.valid, caller->id.number.str, ""),
 sizeof(p->cid_num));
 ast_copy_string(p->cid_name,
 S_COR(caller->id.name.valid, caller->id.name.str, ""),
 sizeof(p->cid_name));
 ast_copy_string(p->cid_subaddr,
 S_COR(caller->id.subaddress.valid, caller->id.subaddress.str, ""),
 sizeof(p->cid_subaddr));
 p->cid_ton = caller->id.number.plan;
 p->callingpres = ast_party_id_presentation(&caller->id);
 if (caller->id.tag) {
 ast_copy_string(p->cid_tag, caller->id.tag, sizeof(p->cid_tag));
 }
 ast_copy_string(p->cid_ani,
 S_COR(caller->ani.number.valid, caller->ani.number.str, ""),
 sizeof(p->cid_ani));
 p->cid_ani2 = caller->ani2;
}
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#if defined(HAVE_PRI) || defined(HAVE_SS7)
/*!
 * \internal
 * \brief Set the Dialed Number Identifier.
 * \since 1.8
 *
 * \param pvt DAHDI private structure
 * \param dnid Dialed Number Identifier string.
 *
 * \return Nothing
 */
static void my_set_dnid(void *pvt, const char *dnid)
{
 struct dahdi_pvt *p = pvt;

 ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
}
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Set the Redirecting Directory Number Information Service (RDNIS).
 * \since 1.8
 *
 * \param pvt DAHDI private structure
 * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
 *
 * \return Nothing
 */
static void my_set_rdnis(void *pvt, const char *rdnis)
{
 struct dahdi_pvt *p = pvt;

 ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Make a dialstring for native ISDN CC to recall properly.
 * \since 1.8
 *
 * \param priv Channel private control structure.
 * \param buf Where to put the modified dialstring.
 * \param buf_size Size of modified dialstring buffer.
 *
 * \details
 * original dialstring:
 * DAHDI/[i<span>-](g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
 *
 * The modified dialstring will have prefixed the channel-group section
 * with the ISDN channel restriction.
 *
 * buf:
 * DAHDI/i<span>-(g|G|r|R)<group#(0-63)>[c|r<cadance#>|d][/extension[/options]]
 *
 * The routine will check to see if the ISDN channel restriction is already
 * in the original dialstring.
 *
 * \return Nothing
 */
static void my_pri_make_cc_dialstring(void *priv, char *buf, size_t buf_size)
{
 char *dial;
 struct dahdi_pvt *pvt;
 AST_DECLARE_APP_ARGS(args,
 AST_APP_ARG(tech); /* channel technology token */
 AST_APP_ARG(group); /* channel/group token */
 //AST_APP_ARG(ext); /* extension token */
 //AST_APP_ARG(opts); /* options token */
 //AST_APP_ARG(other); /* Any remining unused arguments */
 );

 pvt = priv;
 dial = ast_strdupa(pvt->dialstring);
 AST_NONSTANDARD_APP_ARGS(args, dial, '/');
 if (!args.tech) {
 ast_copy_string(buf, pvt->dialstring, buf_size);
 return;
 }
 if (!args.group) {
 /* Append the ISDN span channel restriction to the dialstring. */
 snprintf(buf, buf_size, "%s/i%d-", args.tech, pvt->pri->span);
 return;
 }
 if (isdigit(args.group[0]) || args.group[0] == 'i' || strchr(args.group, '!')) {
 /* The ISDN span channel restriction is not needed or already
 * in the dialstring. */
 ast_copy_string(buf, pvt->dialstring, buf_size);
 return;
 }
 /* Insert the ISDN span channel restriction into the dialstring. */
 snprintf(buf, buf_size, "%s/i%d-%s", args.tech, pvt->pri->span, args.group);
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Reevaluate the PRI span device state.
 * \since 1.8
 *
 * \param pri Asterisk D channel control structure.
 *
 * \return Nothing
 *
 * \note Assumes the pri->lock is already obtained.
 */
static void dahdi_pri_update_span_devstate(struct sig_pri_span *pri)
{
 unsigned idx;
 unsigned num_b_chans; /* Number of B channels provisioned on the span. */
 unsigned in_use; /* Number of B channels in use on the span. */
 unsigned in_alarm; /* TRUE if the span is in alarm condition. */
 enum ast_device_state new_state;

 /* Count the number of B channels and the number of B channels in use. */
 num_b_chans = 0;
 in_use = 0;
 in_alarm = 1;
 for (idx = pri->numchans; idx--;) {
 if (pri->pvts[idx] && !pri->pvts[idx]->no_b_channel) {
 /* This is a B channel interface. */
 ++num_b_chans;
 if (!sig_pri_is_chan_available(pri->pvts[idx])) {
 ++in_use;
 }
 if (!pri->pvts[idx]->inalarm) {
 /* There is a channel that is not in alarm. */
 in_alarm = 0;
 }
 }
 }

 /* Update the span congestion device state and report any change. */
 if (in_alarm) {
 new_state = AST_DEVICE_UNAVAILABLE;
 } else {
 new_state = num_b_chans == in_use ? AST_DEVICE_BUSY : AST_DEVICE_NOT_INUSE;
 }
 if (pri->congestion_devstate != new_state) {
 pri->congestion_devstate = new_state;
 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/congestion", pri->span);
 }
#if defined(THRESHOLD_DEVSTATE_PLACEHOLDER)
 /* Update the span threshold device state and report any change. */
 if (in_alarm) {
 new_state = AST_DEVICE_UNAVAILABLE;
 } else if (!in_use) {
 new_state = AST_DEVICE_NOT_INUSE;
 } else if (!pri->user_busy_threshold) {
 new_state = in_use < num_b_chans ? AST_DEVICE_INUSE : AST_DEVICE_BUSY;
 } else {
 new_state = in_use < pri->user_busy_threshold ? AST_DEVICE_INUSE
 : AST_DEVICE_BUSY;
 }
 if (pri->threshold_devstate != new_state) {
 pri->threshold_devstate = new_state;
 ast_devstate_changed(AST_DEVICE_UNKNOWN, AST_DEVSTATE_NOT_CACHABLE, "DAHDI/I%d/threshold", pri->span);
 }
#endif /* defined(THRESHOLD_DEVSTATE_PLACEHOLDER) */
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Reference this module.
 * \since 1.8
 *
 * \return Nothing
 */
static void my_module_ref(void)
{
 ast_module_ref(ast_module_info->self);
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Unreference this module.
 * \since 1.8
 *
 * \return Nothing
 */
static void my_module_unref(void)
{
 ast_module_unref(ast_module_info->self);
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
#if defined(HAVE_PRI_CALL_WAITING)
static void my_pri_init_config(void *priv, struct sig_pri_span *pri);
#endif /* defined(HAVE_PRI_CALL_WAITING) */
static int dahdi_new_pri_nobch_channel(struct sig_pri_span *pri);

struct sig_pri_callback sig_pri_callbacks =
{
 .handle_dchan_exception = my_handle_dchan_exception,
 .play_tone = my_pri_play_tone,
 .set_echocanceller = my_set_echocanceller,
 .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
 .lock_private = my_lock_private,
 .unlock_private = my_unlock_private,
 .deadlock_avoidance_private = my_deadlock_avoidance_private,
 .new_ast_channel = my_new_pri_ast_channel,
 .fixup_chans = my_pri_fixup_chans,
 .set_alarm = my_set_alarm,
 .set_dialing = my_set_dialing,
 .set_outgoing = my_set_outgoing,
 .set_digital = my_set_digital,
 .set_callerid = my_set_callerid,
 .set_dnid = my_set_dnid,
 .set_rdnis = my_set_rdnis,
 .new_nobch_intf = dahdi_new_pri_nobch_channel,
#if defined(HAVE_PRI_CALL_WAITING)
 .init_config = my_pri_init_config,
#endif /* defined(HAVE_PRI_CALL_WAITING) */
 .get_orig_dialstring = my_get_orig_dialstring,
 .make_cc_dialstring = my_pri_make_cc_dialstring,
 .update_span_devstate = dahdi_pri_update_span_devstate,
 .module_ref = my_module_ref,
 .module_unref = my_module_unref,
 .dial_digits = my_pri_dial_digits,
 .open_media = my_pri_ss7_open_media,
 .ami_channel_event = my_ami_channel_event,
 .destroy_later = pri_queue_for_destruction,
};
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_SS7)
/*!
 * \internal
 * \brief Handle the SS7 link exception.
 * \since 1.8
 *
 * \param linkset Controlling linkset for the channel.
 * \param which Link index of the signaling channel.
 *
 * \return Nothing
 */
static void my_handle_link_exception(struct sig_ss7_linkset *linkset, int which)
{
 int event;

 if (ioctl(linkset->fds[which], DAHDI_GETEVENT, &event)) {
 ast_log(LOG_ERROR, "SS7: Error in exception retrieval on span %d/%d!\n",
 linkset->span, which);
 return;
 }
 switch (event) {
 case DAHDI_EVENT_NONE:
 break;
 case DAHDI_EVENT_ALARM:
 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
 event2str(event), event, linkset->span, which);
 sig_ss7_link_alarm(linkset, which);
 break;
 case DAHDI_EVENT_NOALARM:
 ast_log(LOG_ERROR, "SS7 got event: %s(%d) on span %d/%d\n",
 event2str(event), event, linkset->span, which);
 sig_ss7_link_noalarm(linkset, which);
 break;
 default:
 ast_log(LOG_NOTICE, "SS7 got event: %s(%d) on span %d/%d\n",
 event2str(event), event, linkset->span, which);
 break;
 }
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static void my_ss7_set_loopback(void *pvt, int enable)
{
 struct dahdi_pvt *p = pvt;

 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_LOOPBACK, &enable)) {
 ast_log(LOG_WARNING, "Unable to set loopback on channel %d: %s\n", p->channel,
 strerror(errno));
 }
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
/*!
 * \internal
 * \brief Find the linkset to which SS7 belongs.
 * \since 11.0
 *
 * \param ss7 structure to match on.
 *
 * \retval linkset if found.
 * \retval NULL if not found.
 */
static struct sig_ss7_linkset *my_ss7_find_linkset(struct ss7 *ss7)
{
 int idx;

 if (!ss7) {
 return NULL;
 }

 for (idx = 0; idx < NUM_SPANS; ++idx) {
 if (linksets[idx].ss7.ss7 == ss7) {
 return &linksets[idx].ss7;
 }
 }
 return NULL;
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
/*!
 * \internal
 * \brief Create a new asterisk channel structure for SS7.
 * \since 1.8
 *
 * \param pvt Private channel structure.
 * \param state Initial state of new channel.
 * \param law Combanding law to use.
 * \param exten Dialplan extension for incoming call.
 * \param requestor Channel requesting this new channel.
 *
 * \retval ast_channel on success.
 * \retval NULL on error.
 */
static struct ast_channel *my_new_ss7_ast_channel(void *pvt, int state, enum sig_ss7_law law, char *exten, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor)
{
 struct dahdi_pvt *p = pvt;
 int audio;
 int newlaw;
 ast_callid callid = 0;
 int callid_created = ast_callid_threadstorage_auto(&callid);

 /* Set to audio mode at this point */
 audio = 1;
 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1)
 ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
 p->channel, audio, strerror(errno));

 if (law != SIG_SS7_DEFLAW) {
 dahdi_setlaw(p->subs[SUB_REAL].dfd,
 (law == SIG_SS7_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
 }

 ast_copy_string(p->exten, exten, sizeof(p->exten));

 newlaw = -1;
 switch (law) {
 case SIG_SS7_DEFLAW:
 newlaw = 0;
 break;
 case SIG_SS7_ALAW:
 newlaw = DAHDI_LAW_ALAW;
 break;
 case SIG_SS7_ULAW:
 newlaw = DAHDI_LAW_MULAW;
 break;
 }
 return dahdi_new_callid_clean(p, state, 0, SUB_REAL, newlaw, assignedids, requestor, callid, callid_created);
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static int sig_ss7_tone_to_dahditone(enum sig_ss7_tone tone)
{
 switch (tone) {
 case SIG_SS7_TONE_RINGTONE:
 return DAHDI_TONE_RINGTONE;
 case SIG_SS7_TONE_STUTTER:
 return DAHDI_TONE_STUTTER;
 case SIG_SS7_TONE_CONGESTION:
 return DAHDI_TONE_CONGESTION;
 case SIG_SS7_TONE_DIALTONE:
 return DAHDI_TONE_DIALTONE;
 case SIG_SS7_TONE_DIALRECALL:
 return DAHDI_TONE_DIALRECALL;
 case SIG_SS7_TONE_INFO:
 return DAHDI_TONE_INFO;
 case SIG_SS7_TONE_BUSY:
 return DAHDI_TONE_BUSY;
 default:
 return -1;
 }
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static int my_ss7_play_tone(void *pvt, enum sig_ss7_tone tone)
{
 struct dahdi_pvt *p = pvt;

 return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_ss7_tone_to_dahditone(tone));
}
#endif /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
struct sig_ss7_callback sig_ss7_callbacks =
{
 .lock_private = my_lock_private,
 .unlock_private = my_unlock_private,
 .deadlock_avoidance_private = my_deadlock_avoidance_private,

 .set_echocanceller = my_set_echocanceller,
 .set_loopback = my_ss7_set_loopback,

 .new_ast_channel = my_new_ss7_ast_channel,
 .play_tone = my_ss7_play_tone,

 .handle_link_exception = my_handle_link_exception,
 .set_alarm = my_set_alarm,
 .set_dialing = my_set_dialing,
 .set_outgoing = my_set_outgoing,
 .set_digital = my_set_digital,
 .set_inservice = my_set_inservice,
 .set_locallyblocked = my_set_locallyblocked,
 .set_remotelyblocked = my_set_remotelyblocked,
 .set_callerid = my_set_callerid,
 .set_dnid = my_set_dnid,
 .open_media = my_pri_ss7_open_media,
 .find_linkset = my_ss7_find_linkset,
};
#endif /* defined(HAVE_SS7) */

/*!
 * \brief Send MWI state change
 *
 * \param mailbox This is the mailbox associated with the FXO line that the
 * MWI state has changed on.
 * \param thereornot This argument should simply be set to 1 or 0, to indicate
 * whether there are messages waiting or not.
 *
 * \return nothing
 *
 * This function does two things:
 *
 * 1) It generates an internal Asterisk event notifying any other module that
 * cares about MWI that the state of a mailbox has changed.
 *
 * 2) It runs the script specified by the mwimonitornotify option to allow
 * some custom handling of the state change.
 */
static void notify_message(char *mailbox, int thereornot)
{
 char s[sizeof(mwimonitornotify) + 80];

 if (ast_strlen_zero(mailbox)) {
 return;
 }

 ast_publish_mwi_state(mailbox, NULL, thereornot, thereornot);
 if (!ast_strlen_zero(mwimonitornotify)) {
 snprintf(s, sizeof(s), "%s %s %d", mwimonitornotify, mailbox, thereornot);
 ast_safe_system(s);
 }
}

static void my_handle_notify_message(struct ast_channel *chan, void *pvt, int cid_flags, int neon_mwievent)
{
 struct dahdi_pvt *p = pvt;

 if (neon_mwievent > -1 && !p->mwimonitor_neon)
 return;

 if (neon_mwievent == ANALOG_EVENT_NEONMWI_ACTIVE || cid_flags & CID_MSGWAITING) {
 ast_log(LOG_NOTICE, "MWI: Channel %d message waiting, mailbox %s\n", p->channel, p->mailbox);
 notify_message(p->mailbox, 1);
 } else if (neon_mwievent == ANALOG_EVENT_NEONMWI_INACTIVE || cid_flags & CID_NOMSGWAITING) {
 ast_log(LOG_NOTICE, "MWI: Channel %d no message waiting, mailbox %s\n", p->channel, p->mailbox);
 notify_message(p->mailbox, 0);
 }
 /* If the CID had Message waiting payload, assume that this for MWI only and hangup the call */
 /* If generated using Ring Pulse Alert, then ring has been answered as a call and needs to be hungup */
 if (neon_mwievent == -1 && p->mwimonitor_rpas) {
 ast_hangup(chan);
 return;
 }
}

static int my_have_progressdetect(void *pvt)
{
 struct dahdi_pvt *p = pvt;

 if ((p->callprogress & CALLPROGRESS_PROGRESS)
 && CANPROGRESSDETECT(p) && p->dsp && p->outgoing) {
 return 1;
 } else {
 /* Don't have progress detection. */
 return 0;
 }
}

#define gen_pvt_field_callback(type, field) \
 static type my_get_##field(void *pvt) \
 { \
 struct dahdi_pvt *p = pvt; \
 return p->field; \
 }

gen_pvt_field_callback(int, firstdigit_timeout);
gen_pvt_field_callback(int, interdigit_timeout);
gen_pvt_field_callback(int, matchdigit_timeout);

#undef gen_pvt_field_callback

struct analog_callback analog_callbacks =
{
 .play_tone = my_play_tone,
 .get_event = my_get_event,
 .wait_event = my_wait_event,
 .is_off_hook = my_is_off_hook,
 .set_echocanceller = my_set_echocanceller,
 .ring = my_ring,
 .flash = my_flash,
 .off_hook = my_off_hook,
 .dial_digits = my_dial_digits,
 .train_echocanceller = my_train_echocanceller,
 .on_hook = my_on_hook,
 .is_dialing = my_is_dialing,
 .allocate_sub = my_allocate_sub,
 .unallocate_sub = my_unallocate_sub,
 .swap_subs = my_swap_subchannels,
 .has_voicemail = my_has_voicemail,
 .check_for_conference = my_check_for_conference,
 .conf_add = my_conf_add,
 .conf_del = my_conf_del,
 .complete_conference_update = my_complete_conference_update,
 .start = my_start,
 .all_subchannels_hungup = my_all_subchannels_hungup,
 .lock_private = my_lock_private,
 .unlock_private = my_unlock_private,
 .deadlock_avoidance_private = my_deadlock_avoidance_private,
 .handle_dtmf = my_handle_dtmf,
 .wink = my_wink,
 .new_ast_channel = my_new_analog_ast_channel,
 .dsp_set_digitmode = my_dsp_set_digitmode,
 .dsp_reset_and_flush_digits = my_dsp_reset_and_flush_digits,
 .send_callerid = my_send_callerid,
 .callwait = my_callwait,
 .stop_callwait = my_stop_callwait,
 .get_callerid = my_get_callerid,
 .start_cid_detect = my_start_cid_detect,
 .stop_cid_detect = my_stop_cid_detect,
 .handle_notify_message = my_handle_notify_message,
 .increase_ss_count = my_increase_ss_count,
 .decrease_ss_count = my_decrease_ss_count,
 .distinctive_ring = my_distinctive_ring,
 .set_linear_mode = my_set_linear_mode,
 .set_inthreeway = my_set_inthreeway,
 .get_and_handle_alarms = my_get_and_handle_alarms,
 .get_sigpvt_bridged_channel = my_get_sigpvt_bridged_channel,
 .get_sub_fd = my_get_sub_fd,
 .set_cadence = my_set_cadence,
 .set_alarm = my_set_alarm,
 .set_dialing = my_set_dialing,
 .set_outgoing = my_set_outgoing,
 .set_ringtimeout = my_set_ringtimeout,
 .set_waitingfordt = my_set_waitingfordt,
 .check_waitingfordt = my_check_waitingfordt,
 .set_confirmanswer = my_set_confirmanswer,
 .check_confirmanswer = my_check_confirmanswer,
 .set_callwaiting = my_set_callwaiting,
 .cancel_cidspill = my_cancel_cidspill,
 .confmute = my_confmute,
 .set_pulsedial = my_set_pulsedial,
 .set_new_owner = my_set_new_owner,
 .get_orig_dialstring = my_get_orig_dialstring,
 .set_needringing = my_set_needringing,
 .set_polarity = my_set_polarity,
 .start_polarityswitch = my_start_polarityswitch,
 .answer_polarityswitch = my_answer_polarityswitch,
 .hangup_polarityswitch = my_hangup_polarityswitch,
 .have_progressdetect = my_have_progressdetect,
 .get_firstdigit_timeout = my_get_firstdigit_timeout,
 .get_matchdigit_timeout = my_get_matchdigit_timeout,
 .get_interdigit_timeout = my_get_interdigit_timeout,
};

/*! Round robin search locations. */
static struct dahdi_pvt *round_robin[32];

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_channel_name(ast) : "", 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_channel_trylock(pvt->subs[sub_idx].owner)) {
 /* 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)
{
 dahdi_lock_sub_owner(p, a);
 if (p->subs[a].owner) {
 ast_queue_frame(p->subs[a].owner, &ast_null_frame);
 ast_channel_unlock(p->subs[a].owner);
 }
}

static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f)
{
 for (;;) {
 if (p->owner) {
 if (ast_channel_trylock(p->owner)) {
 DEADLOCK_AVOIDANCE(&p->lock);
 } else {
 ast_queue_frame(p->owner, f);
 ast_channel_unlock(p->owner);
 break;
 }
 } else
 break;
 }
}

static void publish_channel_alarm_clear(int channel)
{
 RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
 RAII_VAR(struct ast_str *, dahdi_chan, ast_str_create(32), ast_free);
 if (!dahdi_chan) {
 return;
 }

 ast_str_set(&dahdi_chan, 0, "%d", channel);
 ast_log(LOG_NOTICE, "Alarm cleared on channel DAHDI/%d\n", channel);
 body = ast_json_pack("{s: s}", "DAHDIChannel", ast_str_buffer(dahdi_chan));
 if (!body) {
 return;
 }

 ast_manager_publish_event("AlarmClear", EVENT_FLAG_SYSTEM, body);
}

static void publish_span_alarm_clear(int span)
{
 RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);

 ast_log(LOG_NOTICE, "Alarm cleared on span %d\n", span);
 body = ast_json_pack("{s: i}", "Span", span);
 if (!body) {
 return;
 }

 ast_manager_publish_event("SpanAlarmClear", EVENT_FLAG_SYSTEM, body);
}

static void handle_clear_alarms(struct dahdi_pvt *p)
{
#if defined(HAVE_PRI)
 if (dahdi_sig_pri_lib_handles(p->sig) && sig_pri_is_alarm_ignored(p->pri)) {
 return;
 }
#endif /* defined(HAVE_PRI) */

 if (report_alarms & REPORT_CHANNEL_ALARMS) {
 publish_channel_alarm_clear(p->channel);
 }
 if (report_alarms & REPORT_SPAN_ALARMS && p->manages_span_alarms) {
 publish_span_alarm_clear(p->span);
 }
}

#ifdef HAVE_OPENR2
static void mfcr2_queue_for_destruction(const struct dahdi_pvt *p)
{
 const struct dahdi_mfcr2 *r2link = p->mfcr2;
 struct r2link_entry *cur;
 AST_LIST_LOCK(&r2links);
 AST_LIST_TRAVERSE_SAFE_BEGIN(&r2links, cur, list) {
 if (r2link == &cur->mfcr2) {
 ast_debug(3, "MFC/R2 channel %d queued for destruction\n", p->channel);
 AST_LIST_MOVE_CURRENT(&nodev_r2links, list);
 break;
 }
 }
 AST_LIST_TRAVERSE_SAFE_END;
 AST_LIST_UNLOCK(&r2links);
}

static int dahdi_r2_answer(struct dahdi_pvt *p)
{
 int res = 0;
 /* openr2 1.1.0 and older does not even define OR2_LIB_INTERFACE
 * and does not has support for openr2_chan_answer_call_with_mode
 * */
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
 const char *double_answer = pbx_builtin_getvar_helper(p->owner, "MFCR2_DOUBLE_ANSWER");
 int wants_double_answer = ast_true(double_answer) ? 1 : 0;
 if (!double_answer) {
 /* this still can result in double answer if the channel context
 * was configured that way */
 res = openr2_chan_answer_call(p->r2chan);
 } else if (wants_double_answer) {
 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_DOUBLE);
 } else {
 res = openr2_chan_answer_call_with_mode(p->r2chan, OR2_ANSWER_SIMPLE);
 }
#else
 res = openr2_chan_answer_call(p->r2chan);
#endif
 return res;
}



/* should be called with the ast_channel locked */
static openr2_calling_party_category_t dahdi_r2_get_channel_category(struct ast_channel *c)
{
 openr2_calling_party_category_t cat;
 const char *catstr = pbx_builtin_getvar_helper(c, "MFCR2_CATEGORY");
 struct dahdi_pvt *p = ast_channel_tech_pvt(c);
 if (ast_strlen_zero(catstr)) {
 ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
 ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
 return p->mfcr2_category;
 }
 if ((cat = openr2_proto_get_category(catstr)) == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) {
 ast_log(LOG_WARNING, "Invalid category specified '%s' for chan %s, using default %s\n",
 catstr, ast_channel_name(c), openr2_proto_get_category_string(p->mfcr2_category));
 return p->mfcr2_category;
 }
 ast_debug(1, "Using category %s\n", catstr);
 return cat;
}

static void dahdi_r2_on_call_init(openr2_chan_t *r2chan)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_mutex_lock(&p->lock);
 if (p->mfcr2call) {
 ast_mutex_unlock(&p->lock);
 /* TODO: This can happen when some other thread just finished dahdi_request requesting this very same
 interface but has not yet seized the line (dahdi_call), and the far end wins and seize the line,
 can we avoid this somehow?, at this point when dahdi_call send the seize, it is likely that since
 the other end will see our seize as a forced release and drop the call, we will see an invalid
 pattern that will be seen and treated as protocol error. */
 ast_log(LOG_ERROR, "Collision of calls on chan %d detected!.\n", openr2_chan_get_number(r2chan));
 return;
 }
 p->mfcr2call = 1;
 /* better safe than sorry ... */
 p->cid_name[0] = '\0';
 p->cid_num[0] = '\0';
 p->cid_subaddr[0] = '\0';
 p->rdnis[0] = '\0';
 p->exten[0] = '\0';
 p->mfcr2_ani_index = '\0';
 p->mfcr2_dnis_index = '\0';
 p->mfcr2_dnis_matched = 0;
 p->mfcr2_answer_pending = 0;
 p->mfcr2_call_accepted = 0;
 ast_mutex_unlock(&p->lock);
 ast_verbose("New MFC/R2 call detected on chan %d.\n", openr2_chan_get_number(r2chan));
}

static void dahdi_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm)
{
 int res;
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_mutex_lock(&p->lock);
 p->inalarm = alarm ? 1 : 0;
 if (p->inalarm) {
 res = get_alarms(p);
 if (res == DAHDI_ALARM_NOTOPEN) {
 mfcr2_queue_for_destruction(p);
 }
 handle_alarms(p, res);
 } else {
 handle_clear_alarms(p);
 }
 ast_mutex_unlock(&p->lock);
}

static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);

 ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
 ast_mutex_lock(&p->lock);
 /* Disconnected? */
 if (errorcode == ENODEV) {
 struct dahdi_mfcr2 *r2link = p->mfcr2;
 p->mfcr2call = 0;
 if (r2link) {
 r2link->nodev = 1;
 }
 }
 ast_mutex_unlock(&p->lock);
}

static void dahdi_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_log(LOG_ERROR, "MFC/R2 protocol error on chan %d: %s\n", openr2_chan_get_number(r2chan), openr2_proto_get_error(reason));
 if (p->owner) {
 ast_channel_hangupcause_set(p->owner, AST_CAUSE_PROTOCOL_ERROR);
 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
 }
 ast_mutex_lock(&p->lock);
 p->mfcr2call = 0;
 ast_mutex_unlock(&p->lock);
}

static void dahdi_r2_disconnect_call(struct dahdi_pvt *p, openr2_call_disconnect_cause_t cause)
{
 if (openr2_chan_disconnect_call(p->r2chan, cause)) {
 ast_log(LOG_NOTICE, "Bad! failed to disconnect call on channel %d with reason %s, hope for the best!\n",
 p->channel, openr2_proto_get_disconnect_string(cause));
 /* force the chan to idle and release the call flag now since we will not see a clean on_call_end */
 openr2_chan_set_idle(p->r2chan);
 ast_mutex_lock(&p->lock);
 p->mfcr2call = 0;
 ast_mutex_unlock(&p->lock);
 }
}

static void dahdi_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category)
{
 struct dahdi_pvt *p;
 struct ast_channel *c;
 ast_callid callid = 0;
 int callid_created = ast_callid_threadstorage_auto(&callid);
 ast_verbose("MFC/R2 call offered on chan %d. ANI = %s, DNIS = %s, Category = %s\n",
 openr2_chan_get_number(r2chan), ani ? ani : "(restricted)", dnis,
 openr2_proto_get_category_string(category));
 p = openr2_chan_get_client_data(r2chan);
 /* if collect calls are not allowed and this is a collect call, reject it! */
 if (!p->mfcr2_allow_collect_calls && category == OR2_CALLING_PARTY_CATEGORY_COLLECT_CALL) {
 ast_log(LOG_NOTICE, "Rejecting MFC/R2 collect call\n");
 dahdi_r2_disconnect_call(p, OR2_CAUSE_COLLECT_CALL_REJECTED);
 goto dahdi_r2_on_call_offered_cleanup;
 }
 ast_mutex_lock(&p->lock);
 p->mfcr2_recvd_category = category;
 /* if we're not supposed to use CID, clear whatever we have */
 if (!p->use_callerid) {
 ast_debug(1, "No CID allowed in configuration, CID is being cleared!\n");
 p->cid_num[0] = 0;
 p->cid_name[0] = 0;
 }
 /* if we're supposed to answer immediately, clear DNIS and set 's' exten */
 if (p->immediate || !openr2_context_get_max_dnis(openr2_chan_get_context(r2chan))) {
 ast_debug(1, "Setting exten => s because of immediate or 0 DNIS configured\n");
 p->exten[0] = 's';
 p->exten[1] = 0;
 }
 ast_mutex_unlock(&p->lock);
 if (!ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
 ast_log(LOG_NOTICE, "MFC/R2 call on channel %d requested non-existent extension '%s' in context '%s'. Rejecting call.\n",
 p->channel, p->exten, p->context);
 dahdi_r2_disconnect_call(p, OR2_CAUSE_UNALLOCATED_NUMBER);
 goto dahdi_r2_on_call_offered_cleanup;
 }
 if (!p->mfcr2_accept_on_offer) {
 /* The user wants us to start the PBX thread right away without accepting the call first */
 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, NULL, callid);
 if (c) {
 /* Done here, don't disable reading now since we still need to generate MF tones to accept
 the call or reject it and detect the tone off condition of the other end, all of this
 will be done in the PBX thread now */
 goto dahdi_r2_on_call_offered_cleanup;
 }
 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
 } else if (p->mfcr2_charge_calls) {
 ast_debug(1, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
 openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
 } else {
 ast_debug(1, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
 openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
 }

dahdi_r2_on_call_offered_cleanup:
 ast_callid_threadstorage_auto_clean(callid, callid_created);
}

static void dahdi_r2_on_call_end(openr2_chan_t *r2chan)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_verbose("MFC/R2 call end on channel %d\n", p->channel);
 ast_mutex_lock(&p->lock);
 p->mfcr2call = 0;
 ast_mutex_unlock(&p->lock);
}

static void dahdi_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode)
{
 struct dahdi_pvt *p = NULL;
 struct ast_channel *c = NULL;
 ast_callid callid = 0;
 int callid_created = ast_callid_threadstorage_auto(&callid);
 p = openr2_chan_get_client_data(r2chan);
 dahdi_ec_enable(p);
 p->mfcr2_call_accepted = 1;
 /* if it's an incoming call ... */
 if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) {
 ast_verbose("MFC/R2 call has been accepted on backward channel %d\n", openr2_chan_get_number(r2chan));
 /* If accept on offer is not set, it means at this point the PBX thread is already
 launched (was launched in the 'on call offered' handler) and therefore this callback
 is being executed already in the PBX thread rather than the monitor thread, don't launch
 any other thread, just disable the openr2 reading and answer the call if needed */
 if (!p->mfcr2_accept_on_offer) {
 openr2_chan_disable_read(r2chan);
 if (p->mfcr2_answer_pending) {
 ast_debug(1, "Answering MFC/R2 call after accepting it on chan %d\n", openr2_chan_get_number(r2chan));
 dahdi_r2_answer(p);
 }
 goto dahdi_r2_on_call_accepted_cleanup;
 }
 c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, NULL, NULL, callid);
 if (c) {
 /* chan_dahdi will take care of reading from now on in the PBX thread, tell the
 library to forget about it */
 openr2_chan_disable_read(r2chan);
 goto dahdi_r2_on_call_accepted_cleanup;
 }
 ast_log(LOG_WARNING, "Unable to create PBX channel in DAHDI channel %d\n", p->channel);
 /* failed to create the channel, bail out and report it as an out of order line */
 dahdi_r2_disconnect_call(p, OR2_CAUSE_OUT_OF_ORDER);
 goto dahdi_r2_on_call_accepted_cleanup;
 }
 /* this is an outgoing call, no need to launch the PBX thread, most likely we're in one already */
 ast_verbose("MFC/R2 call has been accepted on forward channel %d\n", p->channel);
 p->subs[SUB_REAL].needringing = 1;
 p->dialing = 0;
 /* chan_dahdi will take care of reading from now on in the PBX thread, tell the library to forget about it */
 openr2_chan_disable_read(r2chan);

dahdi_r2_on_call_accepted_cleanup:
 ast_callid_threadstorage_auto_clean(callid, callid_created);
}

static void dahdi_r2_on_call_answered(openr2_chan_t *r2chan)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_verbose("MFC/R2 call has been answered on channel %d\n", openr2_chan_get_number(r2chan));
 p->subs[SUB_REAL].needanswer = 1;
}

static void dahdi_r2_on_call_read(openr2_chan_t *r2chan, const unsigned char *buf, int buflen)
{
 /*ast_debug(1, "Read data from dahdi channel %d\n", openr2_chan_get_number(r2chan));*/
}

static int dahdi_r2_cause_to_ast_cause(openr2_call_disconnect_cause_t cause)
{
 switch (cause) {
 case OR2_CAUSE_BUSY_NUMBER:
 return AST_CAUSE_BUSY;
 case OR2_CAUSE_NETWORK_CONGESTION:
 return AST_CAUSE_CONGESTION;
 case OR2_CAUSE_OUT_OF_ORDER:
 return AST_CAUSE_DESTINATION_OUT_OF_ORDER;
 case OR2_CAUSE_UNALLOCATED_NUMBER:
 return AST_CAUSE_UNREGISTERED;
 case OR2_CAUSE_NO_ANSWER:
 return AST_CAUSE_NO_ANSWER;
 case OR2_CAUSE_NORMAL_CLEARING:
 return AST_CAUSE_NORMAL_CLEARING;
 case OR2_CAUSE_UNSPECIFIED:
 default:
 return AST_CAUSE_NOTDEFINED;
 }
}

static void dahdi_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 char cause_str[50];
 struct ast_control_pvt_cause_code *cause_code;
 int datalen = sizeof(*cause_code);

 ast_verbose("MFC/R2 call disconnected on channel %d\n", openr2_chan_get_number(r2chan));
 ast_mutex_lock(&p->lock);
 if (!p->owner) {
 ast_mutex_unlock(&p->lock);
 /* no owner, therefore we can't use dahdi_hangup to disconnect, do it right now */
 dahdi_r2_disconnect_call(p, OR2_CAUSE_NORMAL_CLEARING);
 return;
 }

 snprintf(cause_str, sizeof(cause_str), "R2 DISCONNECT (%s)", openr2_proto_get_disconnect_string(cause));
 datalen += strlen(cause_str);
 cause_code = ast_alloca(datalen);
 memset(cause_code, 0, datalen);
 cause_code->ast_cause = dahdi_r2_cause_to_ast_cause(cause);
 ast_copy_string(cause_code->chan_name, ast_channel_name(p->owner), AST_CHANNEL_NAME);
 ast_copy_string(cause_code->code, cause_str, datalen + 1 - sizeof(*cause_code));
 ast_queue_control_data(p->owner, AST_CONTROL_PVT_CAUSE_CODE, cause_code, datalen);
 ast_channel_hangupcause_hash_set(p->owner, cause_code, datalen);
 ast_channel_hangupcause_set(p->owner, cause_code->ast_cause);

 /* when we have an owner we don't call dahdi_r2_disconnect_call here, that will
 be done in dahdi_hangup */
 if (ast_channel_state(p->owner) == AST_STATE_UP) {
 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
 ast_mutex_unlock(&p->lock);
 } else if (openr2_chan_get_direction(r2chan) == OR2_DIR_FORWARD) {
 /* being the forward side we must report what happened to the call to whoever requested it */
 switch (cause) {
 case OR2_CAUSE_BUSY_NUMBER:
 p->subs[SUB_REAL].needbusy = 1;
 break;
 case OR2_CAUSE_NETWORK_CONGESTION:
 case OR2_CAUSE_OUT_OF_ORDER:
 case OR2_CAUSE_UNALLOCATED_NUMBER:
 case OR2_CAUSE_NO_ANSWER:
 case OR2_CAUSE_UNSPECIFIED:
 case OR2_CAUSE_NORMAL_CLEARING:
 p->subs[SUB_REAL].needcongestion = 1;
 break;
 default:
 ast_channel_softhangup_internal_flag_add(p->owner, AST_SOFTHANGUP_DEV);
 }
 ast_mutex_unlock(&p->lock);
 } else {
 ast_mutex_unlock(&p->lock);
 /* being the backward side and not UP yet, we only need to request hangup */
 /* TODO: what about doing this same thing when were AST_STATE_UP? */
 ast_queue_hangup_with_cause(p->owner, dahdi_r2_cause_to_ast_cause(cause));
 }
}

static void dahdi_r2_write_log(openr2_log_level_t level, char *logmessage)
{
 switch (level) {
 case OR2_LOG_NOTICE:
 ast_verbose("%s", logmessage);
 break;
 case OR2_LOG_WARNING:
 ast_log(LOG_WARNING, "%s", logmessage);
 break;
 case OR2_LOG_ERROR:
 ast_log(LOG_ERROR, "%s", logmessage);
 break;
 case OR2_LOG_STACK_TRACE:
 case OR2_LOG_MF_TRACE:
 case OR2_LOG_CAS_TRACE:
 case OR2_LOG_DEBUG:
 case OR2_LOG_EX_DEBUG:
 ast_debug(1, "%s", logmessage);
 break;
 default:
 ast_log(LOG_WARNING, "We should handle logging level %d here.\n", level);
 ast_debug(1, "%s", logmessage);
 break;
 }
}

static void dahdi_r2_on_line_blocked(openr2_chan_t *r2chan)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_mutex_lock(&p->lock);
 p->remotelyblocked = 1;
 ast_mutex_unlock(&p->lock);
 ast_log(LOG_NOTICE, "Far end blocked on chan %d\n", openr2_chan_get_number(r2chan));
}

static void dahdi_r2_on_line_idle(openr2_chan_t *r2chan)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 ast_mutex_lock(&p->lock);
 p->remotelyblocked = 0;
 ast_mutex_unlock(&p->lock);
 ast_log(LOG_NOTICE, "Far end unblocked on chan %d\n", openr2_chan_get_number(r2chan));
}

static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap)
 __attribute__((format (printf, 3, 0)));
static void dahdi_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap)
{
#define CONTEXT_TAG "Context - "
 char logmsg[256];
 char completemsg[sizeof(logmsg) + sizeof(CONTEXT_TAG) - 1];
 vsnprintf(logmsg, sizeof(logmsg), fmt, ap);
 snprintf(completemsg, sizeof(completemsg), CONTEXT_TAG "%s", logmsg);
 dahdi_r2_write_log(level, completemsg);
#undef CONTEXT_TAG
}

static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap)
 __attribute__((format (printf, 3, 0)));
static void dahdi_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap)
{
#define CHAN_TAG "Chan "
 char logmsg[256];
 char completemsg[sizeof(logmsg) + sizeof(CHAN_TAG) - 1];
 vsnprintf(logmsg, sizeof(logmsg), fmt, ap);
 snprintf(completemsg, sizeof(completemsg), CHAN_TAG "%d - %s", openr2_chan_get_number(r2chan), logmsg);
 dahdi_r2_write_log(level, completemsg);
}

static int dahdi_r2_on_dnis_digit_received(openr2_chan_t *r2chan, char digit)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 /* if 'immediate' is set, let's stop requesting DNIS */
 if (p->immediate) {
 return 0;
 }
 p->exten[p->mfcr2_dnis_index] = digit;
 p->rdnis[p->mfcr2_dnis_index] = digit;
 p->mfcr2_dnis_index++;
 p->exten[p->mfcr2_dnis_index] = 0;
 p->rdnis[p->mfcr2_dnis_index] = 0;
 /* if the DNIS is a match and cannot match more, stop requesting DNIS */
 if ((p->mfcr2_dnis_matched ||
 (ast_exists_extension(NULL, p->context, p->exten, 1, p->cid_num) && (p->mfcr2_dnis_matched = 1))) &&
 !ast_matchmore_extension(NULL, p->context, p->exten, 1, p->cid_num)) {
 return 0;
 }
 /* otherwise keep going */
 return 1;
}

static void dahdi_r2_on_ani_digit_received(openr2_chan_t *r2chan, char digit)
{
 struct dahdi_pvt *p = openr2_chan_get_client_data(r2chan);
 p->cid_num[p->mfcr2_ani_index] = digit;
 p->cid_name[p->mfcr2_ani_index] = digit;
 p->mfcr2_ani_index++;
 p->cid_num[p->mfcr2_ani_index] = 0;
 p->cid_name[p->mfcr2_ani_index] = 0;
}

static void dahdi_r2_on_billing_pulse_received(openr2_chan_t *r2chan)
{
 ast_verbose("MFC/R2 billing pulse received on channel %d\n", openr2_chan_get_number(r2chan));
}

static openr2_event_interface_t dahdi_r2_event_iface = {
 .on_call_init = dahdi_r2_on_call_init,
 .on_call_offered = dahdi_r2_on_call_offered,
 .on_call_accepted = dahdi_r2_on_call_accepted,
 .on_call_answered = dahdi_r2_on_call_answered,
 .on_call_disconnect = dahdi_r2_on_call_disconnect,
 .on_call_end = dahdi_r2_on_call_end,
 .on_call_read = dahdi_r2_on_call_read,
 .on_hardware_alarm = dahdi_r2_on_hardware_alarm,
 .on_os_error = dahdi_r2_on_os_error,
 .on_protocol_error = dahdi_r2_on_protocol_error,
 .on_line_blocked = dahdi_r2_on_line_blocked,
 .on_line_idle = dahdi_r2_on_line_idle,
 /* cast seems to be needed to get rid of the annoying warning regarding format attribute */
 .on_context_log = (openr2_handle_context_logging_func)dahdi_r2_on_context_log,
 .on_dnis_digit_received = dahdi_r2_on_dnis_digit_received,
 .on_ani_digit_received = dahdi_r2_on_ani_digit_received,
 /* so far we do nothing with billing pulses */
 .on_billing_pulse_received = dahdi_r2_on_billing_pulse_received
};

static inline int16_t dahdi_r2_alaw_to_linear(uint8_t sample)
{
 return AST_ALAW(sample);
}

static inline uint8_t dahdi_r2_linear_to_alaw(int sample)
{
 return AST_LIN2A(sample);
}

static openr2_transcoder_interface_t dahdi_r2_transcode_iface = {
 dahdi_r2_alaw_to_linear,
 dahdi_r2_linear_to_alaw
};

#endif /* HAVE_OPENR2 */

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

 ast_debug(1, "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)
 ast_channel_set_fd(p->subs[a].owner, 0, p->subs[a].dfd);
 if (p->subs[b].owner)
 ast_channel_set_fd(p->subs[b].owner, 0, p->subs[b].dfd);
 wakeup_sub(p, a);
 wakeup_sub(p, b);
}

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 = "/dev/dahdi/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;
}

#if defined(HAVE_PRI)
static void dahdi_close_pri_fd(struct dahdi_pri *pri, int fd_num)
{
 dahdi_close(pri->pri.fds[fd_num]);
 pri->pri.fds[fd_num] = -1;
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_SS7)
static void dahdi_close_ss7_fd(struct dahdi_ss7 *ss7, int fd_num)
{
 dahdi_close(ss7->ss7.fds[fd_num]);
 ss7->ss7.fds[fd_num] = -1;
}
#endif /* defined(HAVE_SS7) */

static int dahdi_setlinear(int dfd, int linear)
{
 return ioctl(dfd, DAHDI_SETLINEAR, &linear);
}


static int alloc_sub(struct dahdi_pvt *p, int x)
{
 struct dahdi_bufferinfo bi;
 int res;
 if (p->subs[x].dfd >= 0) {
 ast_log(LOG_WARNING, "%s subchannel of %d already in use\n", subnames[x], p->channel);
 return -1;
 }

 p->subs[x].dfd = dahdi_open("/dev/dahdi/pseudo");
 if (p->subs[x].dfd <= -1) {
 ast_log(LOG_WARNING, "Unable to open pseudo channel: %s\n", strerror(errno));
 return -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);
 p->subs[x].dfd = -1;
 return -1;
 }
 ast_debug(1, "Allocated %s subchannel on FD %d channel %d\n", subnames[x], p->subs[x].dfd, p->subs[x].chan);
 return 0;
}

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_debug(1, "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 idx;
 int dtmf;
 int res;

 pvt = ast_channel_tech_pvt(chan);

 ast_mutex_lock(&pvt->lock);

 idx = dahdi_get_index(chan, pvt, 0);

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

#ifdef HAVE_PRI
 switch (pvt->sig) {
 case SIG_PRI_LIB_HANDLE_CASES:
 res = sig_pri_digit_begin(pvt->sig_pvt, chan, digit);
 if (!res)
 goto out;
 break;
 default:
 break;
 }
#endif
 dtmf = digit_to_dtmfindex(digit);
 if (dtmf == -1) {
 /* Not a valid DTMF digit */
 goto out;
 }

 if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &dtmf)) {
 char dial_str[] = { 'T', digit, '\0' };

 res = dahdi_dial_str(pvt, DAHDI_DIAL_OP_APPEND, dial_str);
 if (!res) {
 pvt->dialing = 1;
 }
 } else {
 pvt->dialing = 1;
 pvt->begindigit = digit;

 /* Flush the write buffer in DAHDI to start sending the digit immediately. */
 dtmf = DAHDI_FLUSH_WRITE;
 res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_FLUSH, &dtmf);
 if (res) {
 ast_log(LOG_WARNING, "Unable to flush the DAHDI write buffer to send DTMF on channel %d: %s\n",
 pvt->channel, strerror(errno));
 }

 ast_debug(1, "Channel %s started VLDTMF digit '%c'\n",
 ast_channel_name(chan), 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 idx;
 int x;

 pvt = ast_channel_tech_pvt(chan);

 ast_mutex_lock(&pvt->lock);

 idx = dahdi_get_index(chan, pvt, 0);

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

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

 if (pvt->begindigit) {
 x = -1;
 ast_debug(1, "Channel %s ending VLDTMF digit '%c'\n",
 ast_channel_name(chan), 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 const char * const 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 alm)
{
 int x;
 for (x = 0; x < ARRAY_LEN(alarms); x++) {
 if (alarms[x].alarm & alm)
 return alarms[x].name;
 }
 return alm ? "Unknown Alarm" : "No Alarm";
}

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

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_BRI:
 return "ISDN BRI Point to Point";
 case SIG_BRI_PTMP:
 return "ISDN BRI Point to MultiPoint";
 case SIG_SS7:
 return "SS7";
 case SIG_MFCR2:
 return "MFC/R2";
 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 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 idx, 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 (!idx) {
 /* 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;
 }
 c->curconf = zi;
 ast_debug(1, "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 idx)
{
 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_debug(1, "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;
}

void dahdi_conf_update(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;
 }
 ast_debug(1, "Updated conferencing on %d, with %d conference users\n", p->channel, needconf);
}

void dahdi_ec_enable(struct dahdi_pvt *p)
{
 int res;
 if (!p)
 return;
 if (p->echocanon) {
 ast_debug(1, "Echo cancellation already on\n");
 return;
 }
 if (p->digital) {
 ast_debug(1, "Echo cancellation isn't required on digital connection\n");
 return;
 }
 if (p->echocancel.head.tap_length) {
#if defined(HAVE_PRI) || defined(HAVE_SS7)
 switch (p->sig) {
#if defined(HAVE_PRI)
 case SIG_PRI_LIB_HANDLE_CASES:
 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
 /*
 * PRI nobch pseudo channel. Does not need ec anyway.
 * Does not handle ioctl(DAHDI_AUDIOMODE)
 */
 return;
 }
 /* Fall through */
#endif /* defined(HAVE_PRI) */
#if defined(HAVE_SS7)
 case SIG_SS7:
#endif /* defined(HAVE_SS7) */
 {
 int 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));
 }
 break;
 default:
 break;
 }
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */
 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_ECHOCANCEL_PARAMS, &p->echocancel);
 if (res) {
 ast_log(LOG_WARNING, "Unable to enable echo cancellation on channel %d (%s)\n", p->channel, strerror(errno));
 } else {
 p->echocanon = 1;
 ast_debug(1, "Enabled echo cancellation on channel %d\n", p->channel);
 }
 } else
 ast_debug(1, "No echo cancellation requested\n");
}

static void dahdi_train_ec(struct dahdi_pvt *p)
{
 int x;
 int res;

 if (p && p->echocanon && 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_debug(1, "Engaged echo training on channel %d\n", p->channel);
 } else {
 ast_debug(1, "No echo training requested\n");
 }
}

void dahdi_ec_disable(struct dahdi_pvt *p)
{
 int res;

 if (p->echocanon) {
 struct dahdi_echocanparams ecp = { .tap_length = 0 };

 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_ECHOCANCEL_PARAMS, &ecp);

 if (res)
 ast_log(LOG_WARNING, "Unable to disable echo cancellation on channel %d: %s\n", p->channel, strerror(errno));
 else
 ast_debug(1, "Disabled echo cancellation on channel %d\n", p->channel);
 }

 p->echocanon = 0;
}

static int set_hwgain(int fd, float gain, int tx_direction)
{
 struct dahdi_hwgain hwgain;

 hwgain.newgain = gain * 10.0;
 hwgain.tx = tx_direction;
 return ioctl(fd, DAHDI_SET_HWGAIN, &hwgain) < 0;
}

/* perform a dynamic range compression transform on the given sample */
static int drc_sample(int sample, float drc)
{
 float neg;
 float shallow, steep;
 float max = SHRT_MAX;

 neg = (sample < 0 ? -1 : 1);
 steep = drc*sample;
 shallow = neg*(max-max/drc)+(float)sample/drc;
 if (fabsf(steep) < fabsf(shallow)) {
 sample = steep;
 }
 else {
 sample = shallow;
 }

 return sample;
}


static void fill_txgain(struct dahdi_gains *g, float gain, float drc, 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 < ARRAY_LEN(g->txgain); j++) {
 if (gain || drc) {
 k = AST_ALAW(j);
 if (drc) {
 k = drc_sample(k, drc);
 }
 k = (float)k * linear_gain;
 if (k > 32767) {
 k = 32767;
 } else if (k < -32768) {
 k = -32768;
 }
 g->txgain[j] = AST_LIN2A(k);
 } else {
 g->txgain[j] = j;
 }
 }
 break;
 case DAHDI_LAW_MULAW:
 for (j = 0; j < ARRAY_LEN(g->txgain); j++) {
 if (gain || drc) {
 k = AST_MULAW(j);
 if (drc) {
 k = drc_sample(k, drc);
 }
 k = (float)k * linear_gain;
 if (k > 32767) {
 k = 32767;
 } else if (k < -32768) {
 k = -32768;
 }
 g->txgain[j] = AST_LIN2MU(k);

 } else {
 g->txgain[j] = j;
 }
 }
 break;
 }
}

static void fill_rxgain(struct dahdi_gains *g, float gain, float drc, 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 < ARRAY_LEN(g->rxgain); j++) {
 if (gain || drc) {
 k = AST_ALAW(j);
 if (drc) {
 k = drc_sample(k, drc);
 }
 k = (float)k * linear_gain;
 if (k > 32767) {
 k = 32767;
 } else if (k < -32768) {
 k = -32768;
 }
 g->rxgain[j] = AST_LIN2A(k);
 } else {
 g->rxgain[j] = j;
 }
 }
 break;
 case DAHDI_LAW_MULAW:
 for (j = 0; j < ARRAY_LEN(g->rxgain); j++) {
 if (gain || drc) {
 k = AST_MULAW(j);
 if (drc) {
 k = drc_sample(k, drc);
 }
 k = (float)k * linear_gain;
 if (k > 32767) {
 k = 32767;
 } else if (k < -32768) {
 k = -32768;
 }
 g->rxgain[j] = AST_LIN2MU(k);
 } else {
 g->rxgain[j] = j;
 }
 }
 break;
 }
}

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

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

 fill_txgain(&g, gain, drc, law);

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

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

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

 fill_rxgain(&g, gain, drc, law);

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

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

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

 /* Bump receive gain by value stored in cid_rxgain */
 res = set_actual_gain(p->subs[SUB_REAL].dfd, p->rxgain + p->cid_rxgain, p->txgain, p->rxdrc, p->txdrc, 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, p->rxgain, p->txgain, p->rxdrc, p->txdrc, 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, res;

 x = muted;
#if defined(HAVE_PRI) || defined(HAVE_SS7)
 switch (p->sig) {
#if defined(HAVE_PRI)
 case SIG_PRI_LIB_HANDLE_CASES:
 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
 /* PRI nobch pseudo channel. Does not handle ioctl(DAHDI_AUDIOMODE) */
 break;
 }
 /* Fall through */
#endif /* defined(HAVE_PRI) */
#if defined(HAVE_SS7)
 case SIG_SS7:
#endif /* defined(HAVE_SS7) */
 {
 int 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));
 }
 break;
 default:
 break;
 }
#endif /* defined(HAVE_PRI) || defined(HAVE_SS7) */
 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;
 }
 ast_debug(1, "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;
 }
 ast_debug(1, "Restored conferencing\n");
 }
 return 0;
}

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);
 ast_verb(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)
{
 int new_msgs;
 RAII_VAR(struct stasis_message *, mwi_message, NULL, ao2_cleanup);

 mwi_message = stasis_cache_get(ast_mwi_state_cache(), ast_mwi_state_type(), p->mailbox);
 if (mwi_message) {
 struct ast_mwi_state *mwi_state = stasis_message_data(mwi_message);
 new_msgs = mwi_state->new_msgs;
 } else {
 new_msgs = ast_app_has_voicemail(p->mailbox, NULL);
 }

 return new_msgs;
}



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);
 ast_debug(4, "writing callerid at pos %d of %d, res = %d\n", p->cidpos, p->cidlen, res);
 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;
 ast_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_channel_tech_pvt(ast);

 p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
 if (p->cidspill) {
 ast_log(LOG_WARNING, "Spill already exists?!?\n");
 ast_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, const char *rdest, int timeout)
{
 struct dahdi_pvt *p = ast_channel_tech_pvt(ast);
 int x, res, mysig;
 char *dest;
 AST_DECLARE_APP_ARGS(args,
 AST_APP_ARG(group); /* channel/group token */
 AST_APP_ARG(ext); /* extension token */
 //AST_APP_ARG(opts); /* options token */
 AST_APP_ARG(other); /* Any remining unused arguments */
 );

 ast_mutex_lock(&p->lock);
 ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));

 /* Split the dialstring */
 dest = ast_strdupa(rdest);
 AST_NONSTANDARD_APP_ARGS(args, dest, '/');
 if (!args.ext) {
 args.ext = "";
 }

#if defined(HAVE_PRI)
 if (dahdi_sig_pri_lib_handles(p->sig)) {
 char *subaddr;

 sig_pri_extract_called_num_subaddr(p->sig_pvt, rdest, p->exten, sizeof(p->exten));

 /* Remove any subaddress for uniformity with incoming calls. */
 subaddr = strchr(p->exten, ':');
 if (subaddr) {
 *subaddr = '\0';
 }
 } else
#endif /* defined(HAVE_PRI) */
 {
 ast_copy_string(p->exten, args.ext, sizeof(p->exten));
 }

 if ((ast_channel_state(ast) == AST_STATE_BUSY)) {
 p->subs[SUB_REAL].needbusy = 1;
 ast_mutex_unlock(&p->lock);
 return 0;
 }
 if ((ast_channel_state(ast) != AST_STATE_DOWN) && (ast_channel_state(ast) != AST_STATE_RESERVED)) {
 ast_log(LOG_WARNING, "dahdi_call called on %s, neither down nor reserved\n", ast_channel_name(ast));
 ast_mutex_unlock(&p->lock);
 return -1;
 }
 p->waitingfordt.tv_sec = 0;
 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_channel_transfercapability(ast))){
 set_actual_gain(p->subs[SUB_REAL].dfd, 0, 0, p->rxdrc, p->txdrc, p->law);
 } else {
 set_actual_gain(p->subs[SUB_REAL].dfd, p->rxgain, p->txgain, p->rxdrc, p->txdrc, p->law);
 }

#ifdef HAVE_PRI
 if (dahdi_sig_pri_lib_handles(p->sig)) {
 res = sig_pri_call(p->sig_pvt, ast, rdest, timeout,
 (p->law == DAHDI_LAW_ALAW) ? PRI_LAYER_1_ALAW : PRI_LAYER_1_ULAW);
 ast_mutex_unlock(&p->lock);
 return res;
 }
#endif

#if defined(HAVE_SS7)
 if (p->sig == SIG_SS7) {
 res = sig_ss7_call(p->sig_pvt, ast, rdest);
 ast_mutex_unlock(&p->lock);
 return res;
 }
#endif /* defined(HAVE_SS7) */

 /* If this is analog signalling we can exit here */
 if (dahdi_analog_lib_handles(p->sig, p->radio, p->oprmode)) {
 p->callwaitrings = 0;
 res = analog_call(p->sig_pvt, ast, rdest, timeout);
 ast_mutex_unlock(&p->lock);
 return res;
 }

 mysig = p->outsigmod > -1 ? p->outsigmod : p->sig;
 switch (mysig) {
 case 0:
 /* Special pseudo -- automatically up*/
 ast_setstate(ast, AST_STATE_UP);
 break;
 case SIG_MFCR2:
 break;
 default:
 ast_debug(1, "not yet implemented\n");
 ast_mutex_unlock(&p->lock);
 return -1;
 }

#ifdef HAVE_OPENR2
 if (p->mfcr2) {
 openr2_calling_party_category_t chancat;
 int callres = 0;
 char *c, *l;

 /* We'll get it in a moment -- but use dialdest to store pre-setup_ack digits */
 p->dialdest[0] = '\0';

 c = args.ext;
 if (!p->hidecallerid) {
 l = ast_channel_connected(ast)->id.number.valid ? ast_channel_connected(ast)->id.number.str : NULL;
 } else {
 l = NULL;
 }
 if (strlen(c) < p->stripmsd) {
 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
 ast_mutex_unlock(&p->lock);
 return -1;
 }
 p->dialing = 1;
 chancat = dahdi_r2_get_channel_category(ast);
 callres = openr2_chan_make_call(p->r2chan, l, (c + p->stripmsd), chancat);
 if (-1 == callres) {
 ast_mutex_unlock(&p->lock);
 ast_log(LOG_ERROR, "unable to make new MFC/R2 call!\n");
 return -1;
 }
 p->mfcr2_call_accepted = 0;
 p->mfcr2_progress_sent = 0;
 ast_setstate(ast, AST_STATE_DIALING);
 }
#endif /* HAVE_OPENR2 */
 ast_mutex_unlock(&p->lock);
 return 0;
}

/*!
 * \internal
 * \brief Insert the given chan_dahdi interface structure into the interface list.
 * \since 1.8
 *
 * \param pvt chan_dahdi private interface structure to insert.
 *
 * \details
 * The interface list is a doubly linked list sorted by the chan_dahdi channel number.
 * Any duplicates are inserted after the existing entries.
 *
 * \note The new interface must not already be in the list.
 *
 * \return Nothing
 */
static void dahdi_iflist_insert(struct dahdi_pvt *pvt)
{
 struct dahdi_pvt *cur;

 pvt->which_iflist = DAHDI_IFLIST_MAIN;

 /* Find place in middle of list for the new interface. */
 for (cur = iflist; cur; cur = cur->next) {
 if (pvt->channel < cur->channel) {
 /* New interface goes before the current interface. */
 pvt->prev = cur->prev;
 pvt->next = cur;
 if (cur->prev) {
 /* Insert into the middle of the list. */
 cur->prev->next = pvt;
 } else {
 /* Insert at head of list. */
 iflist = pvt;
 }
 cur->prev = pvt;
 return;
 }
 }

 /* New interface goes onto the end of the list */
 pvt->prev = ifend;
 pvt->next = NULL;
 if (ifend) {
 ifend->next = pvt;
 }
 ifend = pvt;
 if (!iflist) {
 /* List was empty */
 iflist = pvt;
 }
}

/*!
 * \internal
 * \brief Extract the given chan_dahdi interface structure from the interface list.
 * \since 1.8
 *
 * \param pvt chan_dahdi private interface structure to extract.
 *
 * \note
 * The given interface structure can be either in the interface list or a stand alone
 * structure that has not been put in the list if the next and prev pointers are NULL.
 *
 * \return Nothing
 */
static void dahdi_iflist_extract(struct dahdi_pvt *pvt)
{
 /* Extract from the forward chain. */
 if (pvt->prev) {
 pvt->prev->next = pvt->next;
 } else if (iflist == pvt) {
 /* Node is at the head of the list. */
 iflist = pvt->next;
 }

 /* Extract from the reverse chain. */
 if (pvt->next) {
 pvt->next->prev = pvt->prev;
 } else if (ifend == pvt) {
 /* Node is at the end of the list. */
 ifend = pvt->prev;
 }

 /* Node is no longer in the list. */
 pvt->which_iflist = DAHDI_IFLIST_NONE;
 pvt->prev = NULL;
 pvt->next = NULL;
}

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Insert the given chan_dahdi interface structure into the no B channel list.
 * \since 1.8
 *
 * \param pri sig_pri span control structure holding no B channel list.
 * \param pvt chan_dahdi private interface structure to insert.
 *
 * \details
 * The interface list is a doubly linked list sorted by the chan_dahdi channel number.
 * Any duplicates are inserted after the existing entries.
 *
 * \note The new interface must not already be in the list.
 *
 * \return Nothing
 */
static void dahdi_nobch_insert(struct sig_pri_span *pri, struct dahdi_pvt *pvt)
{
 struct dahdi_pvt *cur;

 pvt->which_iflist = DAHDI_IFLIST_NO_B_CHAN;

 /* Find place in middle of list for the new interface. */
 for (cur = pri->no_b_chan_iflist; cur; cur = cur->next) {
 if (pvt->channel < cur->channel) {
 /* New interface goes before the current interface. */
 pvt->prev = cur->prev;
 pvt->next = cur;
 if (cur->prev) {
 /* Insert into the middle of the list. */
 cur->prev->next = pvt;
 } else {
 /* Insert at head of list. */
 pri->no_b_chan_iflist = pvt;
 }
 cur->prev = pvt;
 return;
 }
 }

 /* New interface goes onto the end of the list */
 pvt->prev = pri->no_b_chan_end;
 pvt->next = NULL;
 if (pri->no_b_chan_end) {
 ((struct dahdi_pvt *) pri->no_b_chan_end)->next = pvt;
 }
 pri->no_b_chan_end = pvt;
 if (!pri->no_b_chan_iflist) {
 /* List was empty */
 pri->no_b_chan_iflist = pvt;
 }
}
#endif /* defined(HAVE_PRI) */

#if defined(HAVE_PRI)
/*!
 * \internal
 * \brief Extract the given chan_dahdi interface structure from the no B channel list.
 * \since 1.8
 *
 * \param pri sig_pri span control structure holding no B channel list.
 * \param pvt chan_dahdi private interface structure to extract.
 *
 * \note
 * The given interface structure can be either in the interface list or a stand alone
 * structure that has not been put in the list if the next and prev pointers are NULL.
 *
 * \return Nothing