Cleanup some flags on DAHDI PRI channel hangup.

[asterisk/asterisk.git] / channels / chan_dahdi.c

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

/*! \file
 *
 * \brief DAHDI for Pseudo TDM
 *
 * \author Mark Spencer <markster@digium.com>
 *
 * Connects to the DAHDI telephony library as well as
 * libpri. Libpri is optional and needed only if you are
 * going to use ISDN connections.
 *
 * You need to install libraries before you attempt to compile
 * and install the DAHDI channel.
 *
 * \par See also
 * \arg \ref Config_dahdi
 *
 * \ingroup channel_drivers
 *
 * \todo Deprecate the "musiconhold" configuration option post 1.4
 */

/*** MODULEINFO
        <depend>res_smdi</depend>
        <depend>dahdi</depend>
        <depend>tonezone</depend>
        <use>pri</use>
        <use>ss7</use>
        <use>openr2</use>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#include <values.h>
#ifdef __NetBSD__
#include <pthread.h>
#include <signal.h>
#else
#include <sys/signal.h>
#endif
#include <sys/ioctl.h>
#include <math.h>
#include <ctype.h>

#include <dahdi/user.h>
#include <dahdi/tonezone.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.
 */

#ifdef HAVE_PRI
#include "sig_pri.h"
#endif

#ifdef HAVE_SS7
/* put this here until sig_ss7 comes along */
#define NUM_DCHANS              4               /*!< No more than 4 d-channels */
#define MAX_CHANNELS    672             /*!< No more than a DS3 per trunk group */
#include <libss7.h>
#endif

#ifdef HAVE_OPENR2
#include <openr2.h>
#endif

#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/cdr.h"
#include "asterisk/cel.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/say.h"
#include "asterisk/tdd.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/astdb.h"
#include "asterisk/manager.h"
#include "asterisk/causes.h"
#include "asterisk/term.h"
#include "asterisk/utils.h"
#include "asterisk/transcap.h"
#include "asterisk/stringfields.h"
#include "asterisk/abstract_jb.h"
#include "asterisk/smdi.h"
#include "asterisk/astobj.h"
#include "asterisk/event.h"
#include "asterisk/devicestate.h"
#include "asterisk/paths.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 QSIG call rerouting facility over a PRI.
                </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 a Callrerouting Facility IE over the
                        current channel.</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>
        <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 name to transfer.</para>
                        </parameter>
                </syntax>
                <description>
                        <para>Transfer a DAHDI channel.</para>
                </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 name to hangup.</para>
                        </parameter>
                </syntax>
                <description>
                        <para>Hangup a DAHDI channel.</para>
                </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" />
                        <parameter name="Number" required="true" />
                </syntax>
                <description>
                </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" />
                </syntax>
                <description>
                </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" />
                </syntax>
                <description>
                </description>
        </manager>
        <manager name="DAHDIShowChannels" language="en_US">
                <synopsis>
                        Show status DAHDI channels.
                </synopsis>
                <syntax>
                        <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
                        <parameter name="DAHDIChannel" required="true" />
                </syntax>
                <description>
                </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>
                </description>
        </manager>
 ***/

#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 */
static struct ast_jb_conf default_jbconf =
{
        .flags = 0,
        .max_size = -1,
        .resync_threshold = -1,
        .impl = ""
};
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 */

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

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

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


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

static const char tdesc[] = "DAHDI Telephony Driver"
#if defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2)
        " w/"
#endif
#ifdef HAVE_PRI
        "PRI"
#endif
#ifdef HAVE_SS7
        #ifdef HAVE_PRI
        " & SS7"
        #else
        "SS7"
        #endif
#endif
#ifdef HAVE_OPENR2
        #if defined(HAVE_PRI) || defined(HAVE_SS7)
        " & MFC/R2"
        #else
        "MFC/R2"
        #endif
#endif
;

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

#define SIG_EM          DAHDI_SIG_EM
#define SIG_EMWINK      (0x0100000 | DAHDI_SIG_EM)
#define SIG_FEATD       (0x0200000 | DAHDI_SIG_EM)
#define SIG_FEATDMF     (0x0400000 | DAHDI_SIG_EM)
#define SIG_FEATB       (0x0800000 | DAHDI_SIG_EM)
#define SIG_E911        (0x1000000 | DAHDI_SIG_EM)
#define SIG_FEATDMF_TA  (0x2000000 | DAHDI_SIG_EM)
#define SIG_FGC_CAMA    (0x4000000 | DAHDI_SIG_EM)
#define SIG_FGC_CAMAMF  (0x8000000 | DAHDI_SIG_EM)
#define SIG_FXSLS       DAHDI_SIG_FXSLS
#define SIG_FXSGS       DAHDI_SIG_FXSGS
#define SIG_FXSKS       DAHDI_SIG_FXSKS
#define SIG_FXOLS       DAHDI_SIG_FXOLS
#define SIG_FXOGS       DAHDI_SIG_FXOGS
#define SIG_FXOKS       DAHDI_SIG_FXOKS
#define SIG_PRI         DAHDI_SIG_CLEAR
#define SIG_BRI         (0x2000000 | DAHDI_SIG_CLEAR)
#define SIG_BRI_PTMP    (0X4000000 | DAHDI_SIG_CLEAR)
#define SIG_SS7         (0x1000000 | DAHDI_SIG_CLEAR)
#define SIG_MFCR2       DAHDI_SIG_CAS
#define SIG_SF          DAHDI_SIG_SF
#define SIG_SFWINK      (0x0100000 | DAHDI_SIG_SF)
#define SIG_SF_FEATD    (0x0200000 | DAHDI_SIG_SF)
#define SIG_SF_FEATDMF  (0x0400000 | DAHDI_SIG_SF)
#define SIG_SF_FEATB    (0x0800000 | DAHDI_SIG_SF)
#define SIG_EM_E1       DAHDI_SIG_EM_E1

#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 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] = "";

static char parkinglot[AST_MAX_EXTENSION] = "";         /*!< Default parking lot for this channel */

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

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

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

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

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

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


static int ifcount = 0;

#ifdef HAVE_PRI
AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
#endif

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

/*! \brief This is the thread for the monitor which checks for input on the channels
   which are not currently in use. */
static pthread_t monitor_thread = AST_PTHREADT_NULL;
static ast_cond_t ss_thread_complete;
AST_MUTEX_DEFINE_STATIC(ss_thread_lock);
AST_MUTEX_DEFINE_STATIC(restart_lock);
static int ss_thread_count = 0;
static int num_restart_pending = 0;

static int restart_monitor(void);

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

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

static void mwi_event_cb(const struct ast_event *event, void *userdata)
{
        /* This module does not handle MWI in an event-based manner.  However, it
         * subscribes to MWI for each mailbox that is configured so that the core
         * knows that we care about it.  Then, chan_dahdi will get the MWI from the
         * event cache instead of checking the mailbox directly. */
}

/*! \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 CIDCW_EXPIRE_SAMPLES            ( (500 * 8) / READ_SIZE) /*!< 500 ms */
#define MIN_MS_SINCE_FLASH                      ( (2000) )      /*!< 2000 ms */
#define DEFAULT_RINGT                           ( (8000 * 8) / READ_SIZE) /*!< 8,000 ms */

struct dahdi_pvt;

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

#ifdef HAVE_SS7

#define LINKSTATE_INALARM       (1 << 0)
#define LINKSTATE_STARTING      (1 << 1)
#define LINKSTATE_UP            (1 << 2)
#define LINKSTATE_DOWN          (1 << 3)

#define SS7_NAI_DYNAMIC         -1

#define LINKSET_FLAG_EXPLICITACM (1 << 0)

struct dahdi_ss7 {
        pthread_t master;                                               /*!< Thread of master */
        ast_mutex_t lock;
        int fds[NUM_DCHANS];
        int numsigchans;
        int linkstate[NUM_DCHANS];
        int numchans;
        int type;
        enum {
                LINKSET_STATE_DOWN = 0,
                LINKSET_STATE_UP
        } state;
        char called_nai;                                                /*!< Called Nature of Address Indicator */
        char calling_nai;                                               /*!< Calling Nature of Address Indicator */
        char internationalprefix[10];                                   /*!< country access code ('00' for european dialplans) */
        char nationalprefix[10];                                        /*!< area access code ('0' for european dialplans) */
        char subscriberprefix[20];                                      /*!< area access code + area code ('0'+area code for european dialplans) */
        char unknownprefix[20];                                         /*!< for unknown dialplans */
        struct ss7 *ss7;
        struct dahdi_pvt *pvts[MAX_CHANNELS];                           /*!< Member channel pvt structs */
        int flags;                                                      /*!< Linkset flags */
};

static struct dahdi_ss7 linksets[NUM_SPANS];

static int cur_ss7type = -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 /* HAVE_SS7 */

#ifdef HAVE_OPENR2
struct dahdi_mfcr2 {
        pthread_t r2master;                    /*!< Thread of master */
        openr2_context_t *protocol_context;    /*!< OpenR2 context handle */
        struct dahdi_pvt *pvts[MAX_CHANNELS];     /*!< Member channel pvt structs */
        int numchans;                          /*!< Number of channels in this R2 block */
        int monitored_count;                   /*!< Number of channels being monitored */
};

struct dahdi_mfcr2_conf {
        openr2_variant_t variant;
        int mfback_timeout;
        int metering_pulse_timeout;
        int max_ani;
        int max_dnis;
        int get_ani_first:1;
#if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
        int skip_category_request:1;
#endif
        int call_files:1;
        int allow_collect_calls:1;
        int charge_calls:1;
        int accept_on_offer:1;
        int forced_release:1;
        int double_answer:1;
        int immediate_accept:1;
        char logdir[OR2_MAX_PATH];
        char r2proto_file[OR2_MAX_PATH];
        openr2_log_level_t loglevel;
        openr2_calling_party_category_t category;
};

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

#endif /* HAVE_OPENR2 */

#ifdef HAVE_PRI

struct dahdi_pri {
        int dchannels[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_pri pri;
};

static struct dahdi_pri pris[NUM_SPANS];

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

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

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


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

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

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

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

#define MAX_SLAVES      4

/* States for sending MWI message
 * First three states are required for send Ring Pulse Alert Signal
 */
typedef enum {
        MWI_SEND_NULL = 0,
        MWI_SEND_SA,
        MWI_SEND_SA_WAIT,
        MWI_SEND_PAUSE,
        MWI_SEND_SPILL,
        MWI_SEND_CLEANUP,
        MWI_SEND_DONE,
} mwisend_states;

struct mwisend_info {
        struct  timeval pause;
        mwisend_states  mwisend_current;
};

/*! Specify the lists dahdi_pvt can be put in. */
enum DAHDI_IFLIST {
        DAHDI_IFLIST_NONE,      /*!< The dahdi_pvt is not in any list. */
        DAHDI_IFLIST_MAIN,      /*!< The dahdi_pvt is in the main interface list */
#if defined(HAVE_PRI)
        DAHDI_IFLIST_NO_B_CHAN, /*!< The dahdi_pvt is in a no B channel interface list */
#endif  /* defined(HAVE_PRI) */
};

struct dahdi_pvt {
        ast_mutex_t lock;
        struct callerid_state *cs;
        struct ast_channel *owner;                      /*!< Our current active owner (if applicable) */
                                                        /*!< Up to three channels can be associated with this call */

        struct dahdi_subchannel sub_unused;             /*!< Just a safety precaution */
        struct dahdi_subchannel subs[3];                        /*!< Sub-channels */
        struct dahdi_confinfo saveconf;                 /*!< Saved conference info */

        struct dahdi_pvt *slaves[MAX_SLAVES];           /*!< Slave to us (follows our conferencing) */
        struct dahdi_pvt *master;                               /*!< Master to us (we follow their conferencing) */
        int inconference;                               /*!< If our real should be in the conference */

        int bufsize;                /*!< Size of the buffers */
        int buf_no;                                     /*!< Number of buffers */
        int buf_policy;                         /*!< Buffer policy */
        int faxbuf_no;              /*!< Number of Fax buffers */
        int faxbuf_policy;          /*!< Fax buffer policy */
        int sig;                                        /*!< Signalling style */
        /*!
         * \brief Nonzero if the signaling type is sent over a radio.
         * \note Set to a couple of nonzero values but it is only tested like a boolean.
         */
        int radio;
        int outsigmod;                                  /*!< Outbound Signalling style (modifier) */
        int oprmode;                                    /*!< "Operator Services" mode */
        struct dahdi_pvt *oprpeer;                              /*!< "Operator Services" peer tech_pvt ptr */
        /*! \brief Amount of gain to increase during caller id */
        float cid_rxgain;
        /*! \brief Rx gain set by chan_dahdi.conf */
        float rxgain;
        /*! \brief Tx gain set by chan_dahdi.conf */
        float txgain;

        float txdrc; /*!< Dynamic Range Compression factor. a number between 1 and 6ish */
        float rxdrc;
        
        int tonezone;                                   /*!< tone zone for this chan, or -1 for default */
        enum DAHDI_IFLIST which_iflist; /*!< Which interface list is this structure listed? */
        struct dahdi_pvt *next;                         /*!< Next channel in list */
        struct dahdi_pvt *prev;                         /*!< Prev channel in list */

        /* flags */

        /*!
         * \brief TRUE if ADSI (Analog Display Services Interface) available
         * \note Set from the "adsi" value read in from chan_dahdi.conf
         */
        unsigned int adsi:1;
        /*!
         * \brief TRUE if we can use a polarity reversal to mark when an outgoing
         * call is answered by the remote party.
         * \note Set from the "answeronpolarityswitch" value read in from chan_dahdi.conf
         */
        unsigned int answeronpolarityswitch:1;
        /*!
         * \brief TRUE if busy detection is enabled.
         * (Listens for the beep-beep busy pattern.)
         * \note Set from the "busydetect" value read in from chan_dahdi.conf
         */
        unsigned int busydetect:1;
        /*!
         * \brief TRUE if call return is enabled.
         * (*69, if your dialplan doesn't catch this first)
         * \note Set from the "callreturn" value read in from chan_dahdi.conf
         */
        unsigned int callreturn:1;
        /*!
         * \brief TRUE if busy extensions will hear the call-waiting tone
         * and can use hook-flash to switch between callers.
         * \note Can be disabled by dialing *70.
         * \note Initialized with the "callwaiting" value read in from chan_dahdi.conf
         */
        unsigned int callwaiting:1;
        /*!
         * \brief TRUE if send caller ID for Call Waiting
         * \note Set from the "callwaitingcallerid" value read in from chan_dahdi.conf
         */
        unsigned int callwaitingcallerid:1;
        /*!
         * \brief TRUE if support for call forwarding enabled.
         * Dial *72 to enable call forwarding.
         * Dial *73 to disable call forwarding.
         * \note Set from the "cancallforward" value read in from chan_dahdi.conf
         */
        unsigned int cancallforward:1;
        /*!
         * \brief TRUE if support for call parking is enabled.
         * \note Set from the "canpark" value read in from chan_dahdi.conf
         */
        unsigned int canpark:1;
        /*! \brief TRUE if to wait for a DTMF digit to confirm answer */
        unsigned int confirmanswer:1;
        /*!
         * \brief TRUE if the channel is to be destroyed on hangup.
         * (Used by pseudo channels.)
         */
        unsigned int destroy:1;
        unsigned int didtdd:1;                          /*!< flag to say its done it once */
        /*! \brief TRUE if analog type line dialed no digits in Dial() */
        unsigned int dialednone:1;
        /*! \brief TRUE if in the process of dialing digits or sending something. */
        unsigned int dialing:1;
        /*! \brief TRUE if the transfer capability of the call is digital. */
        unsigned int digital:1;
        /*! \brief TRUE if Do-Not-Disturb is enabled, present only for non sig_analog */
        unsigned int dnd:1;
        /*! \brief XXX BOOLEAN Purpose??? */
        unsigned int echobreak:1;
        /*!
         * \brief TRUE if echo cancellation enabled when bridged.
         * \note Initialized with the "echocancelwhenbridged" value read in from chan_dahdi.conf
         * \note Disabled if the echo canceller is not setup.
         */
        unsigned int echocanbridged:1;
        /*! \brief TRUE if echo cancellation is turned on. */
        unsigned int echocanon:1;
        /*! \brief TRUE if a fax tone has already been handled. */
        unsigned int faxhandled:1;
        /*! TRUE if dynamic faxbuffers are configured for use, default is OFF */
        unsigned int usefaxbuffers:1;
        /*! TRUE while buffer configuration override is in use */
        unsigned int bufferoverrideinuse:1;
        /*! \brief TRUE if over a radio and dahdi_read() has been called. */
        unsigned int firstradio:1;
        /*!
         * \brief TRUE if the call will be considered "hung up" on a polarity reversal.
         * \note Set from the "hanguponpolarityswitch" value read in from chan_dahdi.conf
         */
        unsigned int hanguponpolarityswitch:1;
        /*! \brief TRUE if DTMF detection needs to be done by hardware. */
        unsigned int hardwaredtmf:1;
        /*!
         * \brief TRUE if the outgoing caller ID is blocked/hidden.
         * \note Caller ID can be disabled by dialing *67.
         * \note Caller ID can be enabled by dialing *82.
         * \note Initialized with the "hidecallerid" value read in from chan_dahdi.conf
         */
        unsigned int hidecallerid:1;
        /*!
         * \brief TRUE if hide just the name not the number for legacy PBX use.
         * \note Only applies to PRI channels.
         * \note Set from the "hidecalleridname" value read in from chan_dahdi.conf
         */
        unsigned int hidecalleridname:1;
        /*! \brief TRUE if DTMF detection is disabled. */
        unsigned int ignoredtmf:1;
        /*!
         * \brief TRUE if the channel should be answered immediately
         * without attempting to gather any digits.
         * \note Set from the "immediate" value read in from chan_dahdi.conf
         */
        unsigned int immediate:1;
        /*! \brief TRUE if in an alarm condition. */
        unsigned int inalarm:1;
        /*! \brief TRUE if TDD in MATE mode */
        unsigned int mate:1;
        /*! \brief TRUE if we originated the call leg. */
        unsigned int outgoing:1;
        /* unsigned int overlapdial:1;                  unused and potentially confusing */
        /*!
         * \brief TRUE if busy extensions will hear the call-waiting tone
         * and can use hook-flash to switch between callers.
         * \note Set from the "callwaiting" value read in from chan_dahdi.conf
         */
        unsigned int permcallwaiting:1;
        /*!
         * \brief TRUE if the outgoing caller ID is blocked/restricted/hidden.
         * \note Set from the "hidecallerid" value read in from chan_dahdi.conf
         */
        unsigned int permhidecallerid:1;
        /*!
         * \brief TRUE if PRI congestion/busy indications are sent out-of-band.
         * \note Set from the "priindication" value read in from chan_dahdi.conf
         */
        unsigned int priindication_oob:1;
        /*!
         * \brief TRUE if PRI B channels are always exclusively selected.
         * \note Set from the "priexclusive" value read in from chan_dahdi.conf
         */
        unsigned int priexclusive:1;
        /*!
         * \brief TRUE if we will pulse dial.
         * \note Set from the "pulsedial" value read in from chan_dahdi.conf
         */
        unsigned int pulse:1;
        /*! \brief TRUE if a pulsed digit was detected. (Pulse dial phone detected) */
        unsigned int pulsedial:1;
        unsigned int restartpending:1;          /*!< flag to ensure counted only once for restart */
        /*!
         * \brief TRUE if caller ID is restricted.
         * \note Set but not used.  Should be deleted.  Redundant with permhidecallerid.
         * \note Set from the "restrictcid" value read in from chan_dahdi.conf
         */
        unsigned int restrictcid:1;
        /*!
         * \brief TRUE if three way calling is enabled
         * \note Set from the "threewaycalling" value read in from chan_dahdi.conf
         */
        unsigned int threewaycalling:1;
        /*!
         * \brief TRUE if call transfer is enabled
         * \note For FXS ports (either direct analog or over T1/E1):
         *   Support flash-hook call transfer
         * \note For digital ports using ISDN PRI protocols:
         *   Support switch-side transfer (called 2BCT, RLT or other names)
         * \note Set from the "transfer" value read in from chan_dahdi.conf
         */
        unsigned int transfer:1;
        /*!
         * \brief TRUE if caller ID is used on this channel.
         * \note PRI and SS7 spans will save caller ID from the networking peer.
         * \note FXS ports will generate the caller ID spill.
         * \note FXO ports will listen for the caller ID spill.
         * \note Set from the "usecallerid" value read in from chan_dahdi.conf
         */
        unsigned int use_callerid:1;
        /*!
         * \brief TRUE if we will use the calling presentation setting
         * from the Asterisk channel for outgoing calls.
         * \note Only applies to PRI and SS7 channels.
         * \note Set from the "usecallingpres" value read in from chan_dahdi.conf
         */
        unsigned int use_callingpres:1;
        /*!
         * \brief TRUE if distinctive rings are to be detected.
         * \note For FXO lines
         * \note Set indirectly from the "usedistinctiveringdetection" value read in from chan_dahdi.conf
         */
        unsigned int usedistinctiveringdetection:1;
        /*!
         * \brief TRUE if we should use the callerid from incoming call on dahdi transfer.
         * \note Set from the "useincomingcalleridondahditransfer" value read in from chan_dahdi.conf
         */
        unsigned int dahditrcallerid:1;
        /*!
         * \brief TRUE if allowed to flash-transfer to busy channels.
         * \note Set from the "transfertobusy" value read in from chan_dahdi.conf
         */
        unsigned int transfertobusy:1;
        /*!
         * \brief TRUE if the FXO port monitors for neon type MWI indications from the other end.
         * \note Set if the "mwimonitor" value read in contains "neon" from chan_dahdi.conf
         */
        unsigned int mwimonitor_neon:1;
        /*!
         * \brief TRUE if the FXO port monitors for fsk type MWI indications from the other end.
         * \note Set if the "mwimonitor" value read in contains "fsk" from chan_dahdi.conf
         */
        unsigned int mwimonitor_fsk:1;
        /*!
         * \brief TRUE if the FXO port monitors for rpas precursor to fsk MWI indications from the other end.
         * \note RPAS - Ring Pulse Alert Signal
         * \note Set if the "mwimonitor" value read in contains "rpas" from chan_dahdi.conf
         */
        unsigned int mwimonitor_rpas:1;
        /*! \brief TRUE if an MWI monitor thread is currently active */
        unsigned int mwimonitoractive:1;
        /*! \brief TRUE if a MWI message sending thread is active */
        unsigned int mwisendactive:1;
        /*!
         * \brief TRUE if channel is out of reset and ready
         * \note Set but not used.
         */
        unsigned int inservice:1;
        /*!
         * \brief TRUE if the channel is locally blocked.
         * \note Applies to SS7 and MFCR2 channels.
         */
        unsigned int locallyblocked:1;
        /*!
         * \brief TRUE if the channel is remotely blocked.
         * \note Applies to SS7 and MFCR2 channels.
         */
        unsigned int remotelyblocked:1;
#if defined(HAVE_PRI)
        struct sig_pri_pri *pri;
        int prioffset;
        int logicalspan;
#endif
#if defined(HAVE_PRI) || defined(HAVE_SS7)
        /*!
         * \brief XXX BOOLEAN Purpose???
         * \note Applies to SS7 channels.
         */
        unsigned int rlt:1;
        /*! \brief TRUE if channel is alerting/ringing */
        unsigned int alerting:1;
        /*! \brief TRUE if the call has already gone/hungup */
        unsigned int alreadyhungup:1;
        /*!
         * \brief TRUE if call is in a proceeding state.
         * The call has started working its way through the network.
         */
        unsigned int proceeding:1;
        /*! \brief TRUE if the call has seen progress through the network. */
        unsigned int progress:1;
#endif
        /*!
         * \brief TRUE if SMDI (Simplified Message Desk Interface) is enabled
         * \note Set from the "usesmdi" value read in from chan_dahdi.conf
         */
        unsigned int use_smdi:1;
        struct mwisend_info mwisend_data;
        /*! \brief The serial port to listen for SMDI data on */
        struct ast_smdi_interface *smdi_iface;

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

        /*!
         * \brief The configured context for incoming calls.
         * \note The "context" string read in from chan_dahdi.conf
         */
        char context[AST_MAX_CONTEXT];
        /*!
         * \brief Saved context string.
         */
        char defcontext[AST_MAX_CONTEXT];
        /*! \brief Extension to use in the dialplan. */
        char exten[AST_MAX_EXTENSION];
        /*!
         * \brief Language configured for calls.
         * \note The "language" string read in from chan_dahdi.conf
         */
        char language[MAX_LANGUAGE];
        /*!
         * \brief The configured music-on-hold class to use for calls.
         * \note The "musicclass" or "mohinterpret" or "musiconhold" string read in from chan_dahdi.conf
         */
        char mohinterpret[MAX_MUSICCLASS];
        /*!
         * \brief Suggested music-on-hold class for peer channel to use for calls.
         * \note The "mohsuggest" string read in from chan_dahdi.conf
         */
        char mohsuggest[MAX_MUSICCLASS];
        char parkinglot[AST_MAX_EXTENSION]; /*!< Parking lot for this channel */
#if defined(PRI_ANI) || defined(HAVE_SS7)
        /*! \brief Automatic Number Identification number (Alternate PRI caller ID number) */
        char cid_ani[AST_MAX_EXTENSION];
#endif
        /*! \brief Automatic Number Identification code from PRI */
        int cid_ani2;
        /*! \brief Caller ID number from an incoming call. */
        char cid_num[AST_MAX_EXTENSION];
        /*! \brief Caller ID Q.931 TON/NPI field values.  Set by PRI. Zero otherwise. */
        int cid_ton;
        /*! \brief Caller ID name from an incoming call. */
        char cid_name[AST_MAX_EXTENSION];
        char *origcid_num;                              /*!< malloced original callerid */
        char *origcid_name;                             /*!< malloced original callerid */
        /*! \brief Call waiting number. */
        char callwait_num[AST_MAX_EXTENSION];
        /*! \brief Call waiting name. */
        char callwait_name[AST_MAX_EXTENSION];
        /*! \brief Redirecting Directory Number Information Service (RDNIS) number */
        char rdnis[AST_MAX_EXTENSION];
        /*! \brief Dialed Number Identifier */
        char dnid[AST_MAX_EXTENSION];
        /*!
         * \brief Bitmapped groups this belongs to.
         * \note The "group" bitmapped group string read in from chan_dahdi.conf
         */
        ast_group_t group;
        /*! \brief Active PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW */
        int law;
        int confno;                                     /*!< Our conference */
        int confusers;                                  /*!< Who is using our conference */
        int propconfno;                                 /*!< Propagated conference number */
        /*!
         * \brief Bitmapped call groups this belongs to.
         * \note The "callgroup" bitmapped group string read in from chan_dahdi.conf
         */
        ast_group_t callgroup;
        /*!
         * \brief Bitmapped pickup groups this belongs to.
         * \note The "pickupgroup" bitmapped group string read in from chan_dahdi.conf
         */
        ast_group_t pickupgroup;
        /*!
         * \brief Channel variable list with associated values to set when a channel is created.
         * \note The "setvar" strings read in from chan_dahdi.conf
         */
        struct ast_variable *vars;
        int channel;                                    /*!< Channel Number */
        int span;                                       /*!< Span number */
        time_t guardtime;                               /*!< Must wait this much time before using for new call */
        int cid_signalling;                             /*!< CID signalling type bell202 or v23 */
        int cid_start;                                  /*!< CID start indicator, polarity or ring or DTMF without warning event */
        int dtmfcid_holdoff_state;              /*!< State indicator that allows for line to settle before checking for dtmf energy */
        struct timeval  dtmfcid_delay;  /*!< Time value used for allow line to settle */
        int callingpres;                                /*!< The value of calling presentation that we're going to use when placing a PRI call */
        int callwaitingrepeat;                          /*!< How many samples to wait before repeating call waiting */
        int cidcwexpire;                                /*!< When to expire our muting for CID/CW */
        /*! \brief Analog caller ID waveform sample buffer */
        unsigned char *cidspill;
        /*! \brief Position in the cidspill buffer to send out next. */
        int cidpos;
        /*! \brief Length of the cidspill buffer containing samples. */
        int cidlen;
        /*! \brief Ring timeout timer?? */
        int ringt;
        /*!
         * \brief Ring timeout base.
         * \note Value computed indirectly from "ringtimeout" read in from chan_dahdi.conf
         */
        int ringt_base;
        /*!
         * \brief Number of most significant digits/characters to strip from the dialed number.
         * \note Feature is deprecated.  Use dialplan logic.
         * \note The characters are stripped before the PRI TON/NPI prefix
         * characters are processed.
         */
        int stripmsd;
        /*! \brief BOOLEAN. XXX Meaning what?? */
        int callwaitcas;
        /*! \brief Number of call waiting rings. */
        int callwaitrings;
        /*! \brief Echo cancel parameters. */
        struct {
                struct dahdi_echocanparams head;
                struct dahdi_echocanparam params[DAHDI_MAX_ECHOCANPARAMS];
        } echocancel;
        /*!
         * \brief Echo training time. 0 = disabled
         * \note Set from the "echotraining" value read in from chan_dahdi.conf
         */
        int echotraining;
        /*! \brief Filled with 'w'.  XXX Purpose?? */
        char echorest[20];
        /*!
         * \brief Number of times to see "busy" tone before hanging up.
         * \note Set from the "busycount" value read in from chan_dahdi.conf
         */
        int busycount;
        /*!
         * \brief Length of "busy" tone on time.
         * \note Set from the "busypattern" value read in from chan_dahdi.conf
         */
        int busy_tonelength;
        /*!
         * \brief Length of "busy" tone off time.
         * \note Set from the "busypattern" value read in from chan_dahdi.conf
         */
        int busy_quietlength;
        /*!
         * \brief Bitmapped call progress detection flags. CALLPROGRESS_xxx values.
         * \note Bits set from the "callprogress" and "faxdetect" values read in from chan_dahdi.conf
         */
        int callprogress;
        /*!
         * \brief Number of milliseconds to wait for dialtone.
         * \note Set from the "waitfordialtone" value read in from chan_dahdi.conf
         */
        int waitfordialtone;
        struct timeval waitingfordt;                    /*!< Time we started waiting for dialtone */
        struct timeval flashtime;                       /*!< Last flash-hook time */
        /*! \brief Opaque DSP configuration structure. */
        struct ast_dsp *dsp;
        /*! \brief DAHDI dial operation command struct for ioctl() call. */
        struct dahdi_dialoperation dop;
        int whichwink;                                  /*!< SIG_FEATDMF_TA Which wink are we on? */
        /*! \brief Second part of SIG_FEATDMF_TA wink operation. */
        char finaldial[64];
        char accountcode[AST_MAX_ACCOUNT_CODE];         /*!< Account code */
        int amaflags;                                   /*!< AMA Flags */
        struct tdd_state *tdd;                          /*!< TDD flag */
        /*! \brief Accumulated call forwarding number. */
        char call_forward[AST_MAX_EXTENSION];
        /*!
         * \brief Voice mailbox location.
         * \note Set from the "mailbox" string read in from chan_dahdi.conf
         */
        char mailbox[AST_MAX_EXTENSION];
        /*! \brief Opaque event subscription parameters for message waiting indication support. */
        struct ast_event_sub *mwi_event_sub;
        /*! \brief Delayed dialing for E911.  Overlap digits for ISDN. */
        char dialdest[256];
#ifdef HAVE_DAHDI_LINEREVERSE_VMWI
        struct dahdi_vmwi_info mwisend_setting;                         /*!< Which VMWI methods to use */
        unsigned int mwisend_fsk: 1;            /*! Variable for enabling FSK MWI handling in chan_dahdi */
        unsigned int mwisend_rpas:1;            /*! Variable for enabling Ring Pulse Alert before MWI FSK Spill */
#endif
        int distinctivering;                            /*!< Which distinctivering to use */
        int dtmfrelax;                                  /*!< whether to run in relaxed DTMF mode */
        /*! \brief Holding place for event injected from outside normal operation. */
        int fake_event;
        /*!
         * \brief Minimal time period (ms) between the answer polarity
         * switch and hangup polarity switch.
         */
        int polarityonanswerdelay;
        /*! \brief Start delay time if polarityonanswerdelay is nonzero. */
        struct timeval polaritydelaytv;
        /*!
         * \brief Send caller ID on FXS after this many rings. Set to 1 for US.
         * \note Set from the "sendcalleridafter" value read in from chan_dahdi.conf
         */
        int sendcalleridafter;
        /*! \brief Current line interface polarity. POLARITY_IDLE, POLARITY_REV */
        int polarity;
        /*! \brief DSP feature flags: DSP_FEATURE_xxx */
        int dsp_features;
#ifdef HAVE_SS7
        /*! \brief SS7 control parameters */
        struct dahdi_ss7 *ss7;
        /*! \brief Opaque libss7 call control structure */
        struct isup_call *ss7call;
        char charge_number[50];
        char gen_add_number[50];
        char gen_dig_number[50];
        char orig_called_num[50];
        char redirecting_num[50];
        char generic_name[50];
        unsigned char gen_add_num_plan;
        unsigned char gen_add_nai;
        unsigned char gen_add_pres_ind;
        unsigned char gen_add_type;
        unsigned char gen_dig_type;
        unsigned char gen_dig_scheme;
        char jip_number[50];
        unsigned char lspi_type;
        unsigned char lspi_scheme;
        unsigned char lspi_context;
        char lspi_ident[50];
        unsigned int call_ref_ident;
        unsigned int call_ref_pc;
        unsigned char calling_party_cat;
        int transcap;
        int cic;                                                        /*!< CIC associated with channel */
        unsigned int dpc;                                               /*!< CIC's DPC */
        unsigned int loopedback:1;
#endif
#ifdef HAVE_OPENR2
        struct dahdi_mfcr2 *mfcr2;
        openr2_chan_t *r2chan;
        openr2_calling_party_category_t mfcr2_recvd_category;
        openr2_calling_party_category_t mfcr2_category;
        int mfcr2_dnis_index;
        int mfcr2_ani_index;
        int mfcr2call:1;
        int mfcr2_answer_pending:1;
        int mfcr2_charge_calls:1;
        int mfcr2_allow_collect_calls:1;
        int mfcr2_forced_release:1;
        int mfcr2_dnis_matched:1;
        int mfcr2_call_accepted:1;
        int mfcr2_accept_on_offer:1;
#endif
        /*! \brief DTMF digit in progress.  0 when no digit in progress. */
        char begindigit;
        /*! \brief TRUE if confrence is muted. */
        int muting;
        void *sig_pvt;
};

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

#if defined(HAVE_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

#ifdef HAVE_SS7
        struct dahdi_ss7 ss7;
#endif

#ifdef HAVE_OPENR2
        struct dahdi_mfcr2_conf mfcr2;
#endif
        struct dahdi_params timing;
        int is_sig_auto; /*!< Use channel signalling from DAHDI? */

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

/*! returns a new dahdi_chan_conf with default values (by-value) */
static struct dahdi_chan_conf dahdi_chan_conf_default(void)
{
        /* recall that if a field is not included here it is initialized
         * to 0 or equivalent
         */
        struct dahdi_chan_conf conf = {
#ifdef HAVE_PRI
                .pri.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,

                        .minunused = 2,
                        .idleext = "",
                        .idledial = "",
                        .internationalprefix = "",
                        .nationalprefix = "",
                        .localprefix = "",
                        .privateprefix = "",
                        .unknownprefix = "",
                        .resetinterval = -1,
                },
#endif
#ifdef HAVE_SS7
                .ss7 = {
                        .called_nai = SS7_NAI_NATIONAL,
                        .calling_nai = SS7_NAI_NATIONAL,
                        .internationalprefix = "",
                        .nationalprefix = "",
                        .subscriberprefix = "",
                        .unknownprefix = ""
                },
#endif
#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,
                        .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 = "",
                        .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,
                },
                .timing = {
                        .prewinktime = -1,
                        .preflashtime = -1,
                        .winktime = -1,
                        .flashtime = -1,
                        .starttime = -1,
                        .rxwinktime = -1,
                        .rxflashtime = -1,
                        .debouncetime = -1
                },
                .is_sig_auto = 1,
                .smdi_port = "/dev/ttyS0",
        };

        return conf;
}


static struct ast_channel *dahdi_request(const char *type, int format, const struct ast_channel *requestor, void *data, int *cause);
static int dahdi_digit_begin(struct ast_channel *ast, char digit);
static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
static int dahdi_sendtext(struct ast_channel *c, const char *text);
static int dahdi_call(struct ast_channel *ast, char *rdest, int timeout);
static int dahdi_hangup(struct ast_channel *ast);
static int dahdi_answer(struct ast_channel *ast);
static struct ast_frame *dahdi_read(struct ast_channel *ast);
static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame);
static struct ast_frame *dahdi_exception(struct ast_channel *ast);
static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen);
static int dahdi_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 const struct ast_channel_tech dahdi_tech = {
        .type = "DAHDI",
        .description = tdesc,
        .capabilities = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW | AST_FORMAT_ALAW,
        .requester = dahdi_request,
        .send_digit_begin = dahdi_digit_begin,
        .send_digit_end = dahdi_digit_end,
        .send_text = dahdi_sendtext,
        .call = dahdi_call,
        .hangup = dahdi_hangup,
        .answer = dahdi_answer,
        .read = dahdi_read,
        .write = dahdi_write,
        .bridge = dahdi_bridge,
        .exception = dahdi_exception,
        .indicate = dahdi_indicate,
        .fixup = dahdi_fixup,
        .setoption = dahdi_setoption,
        .queryoption = dahdi_queryoption,
        .func_channel_read = dahdi_func_read,
        .func_channel_write = dahdi_func_write,
};

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

#define SIG_PRI_LIB_HANDLE_CASES        \
        SIG_PRI:                                                \
        case SIG_BRI:                                   \
        case SIG_BRI_PTMP

/*!
 * \internal
 * \brief Determine if sig_pri handles the signaling.
 * \since 1.6.3
 *
 * \param signaling Signaling to determine if is for sig_pri.
 *
 * \return TRUE if the signaling is for sig_pri.
 */
static inline int dahdi_sig_pri_lib_handles(int signaling)
{
        int handles;

        switch (signaling) {
        case SIG_PRI_LIB_HANDLE_CASES:
                handles = 1;
                break;
        default:
                handles = 0;
                break;
        }

        return handles;
}

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

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 my_stop_cid_detect(void *pvt)
{
        struct dahdi_pvt *p = pvt;
        int index = SUB_REAL;
        if (p->cs)
                callerid_free(p->cs);
        dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
        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) {
                        if (errno != ELAST) {
                                ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
                                callerid_free(p->cs);
                                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) {
                        ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno));
                        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_log(LOG_DEBUG, "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 restore_gains(struct dahdi_pvt *p);

static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
{
        unsigned char buf[256];
        int distMatches;
        int curRingData[3];
        int receivedRingT;
        int counter1;
        int counter;
        int i;
        int res;
        int checkaftercid = 0;

        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, if configured, lets try to listen for
         * distinctive ringing */
        if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
                /* Clear the current ring data array so we dont have old data in it. */
                for (receivedRingT = 0; receivedRingT < ARRAY_LEN(ringdata); receivedRingT++)
                        ringdata[receivedRingT] = 0;
                receivedRingT = 0;
                if (checkaftercid && distinctiveringaftercid)
                        ast_verb(3, "Detecting post-CID distinctive ring\n");
                /* Check to see if context is what it should be, if not set to be. */
                else if (strcmp(p->context,p->defcontext) != 0) {
                        ast_copy_string(p->context, p->defcontext, sizeof(p->context));
                        ast_copy_string(chan->context,p->defcontext,sizeof(chan->context));
                }

                for (;;) {
                        i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
                        if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
                                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_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
                                res = 0;
                                /* 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 == ARRAY_LEN(ringdata))
                                        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)) {
                                                res = -1;
                                                break;
                                        }
                                }
                        }
                }
        }
        if ((checkaftercid && usedistinctiveringdetection) || !checkaftercid) {
                /* this only shows up if you have n of the dring patterns filled in */
                ast_verb(3, "Detected ring pattern: %d,%d,%d\n",ringdata[0],ringdata[1],ringdata[2]);
                for (counter = 0; counter < 3; counter++) {
                /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
                        distMatches = 0;
                        /* this only shows up if you have n of the dring patterns filled in */
                        ast_verb(3, "Checking %d,%d,%d\n",
                                        p->drings.ringnum[counter].ring[0],
                                        p->drings.ringnum[counter].ring[1],
                                        p->drings.ringnum[counter].ring[2]);
                        for (counter1 = 0; counter1 < 3; counter1++) {
                                ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
                                if (p->drings.ringnum[counter].ring[counter1] == -1) {
                                        ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
                                        ringdata[counter1]);
                                        distMatches++;
                                } else if (ringdata[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
                                                                                ringdata[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
                                        ast_verb(3, "Ring pattern matched in range: %d to %d\n",
                                        (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
                                        (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
                                        distMatches++;
                                }
                        }

                        if (distMatches == 3) {
                                /* The ring matches, set the context to whatever is for distinctive ring.. */
                                ast_copy_string(p->context, p->drings.ringContext[counter].contextData, sizeof(p->context));
                                ast_copy_string(chan->context, p->drings.ringContext[counter].contextData, sizeof(chan->context));
                                ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
                                break;
                        }
                }
        }
        /* Restore linear mode (if appropriate) for Caller*ID processing */
        dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
        restore_gains(p);

        return 0;
}

static int send_callerid(struct dahdi_pvt *p);

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

        return 0;
}

static int save_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);
        }
        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_callerid *cid)
{
        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, cid->cid_name, cid->cid_num, AST_LAW(p));
                } else {
                        p->callwaitcas = 0;
                        p->cidcwexpire = 0;
                        p->cidlen = ast_callerid_callwaiting_generate(p->cidspill, cid->cid_name, cid->cid_num, AST_LAW(p));
                        p->cidlen += READ_SIZE * 4;
                }
                p->cidpos = 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_dtmfup(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, "DTMF digit: %c on %s\n", f->subclass, ast->name);

        if (f->subclass == 'f') {
                /* 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->name, strerror(errno));
                                } else {
                                        p->bufferoverrideinuse = 1;
                                }
                        }
                        p->faxhandled = 1;
                        if (strcmp(ast->exten, "fax")) {
                                const char *target_context = S_OR(ast->macrocontext, ast->context);

                                /* We need to unlock 'ast' here because ast_exists_extension has the
                                 * potential to start autoservice on the channel. Such action is prone
                                 * to deadlock.
                                 */
                                ast_mutex_unlock(&p->lock);
                                ast_channel_unlock(ast);
                                if (ast_exists_extension(ast, target_context, "fax", 1, ast->cid.cid_num)) {
                                        ast_channel_lock(ast);
                                        ast_mutex_lock(&p->lock);
                                        ast_verb(3, "Redirecting %s to fax extension\n", ast->name);
                                        /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
                                        pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast->exten);
                                        if (ast_async_goto(ast, target_context, "fax", 1))
                                                ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast->name, target_context);
                                } else {
                                        ast_channel_lock(ast);
                                        ast_mutex_lock(&p->lock);
                                        ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
                                }
                        } else {
                                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 = 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);
}

/* 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, int idx, int linear_mode)
{
        struct dahdi_pvt *p = pvt;
        int oldval;
        
    if (0 > linear_mode || !dahdi_setlinear(p->subs[idx].dfd, linear_mode)) {
        return -1;
    }
        oldval = p->subs[idx].linear;
        p->subs[idx].linear = linear_mode;
        return oldval;
}

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)
{
        struct dahdi_pvt *p = ast_bridged_channel(chan)->tech_pvt;
        if (p)
                return p->sig_pvt;
        else
                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 *cidrings, 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->name, strerror(errno));
                *cidrings = cidrings[p->distinctivering - 1];
        } else {
                if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
                        ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast->name, strerror(errno));
                *cidrings = p->sendcalleridafter;
        }
}

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

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_log(LOG_DEBUG, "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_usec) {
                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_cancel_cidspill(void *pvt)
{
        struct dahdi_pvt *p = pvt;
        if (p->cidspill) {
                ast_free(p->cidspill);
                p->cidspill = NULL;
        }
}

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_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;
        }

        law = DAHDI_LAW_DEFAULT;
        res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
        if (res < 0)
                ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));

        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;

        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;

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

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

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

        return;
}

static struct ast_channel *dahdi_new(struct dahdi_pvt *, int, int, int, int, int, const char *);

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

        return dahdi_new(p, state, startpbx, dsub, 0, 0, requestor ? requestor->linkedid : "");
}

#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

#if defined(HAVE_PRI)
static struct ast_channel *my_new_pri_ast_channel(void *pvt, int state, int startpbx, enum sig_pri_law law, int transfercapability, char *exten, const struct ast_channel *requestor)
{
        struct dahdi_pvt *p = pvt;
        int audio;
        int newlaw = -1;

        /* 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_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(p, state, startpbx, SUB_REAL, newlaw, transfercapability, requestor ? requestor->linkedid : "");
}
#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 void dahdi_enable_ec(struct dahdi_pvt *p);
static void dahdi_disable_ec(struct dahdi_pvt *p);

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

        if (enable)
                dahdi_enable_ec(p);
        else
                dahdi_disable_ec(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 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)
{
        int index = analogsub_to_dahdisub(sub);
        int res;
        struct dahdi_pvt *p = pvt;
        struct dahdi_dialoperation ddop;

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

        if (sub != ANALOG_SUB_REAL)
                printf("Trying to dial digits on sub %d\n", sub);

        ddop.op = DAHDI_DIAL_OP_REPLACE;
        strncpy(ddop.dialstr, dop->dialstr, sizeof(ddop.dialstr));

        printf("Dialing %s on %d\n", ddop.dialstr, p->channel);

        res = ioctl(p->subs[index].dfd, DAHDI_DIAL, &ddop);

        if (res == -1)
                ast_log(LOG_DEBUG, "DAHDI_DIAL ioctl failed on %s: %s\n", p->owner->name, strerror(errno));

        return res;
}

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_log(LOG_DEBUG, "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) {
                new_chan->owner->tech_pvt = new_chan;
                new_chan->owner->fds[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;
}

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

static void my_handle_dchan_exception(struct sig_pri_pri *pri, int index)
{
        int x, res;

        res = ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
        if (x) {
                ast_log(LOG_NOTICE, "PRI got event: %s (%d) on D-channel of span %d\n", event2str(x), x, pri->span);
        }
        /* Keep track of alarm state */
        if (x == DAHDI_EVENT_ALARM) {
                pri_event_alarm(pri, index, 0);
        } else if (x == DAHDI_EVENT_NOALARM) {
                pri_event_noalarm(pri, index, 0);
        }
}

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

/*!
 * \internal
 * \brief Set the caller id information.
 * \since 1.6.3
 *
 * \param pvt DAHDI private structure
 * \param caller Caller-id information to set.
 *
 * \return Nothing
 */
static void my_pri_set_callerid(void *pvt, const struct ast_party_caller *caller)
{
        struct dahdi_pvt *p = pvt;

        ast_copy_string(p->cid_num, S_OR(caller->id.number, ""), sizeof(p->cid_num));
        ast_copy_string(p->cid_name, S_OR(caller->id.name, ""), sizeof(p->cid_name));
        p->cid_ton = caller->id.number_type;
        p->callingpres = caller->id.number_presentation;
        ast_copy_string(p->cid_ani, S_OR(caller->ani, ""), sizeof(p->cid_ani));
        p->cid_ani2 = caller->ani2;
}

/*!
 * \internal
 * \brief Set the Dialed Number Identifier.
 * \since 1.6.3
 *
 * \param pvt DAHDI private structure
 * \param dnid Dialed Number Identifier string.
 *
 * \return Nothing
 */
static void my_pri_set_dnid(void *pvt, const char *dnid)
{
        struct dahdi_pvt *p = pvt;

        ast_copy_string(p->dnid, dnid, sizeof(p->dnid));
}

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

        ast_copy_string(p->rdnis, rdnis, sizeof(p->rdnis));
}

static int dahdi_new_pri_nobch_channel(struct sig_pri_pri *pri);

static struct sig_pri_callback dahdi_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,
        .new_ast_channel = my_new_pri_ast_channel,
        .fixup_chans = my_pri_fixup_chans,
        .set_dialing = my_set_dialing,
        .set_callerid = my_pri_set_callerid,
        .set_dnid = my_pri_set_dnid,
        .set_rdnis = my_pri_set_rdnis,
        .new_nobch_intf = dahdi_new_pri_nobch_channel,
};
#endif  /* defined(HAVE_PRI) */

/*!
 * \brief Send MWI state change
 *
 * \arg mailbox_full This is the mailbox associated with the FXO line that the
 *      MWI state has changed on.
 * \arg 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_full, int thereornot)
{
        char s[sizeof(mwimonitornotify) + 80];
        struct ast_event *event;
        char *mailbox, *context;

        /* Strip off @default */
        context = mailbox = ast_strdupa(mailbox_full);
        strsep(&context, "@");
        if (ast_strlen_zero(context))
                context = "default";

        if (!(event = ast_event_new(AST_EVENT_MWI,
                        AST_EVENT_IE_MAILBOX, AST_EVENT_IE_PLTYPE_STR, mailbox,
                        AST_EVENT_IE_CONTEXT, AST_EVENT_IE_PLTYPE_STR, context,
                        AST_EVENT_IE_NEWMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot,
                        AST_EVENT_IE_OLDMSGS, AST_EVENT_IE_PLTYPE_UINT, thereornot,
                        AST_EVENT_IE_END))) {
                return;
        }

        ast_event_queue_and_cache(event);

        if (!ast_strlen_zero(mailbox) && !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 struct analog_callback dahdi_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,
        .handle_dtmfup = my_handle_dtmfup,
        .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,
        .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_dialing = my_set_dialing,
        .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,
        .cancel_cidspill = my_cancel_cidspill,
        .confmute = my_confmute,
        .set_pulsedial = my_set_pulsedial,
};

static struct dahdi_pvt *round_robin[32];

#if defined(HAVE_SS7)
static inline void ss7_rel(struct dahdi_ss7 *ss7)
{
        ast_mutex_unlock(&ss7->lock);
}
#endif  /* defined(HAVE_SS7) */

#if defined(HAVE_SS7)
static inline int ss7_grab(struct dahdi_pvt *pvt, struct dahdi_ss7 *pri)
{
        int res;
        /* Grab the lock first */
        do {
                res = ast_mutex_trylock(&pri->lock);
                if (res) {
                        DEADLOCK_AVOIDANCE(&pvt->lock);
                }
        } while (res);
        /* Then break the poll */
        if (pri->master != AST_PTHREADT_NULL)
                pthread_kill(pri->master, SIGURG);
        return 0;
}
#endif  /* defined(HAVE_SS7) */

static int dahdi_get_index(struct ast_channel *ast, struct dahdi_pvt *p, int nullok)
{
        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, and nullok is not asserted\n");
        }
        return res;
}

static void wakeup_sub(struct dahdi_pvt *p, int a)
{
        for (;;) {
                if (p->subs[a].owner) {
                        if (ast_channel_trylock(p->subs[a].owner)) {
                                DEADLOCK_AVOIDANCE(&p->lock);
                        } else {
                                ast_queue_frame(p->subs[a].owner, &ast_null_frame);
                                ast_channel_unlock(p->subs[a].owner);
                                break;
                        }
                } else
                        break;
        }
}

static void dahdi_queue_frame(struct dahdi_pvt *p, struct ast_frame *f, void *data)
{
#ifdef HAVE_SS7
        struct dahdi_ss7 *ss7 = (struct dahdi_ss7*) data;

        if (data) {
                switch (p->sig) {
                case SIG_SS7:
                        ast_mutex_unlock(&ss7->lock);
                        break;
                default:
                        break;
                }
        }
#endif
        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;
        }
#if defined(HAVE_SS7)
        if (data) {
                switch (p->sig) {
                case SIG_SS7:
                        ast_mutex_lock(&ss7->lock);
                        break;
                default:
                        break;
                }
        }
#endif
}

#ifdef HAVE_OPENR2

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 = c->tech_pvt;
        if (ast_strlen_zero(catstr)) {
                ast_debug(1, "No MFC/R2 category specified for chan %s, using default %s\n",
                                c->name, 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, c->name, 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->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);
                handle_alarms(p, res);
        } else {
                ast_log(LOG_NOTICE, "Alarm cleared on channel %d\n", p->channel);
                manager_event(EVENT_FLAG_SYSTEM, "AlarmClear", "Channel: %d\r\n", p->channel);
        }
        ast_mutex_unlock(&p->lock);
}

static void dahdi_r2_on_os_error(openr2_chan_t *r2chan, int errorcode)
{
        ast_log(LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode));
}

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) {
                p->owner->hangupcause = AST_CAUSE_PROTOCOL_ERROR;
                p->owner->_softhangup |= 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_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);
                return;
        }
        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_log(LOG_DEBUG, "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_log(LOG_DEBUG, "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);
                return;
        }
        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, 0, NULL);
                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 */
                        return;
                }
                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_log(LOG_DEBUG, "Accepting MFC/R2 call with charge on chan %d\n", p->channel);
                openr2_chan_accept_call(r2chan, OR2_CALL_WITH_CHARGE);
        } else {
                ast_log(LOG_DEBUG, "Accepting MFC/R2 call with no charge on chan %d\n", p->channel);
                openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE);
        }
}

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_enable_ec(struct dahdi_pvt *p);
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;
        p = openr2_chan_get_client_data(r2chan);
        dahdi_enable_ec(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_log(LOG_DEBUG, "Answering MFC/R2 call after accepting it on chan %d\n", openr2_chan_get_number(r2chan));
                                dahdi_r2_answer(p);
                        }
                        return;
                }
                c = dahdi_new(p, AST_STATE_RING, 1, SUB_REAL, DAHDI_LAW_ALAW, 0, NULL);
                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);
                        return;
                }
                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);
                return;
        }
        /* 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);
}

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_log(LOG_DEBUG, "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);
        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;
        }
        /* when we have an owner we don't call dahdi_r2_disconnect_call here, that will
           be done in dahdi_hangup */
        if (p->owner->_state == AST_STATE_UP) {
                p->owner->_softhangup |= 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:
                        p->owner->_softhangup |= 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_log(LOG_DEBUG, "%s", logmessage);
                break;
        default:
                ast_log(LOG_WARNING, "We should handle logging level %d here.\n", level);
                ast_log(LOG_DEBUG, "%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->fds[fd_num]);
        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 = -1;
        int res;

        pvt = chan->tech_pvt;

        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
        if ((dtmf = digit_to_dtmfindex(digit)) == -1)
                goto out;

        if (pvt->pulse || ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &dtmf)) {
                struct dahdi_dialoperation zo = {
                        .op = DAHDI_DIAL_OP_APPEND,
                };

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

out:
        ast_mutex_unlock(&pvt->lock);

        return 0;
}

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

        pvt = chan->tech_pvt;

        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, "Ending VLDTMF digit '%c'\n", digit);
                res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_SENDTONE, &x);
                pvt->dialing = 0;
                pvt->begindigit = 0;
        }

out:
        ast_mutex_unlock(&pvt->lock);