Make number not available presentation also set screening to network provided.

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

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2009, 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 PRI signaling module
 *
 * \author Matthew Fredrickson <creslin@digium.com>
 */


#include "asterisk.h"

#ifdef HAVE_PRI

#include <errno.h>
#include <ctype.h>
#include <signal.h>

#include "asterisk/utils.h"
#include "asterisk/options.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/file.h"
#include "asterisk/callerid.h"
#include "asterisk/say.h"
#include "asterisk/manager.h"
#include "asterisk/astdb.h"
#include "asterisk/causes.h"
#include "asterisk/musiconhold.h"
#include "asterisk/cli.h"
#include "asterisk/transcap.h"
#include "asterisk/features.h"
#include "asterisk/aoc.h"

#include "sig_pri.h"
#ifndef PRI_EVENT_FACILITY
#error please update libpri
#endif

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

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

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

#if defined(HAVE_PRI_CCSS)
struct sig_pri_cc_agent_prv {
        /*! Asterisk span D channel control structure. */
        struct sig_pri_span *pri;
        /*! CC id value to use with libpri. -1 if invalid. */
        long cc_id;
        /*! TRUE if CC has been requested and we are waiting for the response. */
        unsigned char cc_request_response_pending;
};

struct sig_pri_cc_monitor_instance {
        /*! \brief Asterisk span D channel control structure. */
        struct sig_pri_span *pri;
        /*! CC id value to use with libpri. (-1 if already canceled). */
        long cc_id;
        /*! CC core id value. */
        int core_id;
        /*! Device name(Channel name less sequence number) */
        char name[1];
};

/*! Upper level agent/monitor type name. */
static const char *sig_pri_cc_type_name;
/*! Container of sig_pri monitor instances. */
static struct ao2_container *sig_pri_cc_monitors;
#endif  /* defined(HAVE_PRI_CCSS) */

static int pri_matchdigittimeout = 3000;

static int pri_gendigittimeout = 8000;

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

/* Defines to help decode the encoded event channel id. */
#define PRI_CHANNEL(p)  ((p) & 0xff)
#define PRI_SPAN(p)             (((p) >> 8) & 0xff)
#define PRI_EXPLICIT    (1 << 16)
#define PRI_CIS_CALL    (1 << 17)       /* Call is using the D channel only. */
#define PRI_HELD_CALL   (1 << 18)


#define DCHAN_AVAILABLE (DCHAN_NOTINALARM | DCHAN_UP)

#define PRI_DEADLOCK_AVOIDANCE(p) \
        do { \
                sig_pri_unlock_private(p); \
                usleep(1); \
                sig_pri_lock_private(p); \
        } while (0)

static int pri_active_dchan_index(struct sig_pri_span *pri);

static const char *sig_pri_call_level2str(enum sig_pri_call_level level)
{
        switch (level) {
        case SIG_PRI_CALL_LEVEL_IDLE:
                return "Idle";
        case SIG_PRI_CALL_LEVEL_SETUP:
                return "Setup";
        case SIG_PRI_CALL_LEVEL_OVERLAP:
                return "Overlap";
        case SIG_PRI_CALL_LEVEL_PROCEEDING:
                return "Proceeding";
        case SIG_PRI_CALL_LEVEL_ALERTING:
                return "Alerting";
        case SIG_PRI_CALL_LEVEL_DEFER_DIAL:
                return "DeferDial";
        case SIG_PRI_CALL_LEVEL_CONNECT:
                return "Connect";
        }
        return "Unknown";
}

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

static unsigned int PVT_TO_CHANNEL(struct sig_pri_chan *p)
{
        int res = (((p)->prioffset) | ((p)->logicalspan << 8) | (p->mastertrunkgroup ? PRI_EXPLICIT : 0));
        ast_debug(5, "prioffset: %d mastertrunkgroup: %d logicalspan: %d result: %d\n",
                p->prioffset, p->mastertrunkgroup, p->logicalspan, res);

        return res;
}

static void sig_pri_handle_dchan_exception(struct sig_pri_span *pri, int index)
{
        if (pri->calls->handle_dchan_exception)
                pri->calls->handle_dchan_exception(pri, index);
}

static void sig_pri_set_dialing(struct sig_pri_chan *p, int is_dialing)
{
        if (p->calls->set_dialing) {
                p->calls->set_dialing(p->chan_pvt, is_dialing);
        }
}

static void sig_pri_set_digital(struct sig_pri_chan *p, int is_digital)
{
        p->digital = is_digital;
        if (p->calls->set_digital) {
                p->calls->set_digital(p->chan_pvt, is_digital);
        }
}

static void sig_pri_set_outgoing(struct sig_pri_chan *p, int is_outgoing)
{
        p->outgoing = is_outgoing;
        if (p->calls->set_outgoing) {
                p->calls->set_outgoing(p->chan_pvt, is_outgoing);
        }
}

void sig_pri_set_alarm(struct sig_pri_chan *p, int in_alarm)
{
        /*
         * Clear the channel restart flag when the channel alarm changes
         * to prevent the flag from getting stuck when the link goes
         * down.
         */
        p->resetting = 0;

        p->inalarm = in_alarm;
        if (p->calls->set_alarm) {
                p->calls->set_alarm(p->chan_pvt, in_alarm);
        }
}

static const char *sig_pri_get_orig_dialstring(struct sig_pri_chan *p)
{
        if (p->calls->get_orig_dialstring) {
                return p->calls->get_orig_dialstring(p->chan_pvt);
        }
        ast_log(LOG_ERROR, "get_orig_dialstring callback not defined\n");
        return "";
}

#if defined(HAVE_PRI_CCSS)
static void sig_pri_make_cc_dialstring(struct sig_pri_chan *p, char *buf, size_t buf_size)
{
        if (p->calls->make_cc_dialstring) {
                p->calls->make_cc_dialstring(p->chan_pvt, buf, buf_size);
        } else {
                ast_log(LOG_ERROR, "make_cc_dialstring callback not defined\n");
                buf[0] = '\0';
        }
}
#endif  /* defined(HAVE_PRI_CCSS) */

static void sig_pri_dial_digits(struct sig_pri_chan *p, const char *dial_string)
{
        if (p->calls->dial_digits) {
                p->calls->dial_digits(p->chan_pvt, dial_string);
        }
}

/*!
 * \internal
 * \brief Reevaluate the PRI span device state.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 *
 * \return Nothing
 *
 * \note Assumes the pri->lock is already obtained.
 */
static void sig_pri_span_devstate_changed(struct sig_pri_span *pri)
{
        if (pri->calls->update_span_devstate) {
                pri->calls->update_span_devstate(pri);
        }
}

/*!
 * \internal
 * \brief Set the caller id information in the parent module.
 * \since 1.8
 *
 * \param p sig_pri channel structure.
 *
 * \return Nothing
 */
static void sig_pri_set_caller_id(struct sig_pri_chan *p)
{
        struct ast_party_caller caller;

        if (p->calls->set_callerid) {
                ast_party_caller_init(&caller);

                caller.id.name.str = p->cid_name;
                caller.id.name.presentation = p->callingpres;
                caller.id.name.valid = 1;

                caller.id.number.str = p->cid_num;
                caller.id.number.plan = p->cid_ton;
                caller.id.number.presentation = p->callingpres;
                caller.id.number.valid = 1;

                if (!ast_strlen_zero(p->cid_subaddr)) {
                        caller.id.subaddress.valid = 1;
                        //caller.id.subaddress.type = 0;/* nsap */
                        //caller.id.subaddress.odd_even_indicator = 0;
                        caller.id.subaddress.str = p->cid_subaddr;
                }
                caller.id.tag = p->user_tag;

                caller.ani.number.str = p->cid_ani;
                //caller.ani.number.plan = p->xxx;
                //caller.ani.number.presentation = p->xxx;
                caller.ani.number.valid = 1;

                caller.ani2 = p->cid_ani2;
                p->calls->set_callerid(p->chan_pvt, &caller);
        }
}

/*!
 * \internal
 * \brief Set the Dialed Number Identifier.
 * \since 1.8
 *
 * \param p sig_pri channel structure.
 * \param dnid Dialed Number Identifier string.
 *
 * \return Nothing
 */
static void sig_pri_set_dnid(struct sig_pri_chan *p, const char *dnid)
{
        if (p->calls->set_dnid) {
                p->calls->set_dnid(p->chan_pvt, dnid);
        }
}

/*!
 * \internal
 * \brief Set the Redirecting Directory Number Information Service (RDNIS).
 * \since 1.8
 *
 * \param p sig_pri channel structure.
 * \param rdnis Redirecting Directory Number Information Service (RDNIS) string.
 *
 * \return Nothing
 */
static void sig_pri_set_rdnis(struct sig_pri_chan *p, const char *rdnis)
{
        if (p->calls->set_rdnis) {
                p->calls->set_rdnis(p->chan_pvt, rdnis);
        }
}

static void sig_pri_unlock_private(struct sig_pri_chan *p)
{
        if (p->calls->unlock_private)
                p->calls->unlock_private(p->chan_pvt);
}

static void sig_pri_lock_private(struct sig_pri_chan *p)
{
        if (p->calls->lock_private)
                p->calls->lock_private(p->chan_pvt);
}

static void sig_pri_deadlock_avoidance_private(struct sig_pri_chan *p)
{
        if (p->calls->deadlock_avoidance_private) {
                p->calls->deadlock_avoidance_private(p->chan_pvt);
        } else {
                /* Fallback to the old way if callback not present. */
                PRI_DEADLOCK_AVOIDANCE(p);
        }
}

static void pri_grab(struct sig_pri_chan *p, struct sig_pri_span *pri)
{
        int res;

        /* Grab the lock first */
        do {
                res = ast_mutex_trylock(&pri->lock);
                if (res) {
                        sig_pri_deadlock_avoidance_private(p);
                }
        } while (res);
        /* Then break the poll */
        pthread_kill(pri->master, SIGURG);
}

/*!
 * \internal
 * \brief Convert PRI redirecting reason to asterisk version.
 * \since 1.8
 *
 * \param pri_reason PRI redirecting reason.
 *
 * \return Equivalent asterisk redirecting reason value.
 */
static enum AST_REDIRECTING_REASON pri_to_ast_reason(int pri_reason)
{
        enum AST_REDIRECTING_REASON ast_reason;

        switch (pri_reason) {
        case PRI_REDIR_FORWARD_ON_BUSY:
                ast_reason = AST_REDIRECTING_REASON_USER_BUSY;
                break;
        case PRI_REDIR_FORWARD_ON_NO_REPLY:
                ast_reason = AST_REDIRECTING_REASON_NO_ANSWER;
                break;
        case PRI_REDIR_DEFLECTION:
                ast_reason = AST_REDIRECTING_REASON_DEFLECTION;
                break;
        case PRI_REDIR_UNCONDITIONAL:
                ast_reason = AST_REDIRECTING_REASON_UNCONDITIONAL;
                break;
        case PRI_REDIR_UNKNOWN:
        default:
                ast_reason = AST_REDIRECTING_REASON_UNKNOWN;
                break;
        }

        return ast_reason;
}

/*!
 * \internal
 * \brief Convert asterisk redirecting reason to PRI version.
 * \since 1.8
 *
 * \param ast_reason Asterisk redirecting reason.
 *
 * \return Equivalent PRI redirecting reason value.
 */
static int ast_to_pri_reason(enum AST_REDIRECTING_REASON ast_reason)
{
        int pri_reason;

        switch (ast_reason) {
        case AST_REDIRECTING_REASON_USER_BUSY:
                pri_reason = PRI_REDIR_FORWARD_ON_BUSY;
                break;
        case AST_REDIRECTING_REASON_NO_ANSWER:
                pri_reason = PRI_REDIR_FORWARD_ON_NO_REPLY;
                break;
        case AST_REDIRECTING_REASON_UNCONDITIONAL:
                pri_reason = PRI_REDIR_UNCONDITIONAL;
                break;
        case AST_REDIRECTING_REASON_DEFLECTION:
                pri_reason = PRI_REDIR_DEFLECTION;
                break;
        case AST_REDIRECTING_REASON_UNKNOWN:
        default:
                pri_reason = PRI_REDIR_UNKNOWN;
                break;
        }

        return pri_reason;
}

/*!
 * \internal
 * \brief Convert PRI number presentation to asterisk version.
 * \since 1.8
 *
 * \param pri_presentation PRI number presentation.
 *
 * \return Equivalent asterisk number presentation value.
 */
static int pri_to_ast_presentation(int pri_presentation)
{
        int ast_presentation;

        switch (pri_presentation) {
        case PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_UNSCREENED:
                ast_presentation = AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_UNSCREENED;
                break;
        case PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_PASSED_SCREEN:
                ast_presentation = AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_PASSED_SCREEN;
                break;
        case PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_FAILED_SCREEN:
                ast_presentation = AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_FAILED_SCREEN;
                break;
        case PRI_PRES_ALLOWED | PRI_PRES_NETWORK_NUMBER:
                ast_presentation = AST_PRES_ALLOWED | AST_PRES_NETWORK_NUMBER;
                break;

        case PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_UNSCREENED:
                ast_presentation = AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_UNSCREENED;
                break;
        case PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_PASSED_SCREEN:
                ast_presentation = AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_PASSED_SCREEN;
                break;
        case PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_FAILED_SCREEN:
                ast_presentation = AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_FAILED_SCREEN;
                break;
        case PRI_PRES_RESTRICTED | PRI_PRES_NETWORK_NUMBER:
                ast_presentation = AST_PRES_RESTRICTED | AST_PRES_NETWORK_NUMBER;
                break;

        case PRI_PRES_UNAVAILABLE | PRI_PRES_USER_NUMBER_UNSCREENED:
        case PRI_PRES_UNAVAILABLE | PRI_PRES_USER_NUMBER_PASSED_SCREEN:
        case PRI_PRES_UNAVAILABLE | PRI_PRES_USER_NUMBER_FAILED_SCREEN:
        case PRI_PRES_UNAVAILABLE | PRI_PRES_NETWORK_NUMBER:
                ast_presentation = AST_PRES_NUMBER_NOT_AVAILABLE;
                break;

        default:
                ast_presentation = AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_UNSCREENED;
                break;
        }

        return ast_presentation;
}

/*!
 * \internal
 * \brief Convert asterisk number presentation to PRI version.
 * \since 1.8
 *
 * \param ast_presentation Asterisk number presentation.
 *
 * \return Equivalent PRI number presentation value.
 */
static int ast_to_pri_presentation(int ast_presentation)
{
        int pri_presentation;

        switch (ast_presentation) {
        case AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_UNSCREENED:
                pri_presentation = PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_UNSCREENED;
                break;
        case AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_PASSED_SCREEN:
                pri_presentation = PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_PASSED_SCREEN;
                break;
        case AST_PRES_ALLOWED | AST_PRES_USER_NUMBER_FAILED_SCREEN:
                pri_presentation = PRI_PRES_ALLOWED | PRI_PRES_USER_NUMBER_FAILED_SCREEN;
                break;
        case AST_PRES_ALLOWED | AST_PRES_NETWORK_NUMBER:
                pri_presentation = PRI_PRES_ALLOWED | PRI_PRES_NETWORK_NUMBER;
                break;

        case AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_UNSCREENED:
                pri_presentation = PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_UNSCREENED;
                break;
        case AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_PASSED_SCREEN:
                pri_presentation = PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_PASSED_SCREEN;
                break;
        case AST_PRES_RESTRICTED | AST_PRES_USER_NUMBER_FAILED_SCREEN:
                pri_presentation = PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_FAILED_SCREEN;
                break;
        case AST_PRES_RESTRICTED | AST_PRES_NETWORK_NUMBER:
                pri_presentation = PRI_PRES_RESTRICTED | PRI_PRES_NETWORK_NUMBER;
                break;

        case AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_UNSCREENED:
        case AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_PASSED_SCREEN:
        case AST_PRES_UNAVAILABLE | AST_PRES_USER_NUMBER_FAILED_SCREEN:
        case AST_PRES_UNAVAILABLE | AST_PRES_NETWORK_NUMBER:
                pri_presentation = PRES_NUMBER_NOT_AVAILABLE;
                break;

        default:
                pri_presentation = PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_UNSCREENED;
                break;
        }

        return pri_presentation;
}

/*!
 * \internal
 * \brief Convert PRI name char_set to asterisk version.
 * \since 1.8
 *
 * \param pri_char_set PRI name char_set.
 *
 * \return Equivalent asterisk name char_set value.
 */
static enum AST_PARTY_CHAR_SET pri_to_ast_char_set(int pri_char_set)
{
        enum AST_PARTY_CHAR_SET ast_char_set;

        switch (pri_char_set) {
        default:
        case PRI_CHAR_SET_UNKNOWN:
                ast_char_set = AST_PARTY_CHAR_SET_UNKNOWN;
                break;
        case PRI_CHAR_SET_ISO8859_1:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_1;
                break;
        case PRI_CHAR_SET_WITHDRAWN:
                ast_char_set = AST_PARTY_CHAR_SET_WITHDRAWN;
                break;
        case PRI_CHAR_SET_ISO8859_2:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_2;
                break;
        case PRI_CHAR_SET_ISO8859_3:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_3;
                break;
        case PRI_CHAR_SET_ISO8859_4:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_4;
                break;
        case PRI_CHAR_SET_ISO8859_5:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_5;
                break;
        case PRI_CHAR_SET_ISO8859_7:
                ast_char_set = AST_PARTY_CHAR_SET_ISO8859_7;
                break;
        case PRI_CHAR_SET_ISO10646_BMPSTRING:
                ast_char_set = AST_PARTY_CHAR_SET_ISO10646_BMPSTRING;
                break;
        case PRI_CHAR_SET_ISO10646_UTF_8STRING:
                ast_char_set = AST_PARTY_CHAR_SET_ISO10646_UTF_8STRING;
                break;
        }

        return ast_char_set;
}

/*!
 * \internal
 * \brief Convert asterisk name char_set to PRI version.
 * \since 1.8
 *
 * \param ast_char_set Asterisk name char_set.
 *
 * \return Equivalent PRI name char_set value.
 */
static int ast_to_pri_char_set(enum AST_PARTY_CHAR_SET ast_char_set)
{
        int pri_char_set;

        switch (ast_char_set) {
        default:
        case AST_PARTY_CHAR_SET_UNKNOWN:
                pri_char_set = PRI_CHAR_SET_UNKNOWN;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_1:
                pri_char_set = PRI_CHAR_SET_ISO8859_1;
                break;
        case AST_PARTY_CHAR_SET_WITHDRAWN:
                pri_char_set = PRI_CHAR_SET_WITHDRAWN;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_2:
                pri_char_set = PRI_CHAR_SET_ISO8859_2;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_3:
                pri_char_set = PRI_CHAR_SET_ISO8859_3;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_4:
                pri_char_set = PRI_CHAR_SET_ISO8859_4;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_5:
                pri_char_set = PRI_CHAR_SET_ISO8859_5;
                break;
        case AST_PARTY_CHAR_SET_ISO8859_7:
                pri_char_set = PRI_CHAR_SET_ISO8859_7;
                break;
        case AST_PARTY_CHAR_SET_ISO10646_BMPSTRING:
                pri_char_set = PRI_CHAR_SET_ISO10646_BMPSTRING;
                break;
        case AST_PARTY_CHAR_SET_ISO10646_UTF_8STRING:
                pri_char_set = PRI_CHAR_SET_ISO10646_UTF_8STRING;
                break;
        }

        return pri_char_set;
}

#if defined(HAVE_PRI_SUBADDR)
/*!
 * \internal
 * \brief Fill in the asterisk party subaddress from the given PRI party subaddress.
 * \since 1.8
 *
 * \param ast_subaddress Asterisk party subaddress structure.
 * \param pri_subaddress PRI party subaddress structure.
 *
 * \return Nothing
 *
 */
static void sig_pri_set_subaddress(struct ast_party_subaddress *ast_subaddress, const struct pri_party_subaddress *pri_subaddress)
{
        char *cnum, *ptr;
        int x, len;

        if (ast_subaddress->str) {
                ast_free(ast_subaddress->str);
        }
        if (pri_subaddress->length <= 0) {
                ast_party_subaddress_init(ast_subaddress);
                return;
        }

        if (!pri_subaddress->type) {
                /* NSAP */
                ast_subaddress->str = ast_strdup((char *) pri_subaddress->data);
        } else {
                /* User Specified */
                if (!(cnum = ast_malloc(2 * pri_subaddress->length + 1))) {
                        ast_party_subaddress_init(ast_subaddress);
                        return;
                }

                ptr = cnum;
                len = pri_subaddress->length - 1; /* -1 account for zero based indexing */
                for (x = 0; x < len; ++x) {
                        ptr += sprintf(ptr, "%02x", pri_subaddress->data[x]);
                }

                if (pri_subaddress->odd_even_indicator) {
                        /* ODD */
                        sprintf(ptr, "%01x", (pri_subaddress->data[len]) >> 4);
                } else {
                        /* EVEN */
                        sprintf(ptr, "%02x", pri_subaddress->data[len]);
                }
                ast_subaddress->str = cnum;
        }
        ast_subaddress->type = pri_subaddress->type;
        ast_subaddress->odd_even_indicator = pri_subaddress->odd_even_indicator;
        ast_subaddress->valid = 1;
}
#endif  /* defined(HAVE_PRI_SUBADDR) */

#if defined(HAVE_PRI_SUBADDR)
static unsigned char ast_pri_pack_hex_char(char c)
{
        unsigned char res;

        if (c < '0') {
                res = 0;
        } else if (c < ('9' + 1)) {
                res = c - '0';
        } else if (c < 'A') {
                res = 0;
        } else if (c < ('F' + 1)) {
                res = c - 'A' + 10;
        } else if (c < 'a') {
                res = 0;
        } else if (c < ('f' + 1)) {
                res = c - 'a' + 10;
        } else {
                res = 0;
        }
        return res;
}
#endif  /* defined(HAVE_PRI_SUBADDR) */

#if defined(HAVE_PRI_SUBADDR)
/*!
 * \internal
 * \brief Convert a null terminated hexadecimal string to a packed hex byte array.
 * \details left justified, with 0 padding if odd length.
 * \since 1.8
 *
 * \param dst pointer to packed byte array.
 * \param src pointer to null terminated hexadecimal string.
 * \param maxlen destination array size.
 *
 * \return Length of byte array
 *
 * \note The dst is not an ASCIIz string.
 * \note The src is an ASCIIz hex string.
 */
static int ast_pri_pack_hex_string(unsigned char *dst, char *src, int maxlen)
{
        int res = 0;
        int len = strlen(src);

        if (len > (2 * maxlen)) {
                len = 2 * maxlen;
        }

        res = len / 2 + len % 2;

        while (len > 1) {
                *dst = ast_pri_pack_hex_char(*src) << 4;
                src++;
                *dst |= ast_pri_pack_hex_char(*src);
                dst++, src++;
                len -= 2;
        }
        if (len) { /* 1 left */
                *dst = ast_pri_pack_hex_char(*src) << 4;
        }
        return res;
}
#endif  /* defined(HAVE_PRI_SUBADDR) */

#if defined(HAVE_PRI_SUBADDR)
/*!
 * \internal
 * \brief Fill in the PRI party subaddress from the given asterisk party subaddress.
 * \since 1.8
 *
 * \param pri_subaddress PRI party subaddress structure.
 * \param ast_subaddress Asterisk party subaddress structure.
 *
 * \return Nothing
 *
 * \note Assumes that pri_subaddress has been previously memset to zero.
 */
static void sig_pri_party_subaddress_from_ast(struct pri_party_subaddress *pri_subaddress, const struct ast_party_subaddress *ast_subaddress)
{
        if (ast_subaddress->valid && !ast_strlen_zero(ast_subaddress->str)) {
                pri_subaddress->type = ast_subaddress->type;
                if (!ast_subaddress->type) {
                        /* 0 = NSAP */
                        ast_copy_string((char *) pri_subaddress->data, ast_subaddress->str,
                                sizeof(pri_subaddress->data));
                        pri_subaddress->length = strlen((char *) pri_subaddress->data);
                        pri_subaddress->odd_even_indicator = 0;
                        pri_subaddress->valid = 1;
                } else {
                        /* 2 = User Specified */
                        /*
                         * Copy HexString to packed HexData,
                         * if odd length then right pad trailing byte with 0
                         */
                        int length = ast_pri_pack_hex_string(pri_subaddress->data,
                                ast_subaddress->str, sizeof(pri_subaddress->data));

                        pri_subaddress->length = length; /* packed data length */

                        length = strlen(ast_subaddress->str);
                        if (length > 2 * sizeof(pri_subaddress->data)) {
                                pri_subaddress->odd_even_indicator = 0;
                        } else {
                                pri_subaddress->odd_even_indicator = (length & 1);
                        }
                        pri_subaddress->valid = 1;
                }
        }
}
#endif  /* defined(HAVE_PRI_SUBADDR) */

/*!
 * \internal
 * \brief Fill in the PRI party name from the given asterisk party name.
 * \since 1.8
 *
 * \param pri_name PRI party name structure.
 * \param ast_name Asterisk party name structure.
 *
 * \return Nothing
 *
 * \note Assumes that pri_name has been previously memset to zero.
 */
static void sig_pri_party_name_from_ast(struct pri_party_name *pri_name, const struct ast_party_name *ast_name)
{
        if (!ast_name->valid) {
                return;
        }
        pri_name->valid = 1;
        pri_name->presentation = ast_to_pri_presentation(ast_name->presentation);
        pri_name->char_set = ast_to_pri_char_set(ast_name->char_set);
        if (!ast_strlen_zero(ast_name->str)) {
                ast_copy_string(pri_name->str, ast_name->str, sizeof(pri_name->str));
        }
}

/*!
 * \internal
 * \brief Fill in the PRI party number from the given asterisk party number.
 * \since 1.8
 *
 * \param pri_number PRI party number structure.
 * \param ast_number Asterisk party number structure.
 *
 * \return Nothing
 *
 * \note Assumes that pri_number has been previously memset to zero.
 */
static void sig_pri_party_number_from_ast(struct pri_party_number *pri_number, const struct ast_party_number *ast_number)
{
        if (!ast_number->valid) {
                return;
        }
        pri_number->valid = 1;
        pri_number->presentation = ast_to_pri_presentation(ast_number->presentation);
        pri_number->plan = ast_number->plan;
        if (!ast_strlen_zero(ast_number->str)) {
                ast_copy_string(pri_number->str, ast_number->str, sizeof(pri_number->str));
        }
}

/*!
 * \internal
 * \brief Fill in the PRI party id from the given asterisk party id.
 * \since 1.8
 *
 * \param pri_id PRI party id structure.
 * \param ast_id Asterisk party id structure.
 *
 * \return Nothing
 *
 * \note Assumes that pri_id has been previously memset to zero.
 */
static void sig_pri_party_id_from_ast(struct pri_party_id *pri_id, const struct ast_party_id *ast_id)
{
        sig_pri_party_name_from_ast(&pri_id->name, &ast_id->name);
        sig_pri_party_number_from_ast(&pri_id->number, &ast_id->number);
#if defined(HAVE_PRI_SUBADDR)
        sig_pri_party_subaddress_from_ast(&pri_id->subaddress, &ast_id->subaddress);
#endif  /* defined(HAVE_PRI_SUBADDR) */
}

/*!
 * \internal
 * \brief Update the PRI redirecting information for the current call.
 * \since 1.8
 *
 * \param pvt sig_pri private channel structure.
 * \param ast Asterisk channel
 *
 * \return Nothing
 *
 * \note Assumes that the PRI lock is already obtained.
 */
static void sig_pri_redirecting_update(struct sig_pri_chan *pvt, struct ast_channel *ast)
{
        struct pri_party_redirecting pri_redirecting;

/*! \todo XXX Original called data can be put in a channel data store that is inherited. */

        memset(&pri_redirecting, 0, sizeof(pri_redirecting));
        sig_pri_party_id_from_ast(&pri_redirecting.from, &ast_channel_redirecting(ast)->from);
        sig_pri_party_id_from_ast(&pri_redirecting.to, &ast_channel_redirecting(ast)->to);
        pri_redirecting.count = ast_channel_redirecting(ast)->count;
        pri_redirecting.reason = ast_to_pri_reason(ast_channel_redirecting(ast)->reason);

        pri_redirecting_update(pvt->pri->pri, pvt->call, &pri_redirecting);
}

/*!
 * \internal
 * \brief Reset DTMF detector.
 * \since 1.8
 *
 * \param p sig_pri channel structure.
 *
 * \return Nothing
 */
static void sig_pri_dsp_reset_and_flush_digits(struct sig_pri_chan *p)
{
        if (p->calls->dsp_reset_and_flush_digits) {
                p->calls->dsp_reset_and_flush_digits(p->chan_pvt);
        }
}

static int sig_pri_set_echocanceller(struct sig_pri_chan *p, int enable)
{
        if (p->calls->set_echocanceller)
                return p->calls->set_echocanceller(p->chan_pvt, enable);
        else
                return -1;
}

static void sig_pri_fixup_chans(struct sig_pri_chan *old_chan, struct sig_pri_chan *new_chan)
{
        if (old_chan->calls->fixup_chans)
                old_chan->calls->fixup_chans(old_chan->chan_pvt, new_chan->chan_pvt);
}

static int sig_pri_play_tone(struct sig_pri_chan *p, enum sig_pri_tone tone)
{
        if (p->calls->play_tone)
                return p->calls->play_tone(p->chan_pvt, tone);
        else
                return -1;
}

static struct ast_channel *sig_pri_new_ast_channel(struct sig_pri_chan *p, int state, int ulaw, int transfercapability, char *exten, const struct ast_channel *requestor)
{
        struct ast_channel *c;

        if (p->calls->new_ast_channel) {
                c = p->calls->new_ast_channel(p->chan_pvt, state, ulaw, exten, requestor);
        } else {
                return NULL;
        }
        if (!c) {
                return NULL;
        }

        if (!p->owner)
                p->owner = c;
        p->isidlecall = 0;
        p->alreadyhungup = 0;
        ast_channel_transfercapability_set(c, transfercapability);
        pbx_builtin_setvar_helper(c, "TRANSFERCAPABILITY",
                ast_transfercapability2str(transfercapability));
        if (transfercapability & AST_TRANS_CAP_DIGITAL) {
                sig_pri_set_digital(p, 1);
        }
        if (p->pri) {
                ast_mutex_lock(&p->pri->lock);
                sig_pri_span_devstate_changed(p->pri);
                ast_mutex_unlock(&p->pri->lock);
        }

        return c;
}

/*!
 * \internal
 * \brief Open the PRI channel media path.
 * \since 1.8
 *
 * \param p Channel private control structure.
 *
 * \return Nothing
 */
static void sig_pri_open_media(struct sig_pri_chan *p)
{
        if (p->no_b_channel) {
                return;
        }

        if (p->calls->open_media) {
                p->calls->open_media(p->chan_pvt);
        }
}

/*!
 * \internal
 * \brief Post an AMI B channel association event.
 * \since 1.8
 *
 * \param p Channel private control structure.
 *
 * \note Assumes the private and owner are locked.
 *
 * \return Nothing
 */
static void sig_pri_ami_channel_event(struct sig_pri_chan *p)
{
        if (p->calls->ami_channel_event) {
                p->calls->ami_channel_event(p->chan_pvt, p->owner);
        }
}

struct ast_channel *sig_pri_request(struct sig_pri_chan *p, enum sig_pri_law law, const struct ast_channel *requestor, int transfercapability)
{
        struct ast_channel *ast;

        ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);

        sig_pri_set_outgoing(p, 1);
        ast = sig_pri_new_ast_channel(p, AST_STATE_RESERVED, law, transfercapability, p->exten, requestor);
        if (!ast) {
                sig_pri_set_outgoing(p, 0);
        }
        return ast;
}

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

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

/* Returns index of the active dchan */
static int pri_active_dchan_index(struct sig_pri_span *pri)
{
        int x;

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

        ast_log(LOG_WARNING, "No active dchan found!\n");
        return -1;
}

static void pri_find_dchan(struct sig_pri_span *pri)
{
        struct pri *old;
        int oldslot = -1;
        int newslot = -1;
        int idx;

        old = pri->pri;
        for (idx = 0; idx < SIG_PRI_NUM_DCHANS; ++idx) {
                if (!pri->dchans[idx]) {
                        /* No more D channels defined on the span. */
                        break;
                }
                if (pri->dchans[idx] == old) {
                        oldslot = idx;
                }
                if (newslot < 0 && pri->dchanavail[idx] == DCHAN_AVAILABLE) {
                        newslot = idx;
                }
        }
        /* At this point, idx is a count of how many D-channels are defined on the span. */

        if (1 < idx) {
                /* We have several D-channels defined on the span.  (NFAS PRI setup) */
                if (newslot < 0) {
                        /* No D-channels available.  Default to the primary D-channel. */
                        newslot = 0;

                        if (!pri->no_d_channels) {
                                pri->no_d_channels = 1;
                                if (old && oldslot != newslot) {
                                        ast_log(LOG_WARNING,
                                                "Span %d: No D-channels up!  Switching selected D-channel from %s to %s.\n",
                                                pri->span, pri_order(oldslot), pri_order(newslot));
                                } else {
                                        ast_log(LOG_WARNING, "Span %d: No D-channels up!\n", pri->span);
                                }
                        }
                } else {
                        pri->no_d_channels = 0;
                }
                if (old && oldslot != newslot) {
                        ast_log(LOG_NOTICE,
                                "Switching selected D-channel from %s (fd %d) to %s (fd %d)!\n",
                                pri_order(oldslot), pri->fds[oldslot],
                                pri_order(newslot), pri->fds[newslot]);
                }
        } else {
                if (newslot < 0) {
                        /* The only D-channel is not up. */
                        newslot = 0;

                        if (!pri->no_d_channels) {
                                pri->no_d_channels = 1;

                                /*
                                 * This is annoying to see on non-persistent layer 2
                                 * connections.  Let's not complain in that case.
                                 */
                                if (pri->sig != SIG_BRI_PTMP) {
                                        ast_log(LOG_WARNING, "Span %d: D-channel is down!\n", pri->span);
                                }
                        }
                } else {
                        pri->no_d_channels = 0;
                }
        }
        pri->pri = pri->dchans[newslot];
}

/*!
 * \internal
 * \brief Determine if a private channel structure is in use.
 * \since 1.8
 *
 * \param pvt Channel to determine if in use.
 *
 * \return TRUE if the channel is in use.
 */
static int sig_pri_is_chan_in_use(struct sig_pri_chan *pvt)
{
        return pvt->owner || pvt->call || pvt->allocated || pvt->resetting || pvt->inalarm;
}

/*!
 * \brief Determine if a private channel structure is available.
 * \since 1.8
 *
 * \param pvt Channel to determine if available.
 *
 * \return TRUE if the channel is available.
 */
int sig_pri_is_chan_available(struct sig_pri_chan *pvt)
{
        return !sig_pri_is_chan_in_use(pvt)
#if defined(HAVE_PRI_SERVICE_MESSAGES)
                /* And not out-of-service */
                && !pvt->service_status
#endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
                ;
}

/*!
 * \internal
 * \brief Obtain the sig_pri owner channel lock if the owner exists.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param chanpos Channel position in the span.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_lock_owner(struct sig_pri_span *pri, int chanpos)
{
        for (;;) {
                if (!pri->pvts[chanpos]->owner) {
                        /* There is no owner lock to get. */
                        break;
                }
                if (!ast_channel_trylock(pri->pvts[chanpos]->owner)) {
                        /* We got the lock */
                        break;
                }
                /* We must unlock the PRI to avoid the possibility of a deadlock */
                ast_mutex_unlock(&pri->lock);
                sig_pri_deadlock_avoidance_private(pri->pvts[chanpos]);
                ast_mutex_lock(&pri->lock);
        }
}

/*!
 * \internal
 * \brief Queue the given frame onto the owner channel.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param chanpos Channel position in the span.
 * \param frame Frame to queue onto the owner channel.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
 *
 * \return Nothing
 */
static void pri_queue_frame(struct sig_pri_span *pri, int chanpos, struct ast_frame *frame)
{
        sig_pri_lock_owner(pri, chanpos);
        if (pri->pvts[chanpos]->owner) {
                ast_queue_frame(pri->pvts[chanpos]->owner, frame);
                ast_channel_unlock(pri->pvts[chanpos]->owner);
        }
}

/*!
 * \internal
 * \brief Queue a control frame of the specified subclass onto the owner channel.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param chanpos Channel position in the span.
 * \param subclass Control frame subclass to queue onto the owner channel.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
 *
 * \return Nothing
 */
static void pri_queue_control(struct sig_pri_span *pri, int chanpos, int subclass)
{
        struct ast_frame f = {AST_FRAME_CONTROL, };
        struct sig_pri_chan *p = pri->pvts[chanpos];

        if (p->calls->queue_control) {
                p->calls->queue_control(p->chan_pvt, subclass);
        }

        f.subclass.integer = subclass;
        pri_queue_frame(pri, chanpos, &f);
}

/*!
 * \internal
 * \brief Find the channel associated with the libpri call.
 * \since 10.0
 *
 * \param pri PRI span control structure.
 * \param call LibPRI opaque call pointer to find.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval array-index into private pointer array on success.
 * \retval -1 on error.
 */
static int pri_find_principle_by_call(struct sig_pri_span *pri, q931_call *call)
{
        int idx;

        if (!call) {
                /* Cannot find a call without a call. */
                return -1;
        }
        for (idx = 0; idx < pri->numchans; ++idx) {
                if (pri->pvts[idx] && pri->pvts[idx]->call == call) {
                        /* Found the principle */
                        return idx;
                }
        }
        return -1;
}

/*!
 * \internal
 * \brief Kill the call.
 * \since 10.0
 *
 * \param pri PRI span control structure.
 * \param call LibPRI opaque call pointer to find.
 * \param cause Reason call was killed.
 *
 * \note Assumes the pvt->pri->lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_kill_call(struct sig_pri_span *pri, q931_call *call, int cause)
{
        int chanpos;

        chanpos = pri_find_principle_by_call(pri, call);
        if (chanpos < 0) {
                pri_hangup(pri->pri, call, cause);
                return;
        }
        sig_pri_lock_private(pri->pvts[chanpos]);
        if (!pri->pvts[chanpos]->owner) {
                pri_hangup(pri->pri, call, cause);
                pri->pvts[chanpos]->call = NULL;
                sig_pri_unlock_private(pri->pvts[chanpos]);
                sig_pri_span_devstate_changed(pri);
                return;
        }
        ast_channel_hangupcause_set(pri->pvts[chanpos]->owner, cause);
        pri_queue_control(pri, chanpos, AST_CONTROL_HANGUP);
        sig_pri_unlock_private(pri->pvts[chanpos]);
}

/*!
 * \internal
 * \brief Find the private structure for the libpri call.
 *
 * \param pri PRI span control structure.
 * \param channel LibPRI encoded channel ID.
 * \param call LibPRI opaque call pointer.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval array-index into private pointer array on success.
 * \retval -1 on error.
 */
static int pri_find_principle(struct sig_pri_span *pri, int channel, q931_call *call)
{
        int x;
        int span;
        int principle;
        int prioffset;

        if (channel < 0) {
                /* Channel is not picked yet. */
                return -1;
        }

        prioffset = PRI_CHANNEL(channel);
        if (!prioffset || (channel & PRI_HELD_CALL)) {
                /* Find the call waiting call or held call. */
                return pri_find_principle_by_call(pri, call);
        }

        span = PRI_SPAN(channel);
        if (!(channel & PRI_EXPLICIT)) {
                int index;

                index = pri_active_dchan_index(pri);
                if (index == -1) {
                        return -1;
                }
                span = pri->dchan_logical_span[index];
        }

        principle = -1;
        for (x = 0; x < pri->numchans; x++) {
                if (pri->pvts[x]
                        && pri->pvts[x]->prioffset == prioffset
                        && pri->pvts[x]->logicalspan == span
                        && !pri->pvts[x]->no_b_channel) {
                        principle = x;
                        break;
                }
        }

        return principle;
}

/*!
 * \internal
 * \brief Fixup the private structure associated with the libpri call.
 *
 * \param pri PRI span control structure.
 * \param principle Array-index into private array to move call to if not already there.
 * \param call LibPRI opaque call pointer to find if need to move call.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval principle on success.
 * \retval -1 on error.
 */
static int pri_fixup_principle(struct sig_pri_span *pri, int principle, q931_call *call)
{
        int x;

        if (principle < 0 || pri->numchans <= principle) {
                /* Out of rannge */
                return -1;
        }
        if (!call) {
                /* No call */
                return principle;
        }
        if (pri->pvts[principle] && pri->pvts[principle]->call == call) {
                /* Call is already on the specified principle. */
                return principle;
        }

        /* Find the old principle location. */
        for (x = 0; x < pri->numchans; x++) {
                struct sig_pri_chan *new_chan;
                struct sig_pri_chan *old_chan;

                if (!pri->pvts[x] || pri->pvts[x]->call != call) {
                        continue;
                }

                /* Found our call */
                new_chan = pri->pvts[principle];
                old_chan = pri->pvts[x];

                /* Get locks to safely move to the new private structure. */
                sig_pri_lock_private(old_chan);
                sig_pri_lock_owner(pri, x);
                sig_pri_lock_private(new_chan);

                ast_verb(3, "Moving call (%s) from channel %d to %d.\n",
                        old_chan->owner ? ast_channel_name(old_chan->owner) : "",
                        old_chan->channel, new_chan->channel);
                if (!sig_pri_is_chan_available(new_chan)) {
                        ast_log(LOG_WARNING,
                                "Can't move call (%s) from channel %d to %d.  It is already in use.\n",
                                old_chan->owner ? ast_channel_name(old_chan->owner) : "",
                                old_chan->channel, new_chan->channel);
                        sig_pri_unlock_private(new_chan);
                        if (old_chan->owner) {
                                ast_channel_unlock(old_chan->owner);
                        }
                        sig_pri_unlock_private(old_chan);
                        return -1;
                }

                sig_pri_fixup_chans(old_chan, new_chan);

                /* Fix it all up now */
                new_chan->owner = old_chan->owner;
                old_chan->owner = NULL;

                new_chan->call = old_chan->call;
                old_chan->call = NULL;

                /* Transfer flags from the old channel. */
#if defined(HAVE_PRI_AOC_EVENTS)
                new_chan->aoc_s_request_invoke_id_valid = old_chan->aoc_s_request_invoke_id_valid;
                new_chan->waiting_for_aoce = old_chan->waiting_for_aoce;
                new_chan->holding_aoce = old_chan->holding_aoce;
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */
                new_chan->alreadyhungup = old_chan->alreadyhungup;
                new_chan->isidlecall = old_chan->isidlecall;
                new_chan->progress = old_chan->progress;
                new_chan->allocated = old_chan->allocated;
                new_chan->outgoing = old_chan->outgoing;
                new_chan->digital = old_chan->digital;
#if defined(HAVE_PRI_CALL_WAITING)
                new_chan->is_call_waiting = old_chan->is_call_waiting;
#endif  /* defined(HAVE_PRI_CALL_WAITING) */

#if defined(HAVE_PRI_AOC_EVENTS)
                old_chan->aoc_s_request_invoke_id_valid = 0;
                old_chan->waiting_for_aoce = 0;
                old_chan->holding_aoce = 0;
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */
                old_chan->alreadyhungup = 0;
                old_chan->isidlecall = 0;
                old_chan->progress = 0;
                old_chan->allocated = 0;
                old_chan->outgoing = 0;
                old_chan->digital = 0;
#if defined(HAVE_PRI_CALL_WAITING)
                old_chan->is_call_waiting = 0;
#endif  /* defined(HAVE_PRI_CALL_WAITING) */

                /* More stuff to transfer to the new channel. */
                new_chan->call_level = old_chan->call_level;
                old_chan->call_level = SIG_PRI_CALL_LEVEL_IDLE;
#if defined(HAVE_PRI_REVERSE_CHARGE)
                new_chan->reverse_charging_indication = old_chan->reverse_charging_indication;
#endif  /* defined(HAVE_PRI_REVERSE_CHARGE) */
#if defined(HAVE_PRI_SETUP_KEYPAD)
                strcpy(new_chan->keypad_digits, old_chan->keypad_digits);
#endif  /* defined(HAVE_PRI_SETUP_KEYPAD) */
                strcpy(new_chan->deferred_digits, old_chan->deferred_digits);
                strcpy(new_chan->moh_suggested, old_chan->moh_suggested);
                new_chan->moh_state = old_chan->moh_state;
                old_chan->moh_state = SIG_PRI_MOH_STATE_IDLE;

#if defined(HAVE_PRI_AOC_EVENTS)
                new_chan->aoc_s_request_invoke_id = old_chan->aoc_s_request_invoke_id;
                new_chan->aoc_e = old_chan->aoc_e;
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */
                strcpy(new_chan->user_tag, old_chan->user_tag);

                if (new_chan->no_b_channel) {
                        /* Copy the real channel configuration to the no B channel interface. */
                        new_chan->hidecallerid = old_chan->hidecallerid;
                        new_chan->hidecalleridname = old_chan->hidecalleridname;
                        new_chan->immediate = old_chan->immediate;
                        new_chan->priexclusive = old_chan->priexclusive;
                        new_chan->priindication_oob = old_chan->priindication_oob;
                        new_chan->use_callerid = old_chan->use_callerid;
                        new_chan->use_callingpres = old_chan->use_callingpres;
                        new_chan->stripmsd = old_chan->stripmsd;
                        strcpy(new_chan->context, old_chan->context);
                        strcpy(new_chan->mohinterpret, old_chan->mohinterpret);

                        /* Become a member of the old channel span/trunk-group. */
                        new_chan->logicalspan = old_chan->logicalspan;
                        new_chan->mastertrunkgroup = old_chan->mastertrunkgroup;
                } else if (old_chan->no_b_channel) {
                        /*
                         * We are transitioning from a held/call-waiting channel to a
                         * real channel so we need to make sure that the media path is
                         * open.  (Needed especially if the channel is natively
                         * bridged.)
                         */
                        sig_pri_open_media(new_chan);
                }

                if (new_chan->owner) {
                        sig_pri_ami_channel_event(new_chan);
                }

                sig_pri_unlock_private(old_chan);
                if (new_chan->owner) {
                        ast_channel_unlock(new_chan->owner);
                }
                sig_pri_unlock_private(new_chan);

                return principle;
        }
        ast_verb(3, "Call specified, but not found.\n");
        return -1;
}

/*!
 * \internal
 * \brief Find and fixup the private structure associated with the libpri call.
 *
 * \param pri PRI span control structure.
 * \param channel LibPRI encoded channel ID.
 * \param call LibPRI opaque call pointer.
 *
 * \details
 * This is a combination of pri_find_principle() and pri_fixup_principle()
 * to reduce code redundancy and to make handling several PRI_EVENT_xxx's
 * consistent for the current architecture.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval array-index into private pointer array on success.
 * \retval -1 on error.
 */
static int pri_find_fixup_principle(struct sig_pri_span *pri, int channel, q931_call *call)
{
        int chanpos;

        chanpos = pri_find_principle(pri, channel, call);
        if (chanpos < 0) {
                ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is unconfigured.\n",
                        pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
                sig_pri_kill_call(pri, call, PRI_CAUSE_IDENTIFIED_CHANNEL_NOTEXIST);
                return -1;
        }
        chanpos = pri_fixup_principle(pri, chanpos, call);
        if (chanpos < 0) {
                ast_log(LOG_WARNING, "Span %d: PRI requested channel %d/%d is not available.\n",
                        pri->span, PRI_SPAN(channel), PRI_CHANNEL(channel));
                /*
                 * Using Q.931 section 5.2.3.1 b) as the reason for picking
                 * PRI_CAUSE_CHANNEL_UNACCEPTABLE.  Receiving a
                 * PRI_CAUSE_REQUESTED_CHAN_UNAVAIL would cause us to restart
                 * that channel (which is not specified by Q.931) and kill some
                 * other call which would be bad.
                 */
                sig_pri_kill_call(pri, call, PRI_CAUSE_CHANNEL_UNACCEPTABLE);
                return -1;
        }
        return chanpos;
}

static char * redirectingreason2str(int redirectingreason)
{
        switch (redirectingreason) {
        case 0:
                return "UNKNOWN";
        case 1:
                return "BUSY";
        case 2:
                return "NO_REPLY";
        case 0xF:
                return "UNCONDITIONAL";
        default:
                return "NOREDIRECT";
        }
}

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

/*!
 * \internal
 * \brief Apply numbering plan prefix to the given number.
 *
 * \param buf Buffer to put number into.
 * \param size Size of given buffer.
 * \param pri PRI span control structure.
 * \param number Number to apply numbering plan.
 * \param plan Numbering plan to apply.
 *
 * \return Nothing
 */
static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, int plan)
{
        switch (plan) {
        case PRI_INTERNATIONAL_ISDN:            /* Q.931 dialplan == 0x11 international dialplan => prepend international prefix digits */
                snprintf(buf, size, "%s%s", pri->internationalprefix, number);
                break;
        case PRI_NATIONAL_ISDN:                 /* Q.931 dialplan == 0x21 national dialplan => prepend national prefix digits */
                snprintf(buf, size, "%s%s", pri->nationalprefix, number);
                break;
        case PRI_LOCAL_ISDN:                    /* Q.931 dialplan == 0x41 local dialplan => prepend local prefix digits */
                snprintf(buf, size, "%s%s", pri->localprefix, number);
                break;
        case PRI_PRIVATE:                       /* Q.931 dialplan == 0x49 private dialplan => prepend private prefix digits */
                snprintf(buf, size, "%s%s", pri->privateprefix, number);
                break;
        case PRI_UNKNOWN:                       /* Q.931 dialplan == 0x00 unknown dialplan => prepend unknown prefix digits */
                snprintf(buf, size, "%s%s", pri->unknownprefix, number);
                break;
        default:                                /* other Q.931 dialplan => don't twiddle with callingnum */
                snprintf(buf, size, "%s", number);
                break;
        }
}

/*!
 * \internal
 * \brief Apply numbering plan prefix to the given number if the number exists.
 *
 * \param buf Buffer to put number into.
 * \param size Size of given buffer.
 * \param pri PRI span control structure.
 * \param number Number to apply numbering plan.
 * \param plan Numbering plan to apply.
 *
 * \return Nothing
 */
static void apply_plan_to_existing_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, int plan)
{
        /* Make sure a number exists so the prefix isn't placed on an empty string. */
        if (ast_strlen_zero(number)) {
                if (size) {
                        *buf = '\0';
                }
                return;
        }
        apply_plan_to_number(buf, size, pri, number, plan);
}

/*!
 * \internal
 * \brief Restart the next channel we think is idle on the span.
 *
 * \param pri PRI span control structure.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \return Nothing
 */
static void pri_check_restart(struct sig_pri_span *pri)
{
#if defined(HAVE_PRI_SERVICE_MESSAGES)
        unsigned why;
#endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */

        for (++pri->resetpos; pri->resetpos < pri->numchans; ++pri->resetpos) {
                if (!pri->pvts[pri->resetpos]
                        || pri->pvts[pri->resetpos]->no_b_channel
                        || sig_pri_is_chan_in_use(pri->pvts[pri->resetpos])) {
                        continue;
                }
#if defined(HAVE_PRI_SERVICE_MESSAGES)
                why = pri->pvts[pri->resetpos]->service_status;
                if (why) {
                        ast_log(LOG_NOTICE,
                                "Span %d: channel %d out-of-service (reason: %s), not sending RESTART\n",
                                pri->span, pri->pvts[pri->resetpos]->channel,
                                (why & SRVST_FAREND) ? (why & SRVST_NEAREND) ? "both ends" : "far end" : "near end");
                        continue;
                }
#endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
                break;
        }
        if (pri->resetpos < pri->numchans) {
                /* Mark the channel as resetting and restart it */
                pri->pvts[pri->resetpos]->resetting = 1;
                pri_reset(pri->pri, PVT_TO_CHANNEL(pri->pvts[pri->resetpos]));
        } else {
                pri->resetting = 0;
                time(&pri->lastreset);
                sig_pri_span_devstate_changed(pri);
        }
}

#if defined(HAVE_PRI_CALL_WAITING)
/*!
 * \internal
 * \brief Init the private channel configuration using the span controller.
 * \since 1.8
 *
 * \param pvt Channel to init the configuration.
 * \param pri PRI span control structure.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_init_config(struct sig_pri_chan *pvt, struct sig_pri_span *pri)
{
        pvt->stripmsd = pri->ch_cfg.stripmsd;
        pvt->hidecallerid = pri->ch_cfg.hidecallerid;
        pvt->hidecalleridname = pri->ch_cfg.hidecalleridname;
        pvt->immediate = pri->ch_cfg.immediate;
        pvt->priexclusive = pri->ch_cfg.priexclusive;
        pvt->priindication_oob = pri->ch_cfg.priindication_oob;
        pvt->use_callerid = pri->ch_cfg.use_callerid;
        pvt->use_callingpres = pri->ch_cfg.use_callingpres;
        ast_copy_string(pvt->context, pri->ch_cfg.context, sizeof(pvt->context));
        ast_copy_string(pvt->mohinterpret, pri->ch_cfg.mohinterpret, sizeof(pvt->mohinterpret));

        if (pri->calls->init_config) {
                pri->calls->init_config(pvt->chan_pvt, pri);
        }
}
#endif  /* defined(HAVE_PRI_CALL_WAITING) */

/*!
 * \internal
 * \brief Find an empty B-channel interface to use.
 *
 * \param pri PRI span control structure.
 * \param backwards TRUE if the search starts from higher channels.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval array-index into private pointer array on success.
 * \retval -1 on error.
 */
static int pri_find_empty_chan(struct sig_pri_span *pri, int backwards)
{
        int x;
        if (backwards)
                x = pri->numchans;
        else
                x = 0;
        for (;;) {
                if (backwards && (x < 0))
                        break;
                if (!backwards && (x >= pri->numchans))
                        break;
                if (pri->pvts[x]
                        && !pri->pvts[x]->no_b_channel
                        && sig_pri_is_chan_available(pri->pvts[x])) {
                        ast_debug(1, "Found empty available channel %d/%d\n",
                                pri->pvts[x]->logicalspan, pri->pvts[x]->prioffset);
                        return x;
                }
                if (backwards)
                        x--;
                else
                        x++;
        }
        return -1;
}

#if defined(HAVE_PRI_CALL_HOLD)
/*!
 * \internal
 * \brief Find or create an empty no-B-channel interface to use.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval array-index into private pointer array on success.
 * \retval -1 on error.
 */
static int pri_find_empty_nobch(struct sig_pri_span *pri)
{
        int idx;

        for (idx = 0; idx < pri->numchans; ++idx) {
                if (pri->pvts[idx]
                        && pri->pvts[idx]->no_b_channel
                        && sig_pri_is_chan_available(pri->pvts[idx])) {
                        ast_debug(1, "Found empty available no B channel interface\n");
                        return idx;
                }
        }

        /* Need to create a new interface. */
        if (pri->calls->new_nobch_intf) {
                idx = pri->calls->new_nobch_intf(pri);
        } else {
                idx = -1;
        }
        return idx;
}
#endif  /* defined(HAVE_PRI_CALL_HOLD) */

static void *do_idle_thread(void *v_pvt)
{
        struct sig_pri_chan *pvt = v_pvt;
        struct ast_channel *chan = pvt->owner;
        struct ast_frame *f;
        char ex[80];
        /* Wait up to 30 seconds for an answer */
        int newms, ms = 30000;

        ast_verb(3, "Initiating idle call on channel %s\n", ast_channel_name(chan));
        snprintf(ex, sizeof(ex), "%d/%s", pvt->channel, pvt->pri->idledial);
        if (ast_call(chan, ex, 0)) {
                ast_log(LOG_WARNING, "Idle dial failed on '%s' to '%s'\n", ast_channel_name(chan), ex);
                ast_hangup(chan);
                return NULL;
        }
        while ((newms = ast_waitfor(chan, ms)) > 0) {
                f = ast_read(chan);
                if (!f) {
                        /* Got hangup */
                        break;
                }
                if (f->frametype == AST_FRAME_CONTROL) {
                        switch (f->subclass.integer) {
                        case AST_CONTROL_ANSWER:
                                /* Launch the PBX */
                                ast_channel_exten_set(chan, pvt->pri->idleext);
                                ast_channel_context_set(chan, pvt->pri->idlecontext);
                                ast_channel_priority_set(chan, 1);
                                ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", ast_channel_name(chan), ast_channel_exten(chan), ast_channel_context(chan));
                                ast_pbx_run(chan);
                                /* It's already hungup, return immediately */
                                return NULL;
                        case AST_CONTROL_BUSY:
                                ast_verb(4, "Idle channel '%s' busy, waiting...\n", ast_channel_name(chan));
                                break;
                        case AST_CONTROL_CONGESTION:
                                ast_verb(4, "Idle channel '%s' congested, waiting...\n", ast_channel_name(chan));
                                break;
                        };
                }
                ast_frfree(f);
                ms = newms;
        }
        /* Hangup the channel since nothing happend */
        ast_hangup(chan);
        return NULL;
}

static void *pri_ss_thread(void *data)
{
        struct sig_pri_chan *p = data;
        struct ast_channel *chan = p->owner;
        char exten[AST_MAX_EXTENSION];
        int res;
        int len;
        int timeout;

        if (!chan) {
                /* We lost the owner before we could get started. */
                return NULL;
        }

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

        ast_verb(3, "Starting simple switch on '%s'\n", ast_channel_name(chan));

        sig_pri_dsp_reset_and_flush_digits(p);

        /* Now loop looking for an extension */
        ast_copy_string(exten, p->exten, sizeof(exten));
        len = strlen(exten);
        res = 0;
        while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num)) {
                if (len && !ast_ignore_pattern(ast_channel_context(chan), exten))
                        sig_pri_play_tone(p, -1);
                else
                        sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
                if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num))
                        timeout = pri_matchdigittimeout;
                else
                        timeout = pri_gendigittimeout;
                res = ast_waitfordigit(chan, timeout);
                if (res < 0) {
                        ast_debug(1, "waitfordigit returned < 0...\n");
                        ast_hangup(chan);
                        return NULL;
                } else if (res) {
                        exten[len++] = res;
                        exten[len] = '\0';
                } else
                        break;
        }
        /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
        if (ast_strlen_zero(exten)) {
                ast_verb(3, "Going to extension s|1 because of empty extension received on overlap call\n");
                exten[0] = 's';
                exten[1] = '\0';
        } else {
                ast_free(ast_channel_dialed(chan)->number.str);
                ast_channel_dialed(chan)->number.str = ast_strdup(exten);

                if (p->pri->append_msn_to_user_tag && p->pri->nodetype != PRI_NETWORK) {
                        /*
                         * Update the user tag for party id's from this device for this call
                         * now that we have a complete MSN from the network.
                         */
                        snprintf(p->user_tag, sizeof(p->user_tag), "%s_%s", p->pri->initial_user_tag,
                                exten);
                        ast_free(ast_channel_caller(chan)->id.tag);
                        ast_channel_caller(chan)->id.tag = ast_strdup(p->user_tag);
                }
        }
        sig_pri_play_tone(p, -1);
        if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num)) {
                /* Start the real PBX */
                ast_channel_exten_set(chan, exten);
                sig_pri_dsp_reset_and_flush_digits(p);
#if defined(ISSUE_16789)
                /*
                 * Conditionaled out this code to effectively revert the Mantis
                 * issue 16789 change.  It breaks overlap dialing through
                 * Asterisk.  There is not enough information available at this
                 * point to know if dialing is complete.  The
                 * ast_exists_extension(), ast_matchmore_extension(), and
                 * ast_canmatch_extension() calls are not adequate to detect a
                 * dial through extension pattern of "_9!".
                 *
                 * Workaround is to use the dialplan Proceeding() application
                 * early on non-dial through extensions.
                 */
                if ((p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING)
                        && !ast_matchmore_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num)) {
                        sig_pri_lock_private(p);
                        if (p->pri->pri) {
                                pri_grab(p, p->pri);
                                if (p->call_level < SIG_PRI_CALL_LEVEL_PROCEEDING) {
                                        p->call_level = SIG_PRI_CALL_LEVEL_PROCEEDING;
                                }
                                pri_proceeding(p->pri->pri, p->call, PVT_TO_CHANNEL(p), 0);
                                pri_rel(p->pri);
                        }
                        sig_pri_unlock_private(p);
                }
#endif  /* defined(ISSUE_16789) */

                sig_pri_set_echocanceller(p, 1);
                ast_setstate(chan, AST_STATE_RING);
                res = ast_pbx_run(chan);
                if (res) {
                        ast_log(LOG_WARNING, "PBX exited non-zero!\n");
                }
        } else {
                ast_debug(1, "No such possible extension '%s' in context '%s'\n", exten, ast_channel_context(chan));
                ast_channel_hangupcause_set(chan, AST_CAUSE_UNALLOCATED);
                ast_hangup(chan);
                p->exten[0] = '\0';
                /* Since we send release complete here, we won't get one */
                p->call = NULL;
                ast_mutex_lock(&p->pri->lock);
                sig_pri_span_devstate_changed(p->pri);
                ast_mutex_unlock(&p->pri->lock);
        }
        return NULL;
}

void pri_event_alarm(struct sig_pri_span *pri, int index, int before_start_pri)
{
        pri->dchanavail[index] &= ~(DCHAN_NOTINALARM | DCHAN_UP);
        if (!before_start_pri) {
                pri_find_dchan(pri);
        }
}

void pri_event_noalarm(struct sig_pri_span *pri, int index, int before_start_pri)
{
        pri->dchanavail[index] |= DCHAN_NOTINALARM;
        if (!before_start_pri)
                pri_restart(pri->dchans[index]);
}

/*!
 * \internal
 * \brief Convert libpri party name into asterisk party name.
 * \since 1.8
 *
 * \param ast_name Asterisk party name structure to fill.  Must already be set initialized.
 * \param pri_name libpri party name structure containing source information.
 *
 * \note The filled in ast_name structure needs to be destroyed by
 * ast_party_name_free() when it is no longer needed.
 *
 * \return Nothing
 */
static void sig_pri_party_name_convert(struct ast_party_name *ast_name, const struct pri_party_name *pri_name)
{
        ast_name->str = ast_strdup(pri_name->str);
        ast_name->char_set = pri_to_ast_char_set(pri_name->char_set);
        ast_name->presentation = pri_to_ast_presentation(pri_name->presentation);
        ast_name->valid = 1;
}

/*!
 * \internal
 * \brief Convert libpri party number into asterisk party number.
 * \since 1.8
 *
 * \param ast_number Asterisk party number structure to fill.  Must already be set initialized.
 * \param pri_number libpri party number structure containing source information.
 * \param pri PRI span control structure.
 *
 * \note The filled in ast_number structure needs to be destroyed by
 * ast_party_number_free() when it is no longer needed.
 *
 * \return Nothing
 */
static void sig_pri_party_number_convert(struct ast_party_number *ast_number, const struct pri_party_number *pri_number, struct sig_pri_span *pri)
{
        char number[AST_MAX_EXTENSION];

        apply_plan_to_existing_number(number, sizeof(number), pri, pri_number->str,
                pri_number->plan);
        ast_number->str = ast_strdup(number);
        ast_number->plan = pri_number->plan;
        ast_number->presentation = pri_to_ast_presentation(pri_number->presentation);
        ast_number->valid = 1;
}

/*!
 * \internal
 * \brief Convert libpri party id into asterisk party id.
 * \since 1.8
 *
 * \param ast_id Asterisk party id structure to fill.  Must already be set initialized.
 * \param pri_id libpri party id structure containing source information.
 * \param pri PRI span control structure.
 *
 * \note The filled in ast_id structure needs to be destroyed by
 * ast_party_id_free() when it is no longer needed.
 *
 * \return Nothing
 */
static void sig_pri_party_id_convert(struct ast_party_id *ast_id, const struct pri_party_id *pri_id, struct sig_pri_span *pri)
{
        if (pri_id->name.valid) {
                sig_pri_party_name_convert(&ast_id->name, &pri_id->name);
        }
        if (pri_id->number.valid) {
                sig_pri_party_number_convert(&ast_id->number, &pri_id->number, pri);
        }
#if defined(HAVE_PRI_SUBADDR)
        if (pri_id->subaddress.valid) {
                sig_pri_set_subaddress(&ast_id->subaddress, &pri_id->subaddress);
        }
#endif  /* defined(HAVE_PRI_SUBADDR) */
}

/*!
 * \internal
 * \brief Convert libpri redirecting information into asterisk redirecting information.
 * \since 1.8
 *
 * \param ast_redirecting Asterisk redirecting structure to fill.
 * \param pri_redirecting libpri redirecting structure containing source information.
 * \param ast_guide Asterisk redirecting structure to use as an initialization guide.
 * \param pri PRI span control structure.
 *
 * \note The filled in ast_redirecting structure needs to be destroyed by
 * ast_party_redirecting_free() when it is no longer needed.
 *
 * \return Nothing
 */
static void sig_pri_redirecting_convert(struct ast_party_redirecting *ast_redirecting,
        const struct pri_party_redirecting *pri_redirecting,
        const struct ast_party_redirecting *ast_guide,
        struct sig_pri_span *pri)
{
        ast_party_redirecting_set_init(ast_redirecting, ast_guide);

        sig_pri_party_id_convert(&ast_redirecting->from, &pri_redirecting->from, pri);
        sig_pri_party_id_convert(&ast_redirecting->to, &pri_redirecting->to, pri);
        ast_redirecting->count = pri_redirecting->count;
        ast_redirecting->reason = pri_to_ast_reason(pri_redirecting->reason);
}

/*!
 * \internal
 * \brief Determine if the given extension matches one of the MSNs in the pattern list.
 * \since 1.8
 *
 * \param msn_patterns Comma separated list of MSN patterns to match.
 * \param exten Extension to match in the MSN list.
 *
 * \retval 1 if matches.
 * \retval 0 if no match.
 */
static int sig_pri_msn_match(const char *msn_patterns, const char *exten)
{
        char *pattern;
        char *msn_list;
        char *list_tail;

        msn_list = ast_strdupa(msn_patterns);

        list_tail = NULL;
        pattern = strtok_r(msn_list, ",", &list_tail);
        while (pattern) {
                pattern = ast_strip(pattern);
                if (!ast_strlen_zero(pattern) && ast_extension_match(pattern, exten)) {
                        /* Extension matched the pattern. */
                        return 1;
                }
                pattern = strtok_r(NULL, ",", &list_tail);
        }
        /* Did not match any pattern in the list. */
        return 0;
}

#if defined(HAVE_PRI_MCID)
/*!
 * \internal
 * \brief Append the given party id to the event string.
 * \since 1.8
 *
 * \param msg Event message string being built.
 * \param prefix Prefix to add to the party id lines.
 * \param party Party information to encode.
 *
 * \return Nothing
 */
static void sig_pri_event_party_id(struct ast_str **msg, const char *prefix, struct ast_party_id *party)
{
        int pres;

        /* Combined party presentation */
        pres = ast_party_id_presentation(party);
        ast_str_append(msg, 0, "%sPres: %d (%s)\r\n", prefix, pres,
                ast_describe_caller_presentation(pres));

        /* Party number */
        ast_str_append(msg, 0, "%sNumValid: %d\r\n", prefix,
                (unsigned) party->number.valid);
        ast_str_append(msg, 0, "%sNum: %s\r\n", prefix,
                S_COR(party->number.valid, party->number.str, ""));
        ast_str_append(msg, 0, "%ston: %d\r\n", prefix, party->number.plan);
        if (party->number.valid) {
                ast_str_append(msg, 0, "%sNumPlan: %d\r\n", prefix, party->number.plan);
                ast_str_append(msg, 0, "%sNumPres: %d (%s)\r\n", prefix,
                        party->number.presentation,
                        ast_describe_caller_presentation(party->number.presentation));
        }

        /* Party name */
        ast_str_append(msg, 0, "%sNameValid: %d\r\n", prefix,
                (unsigned) party->name.valid);
        ast_str_append(msg, 0, "%sName: %s\r\n", prefix,
                S_COR(party->name.valid, party->name.str, ""));
        if (party->name.valid) {
                ast_str_append(msg, 0, "%sNameCharSet: %s\r\n", prefix,
                        ast_party_name_charset_describe(party->name.char_set));
                ast_str_append(msg, 0, "%sNamePres: %d (%s)\r\n", prefix,
                        party->name.presentation,
                        ast_describe_caller_presentation(party->name.presentation));
        }

#if defined(HAVE_PRI_SUBADDR)
        /* Party subaddress */
        if (party->subaddress.valid) {
                static const char subaddress[] = "Subaddr";

                ast_str_append(msg, 0, "%s%s: %s\r\n", prefix, subaddress,
                        S_OR(party->subaddress.str, ""));
                ast_str_append(msg, 0, "%s%sType: %d\r\n", prefix, subaddress,
                        party->subaddress.type);
                ast_str_append(msg, 0, "%s%sOdd: %d\r\n", prefix, subaddress,
                        party->subaddress.odd_even_indicator);
        }
#endif  /* defined(HAVE_PRI_SUBADDR) */
}
#endif  /* defined(HAVE_PRI_MCID) */

#if defined(HAVE_PRI_MCID)
/*!
 * \internal
 * \brief Handle the MCID event.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param mcid MCID event parameters.
 * \param owner Asterisk channel associated with the call.
 * NULL if Asterisk no longer has the ast_channel struct.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the owner channel lock is already obtained if still present.
 *
 * \return Nothing
 */
static void sig_pri_mcid_event(struct sig_pri_span *pri, const struct pri_subcmd_mcid_req *mcid, struct ast_channel *owner)
{
        struct ast_channel *chans[1];
        struct ast_str *msg;
        struct ast_party_id party;

        msg = ast_str_create(4096);
        if (!msg) {
                return;
        }

        if (owner) {
                /*
                 * The owner channel is present.
                 * Pass the event to the peer as well.
                 */
                ast_queue_control(owner, AST_CONTROL_MCID);

                ast_str_append(&msg, 0, "Channel: %s\r\n", ast_channel_name(owner));
                ast_str_append(&msg, 0, "UniqueID: %s\r\n", ast_channel_uniqueid(owner));

                sig_pri_event_party_id(&msg, "CallerID", &ast_channel_connected(owner)->id);
        } else {
                /*
                 * Since we no longer have an owner channel,
                 * we have to use the caller information supplied by libpri.
                 */
                ast_party_id_init(&party);
                sig_pri_party_id_convert(&party, &mcid->originator, pri);
                sig_pri_event_party_id(&msg, "CallerID", &party);
                ast_party_id_free(&party);
        }

        /* Always use libpri's called party information. */
        ast_party_id_init(&party);
        sig_pri_party_id_convert(&party, &mcid->answerer, pri);
        sig_pri_event_party_id(&msg, "ConnectedID", &party);
        ast_party_id_free(&party);

        chans[0] = owner;
        ast_manager_event_multichan(EVENT_FLAG_CALL, "MCID", owner ? 1 : 0, chans, "%s",
                ast_str_buffer(msg));
        ast_free(msg);
}
#endif  /* defined(HAVE_PRI_MCID) */

#if defined(HAVE_PRI_TRANSFER)
struct xfer_rsp_data {
        struct sig_pri_span *pri;
        /*! Call to send transfer success/fail response over. */
        q931_call *call;
        /*! Invocation ID to use when sending a reply to the transfer request. */
        int invoke_id;
};
#endif  /* defined(HAVE_PRI_TRANSFER) */

#if defined(HAVE_PRI_TRANSFER)
/*!
 * \internal
 * \brief Send the transfer success/fail response message.
 * \since 1.8
 *
 * \param data Callback user data pointer
 * \param is_successful TRUE if the transfer was successful.
 *
 * \return Nothing
 */
static void sig_pri_transfer_rsp(void *data, int is_successful)
{
        struct xfer_rsp_data *rsp = data;

        pri_transfer_rsp(rsp->pri->pri, rsp->call, rsp->invoke_id, is_successful);
}
#endif  /* defined(HAVE_PRI_TRANSFER) */

#if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
/*!
 * \brief Protocol callback to indicate if transfer will happen.
 * \since 1.8
 *
 * \param data Callback user data pointer
 * \param is_successful TRUE if the transfer will happen.
 *
 * \return Nothing
 */
typedef void (*xfer_rsp_callback)(void *data, int is_successful);
#endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */

#if defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
/*!
 * \internal
 * \brief Attempt to transfer the two calls to each other.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param call_1_pri First call involved in the transfer. (transferee; usually on hold)
 * \param call_1_held TRUE if call_1_pri is on hold.
 * \param call_2_pri Second call involved in the transfer. (target; usually active/ringing)
 * \param call_2_held TRUE if call_2_pri is on hold.
 * \param rsp_callback Protocol callback to indicate if transfer will happen. NULL if not used.
 * \param data Callback user data pointer
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \retval 0 on success.
 * \retval -1 on error.
 */
static int sig_pri_attempt_transfer(struct sig_pri_span *pri, q931_call *call_1_pri, int call_1_held, q931_call *call_2_pri, int call_2_held, xfer_rsp_callback rsp_callback, void *data)
{
        struct attempt_xfer_call {
                q931_call *pri;
                struct ast_channel *ast;
                int held;
                int chanpos;
        };
        int retval;
        struct ast_channel *transferee;
        struct attempt_xfer_call *call_1;
        struct attempt_xfer_call *call_2;
        struct attempt_xfer_call *swap_call;
        struct attempt_xfer_call c1;
        struct attempt_xfer_call c2;

        c1.pri = call_1_pri;
        c1.held = call_1_held;
        call_1 = &c1;

        c2.pri = call_2_pri;
        c2.held = call_2_held;
        call_2 = &c2;

        call_1->chanpos = pri_find_principle_by_call(pri, call_1->pri);
        call_2->chanpos = pri_find_principle_by_call(pri, call_2->pri);
        if (call_1->chanpos < 0 || call_2->chanpos < 0) {
                /* Calls not found in span control. */
                if (rsp_callback) {
                        /* Transfer failed. */
                        rsp_callback(data, 0);
                }
                return -1;
        }

        /* Attempt to make transferee and target consistent. */
        if (!call_1->held && call_2->held) {
                /*
                 * Swap call_1 and call_2 to make call_1 the transferee(held call)
                 * and call_2 the target(active call).
                 */
                swap_call = call_1;
                call_1 = call_2;
                call_2 = swap_call;
        }

        /* Deadlock avoidance is attempted. */
        sig_pri_lock_private(pri->pvts[call_1->chanpos]);
        sig_pri_lock_owner(pri, call_1->chanpos);
        sig_pri_lock_private(pri->pvts[call_2->chanpos]);
        sig_pri_lock_owner(pri, call_2->chanpos);

        call_1->ast = pri->pvts[call_1->chanpos]->owner;
        call_2->ast = pri->pvts[call_2->chanpos]->owner;
        if (!call_1->ast || !call_2->ast) {
                /* At least one owner is not present. */
                if (call_1->ast) {
                        ast_channel_unlock(call_1->ast);
                }
                if (call_2->ast) {
                        ast_channel_unlock(call_2->ast);
                }
                sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
                sig_pri_unlock_private(pri->pvts[call_2->chanpos]);
                if (rsp_callback) {
                        /* Transfer failed. */
                        rsp_callback(data, 0);
                }
                return -1;
        }

        for (;;) {
                transferee = ast_bridged_channel(call_1->ast);
                if (transferee) {
                        break;
                }

                /* Try masquerading the other way. */
                swap_call = call_1;
                call_1 = call_2;
                call_2 = swap_call;

                transferee = ast_bridged_channel(call_1->ast);
                if (transferee) {
                        break;
                }

                /* Could not transfer.  Neither call is bridged. */
                ast_channel_unlock(call_1->ast);
                ast_channel_unlock(call_2->ast);
                sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
                sig_pri_unlock_private(pri->pvts[call_2->chanpos]);

                if (rsp_callback) {
                        /* Transfer failed. */
                        rsp_callback(data, 0);
                }
                return -1;
        }

        ast_verb(3, "TRANSFERRING %s to %s\n", ast_channel_name(call_1->ast), ast_channel_name(call_2->ast));

        /*
         * Setup transfer masquerade.
         *
         * Note:  There is an extremely nasty deadlock avoidance issue
         * with ast_channel_transfer_masquerade().  Deadlock may be possible if
         * the channels involved are proxies (chan_agent channels) and
         * it is called with locks.  Unfortunately, there is no simple
         * or even merely difficult way to guarantee deadlock avoidance
         * and still be able to send an ECT success response without the
         * possibility of the bridged channel hanging up on us.
         */
        ast_mutex_unlock(&pri->lock);
        retval = ast_channel_transfer_masquerade(
                call_2->ast,
                ast_channel_connected(call_2->ast),
                call_2->held,
                transferee,
                ast_channel_connected(call_1->ast),
                call_1->held);

        /* Reacquire the pri->lock to hold off completion of the transfer masquerade. */
        ast_mutex_lock(&pri->lock);

        ast_channel_unlock(call_1->ast);
        ast_channel_unlock(call_2->ast);
        sig_pri_unlock_private(pri->pvts[call_1->chanpos]);
        sig_pri_unlock_private(pri->pvts[call_2->chanpos]);

        if (rsp_callback) {
                /*
                 * Report transfer status.
                 *
                 * Must do the callback before the masquerade completes to ensure
                 * that the protocol message goes out before the call leg is
                 * disconnected.
                 */
                rsp_callback(data, retval ? 0 : 1);
        }
        return retval;
}
#endif  /* defined(HAVE_PRI_CALL_HOLD) || defined(HAVE_PRI_TRANSFER) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Compare the CC agent private data by libpri cc_id.
 * \since 1.8
 *
 * \param obj pointer to the (user-defined part) of an object.
 * \param arg callback argument from ao2_callback()
 * \param flags flags from ao2_callback()
 *
 * \return values are a combination of enum _cb_results.
 */
static int sig_pri_cc_agent_cmp_cc_id(void *obj, void *arg, int flags)
{
        struct ast_cc_agent *agent_1 = obj;
        struct sig_pri_cc_agent_prv *agent_prv_1 = agent_1->private_data;
        struct sig_pri_cc_agent_prv *agent_prv_2 = arg;

        return (agent_prv_1 && agent_prv_1->pri == agent_prv_2->pri
                && agent_prv_1->cc_id == agent_prv_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Find the CC agent by libpri cc_id.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param cc_id CC record ID to find.
 *
 * \note
 * Since agents are refcounted, and this function returns
 * a reference to the agent, it is imperative that you decrement
 * the refcount of the agent once you have finished using it.
 *
 * \retval agent on success.
 * \retval NULL not found.
 */
static struct ast_cc_agent *sig_pri_find_cc_agent_by_cc_id(struct sig_pri_span *pri, long cc_id)
{
        struct sig_pri_cc_agent_prv finder = {
                .pri = pri,
                .cc_id = cc_id,
        };

        return ast_cc_agent_callback(0, sig_pri_cc_agent_cmp_cc_id, &finder,
                sig_pri_cc_type_name);
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Compare the CC monitor instance by libpri cc_id.
 * \since 1.8
 *
 * \param obj pointer to the (user-defined part) of an object.
 * \param arg callback argument from ao2_callback()
 * \param flags flags from ao2_callback()
 *
 * \return values are a combination of enum _cb_results.
 */
static int sig_pri_cc_monitor_cmp_cc_id(void *obj, void *arg, int flags)
{
        struct sig_pri_cc_monitor_instance *monitor_1 = obj;
        struct sig_pri_cc_monitor_instance *monitor_2 = arg;

        return (monitor_1->pri == monitor_2->pri
                && monitor_1->cc_id == monitor_2->cc_id) ? CMP_MATCH | CMP_STOP : 0;
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Find the CC monitor instance by libpri cc_id.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param cc_id CC record ID to find.
 *
 * \note
 * Since monitor_instances are refcounted, and this function returns
 * a reference to the instance, it is imperative that you decrement
 * the refcount of the instance once you have finished using it.
 *
 * \retval monitor_instance on success.
 * \retval NULL not found.
 */
static struct sig_pri_cc_monitor_instance *sig_pri_find_cc_monitor_by_cc_id(struct sig_pri_span *pri, long cc_id)
{
        struct sig_pri_cc_monitor_instance finder = {
                .pri = pri,
                .cc_id = cc_id,
        };

        return ao2_callback(sig_pri_cc_monitors, 0, sig_pri_cc_monitor_cmp_cc_id, &finder);
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Destroy the given monitor instance.
 * \since 1.8
 *
 * \param data Monitor instance to destroy.
 *
 * \return Nothing
 */
static void sig_pri_cc_monitor_instance_destroy(void *data)
{
        struct sig_pri_cc_monitor_instance *monitor_instance = data;

        if (monitor_instance->cc_id != -1) {
                ast_mutex_lock(&monitor_instance->pri->lock);
                pri_cc_cancel(monitor_instance->pri->pri, monitor_instance->cc_id);
                ast_mutex_unlock(&monitor_instance->pri->lock);
        }
        monitor_instance->pri->calls->module_unref();
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Construct a new monitor instance.
 * \since 1.8
 *
 * \param core_id CC core ID.
 * \param pri PRI span control structure.
 * \param cc_id CC record ID.
 * \param device_name Name of device (Asterisk channel name less sequence number).
 *
 * \note
 * Since monitor_instances are refcounted, and this function returns
 * a reference to the instance, it is imperative that you decrement
 * the refcount of the instance once you have finished using it.
 *
 * \retval monitor_instance on success.
 * \retval NULL on error.
 */
static struct sig_pri_cc_monitor_instance *sig_pri_cc_monitor_instance_init(int core_id, struct sig_pri_span *pri, long cc_id, const char *device_name)
{
        struct sig_pri_cc_monitor_instance *monitor_instance;

        if (!pri->calls->module_ref || !pri->calls->module_unref) {
                return NULL;
        }

        monitor_instance = ao2_alloc(sizeof(*monitor_instance) + strlen(device_name),
                sig_pri_cc_monitor_instance_destroy);
        if (!monitor_instance) {
                return NULL;
        }

        monitor_instance->cc_id = cc_id;
        monitor_instance->pri = pri;
        monitor_instance->core_id = core_id;
        strcpy(monitor_instance->name, device_name);

        pri->calls->module_ref();

        ao2_link(sig_pri_cc_monitors, monitor_instance);
        return monitor_instance;
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief Announce to the CC core that protocol CC monitor is available for this call.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param chanpos Channel position in the span.
 * \param cc_id CC record ID.
 * \param service CCBS/CCNR indication.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
 * \note Assumes the sig_pri_lock_owner(pri, chanpos) is already obtained.
 *
 * \retval 0 on success.
 * \retval -1 on error.
 */
static int sig_pri_cc_available(struct sig_pri_span *pri, int chanpos, long cc_id, enum ast_cc_service_type service)
{
        struct sig_pri_chan *pvt;
        struct ast_cc_config_params *cc_params;
        struct sig_pri_cc_monitor_instance *monitor;
        enum ast_cc_monitor_policies monitor_policy;
        int core_id;
        int res;
        char device_name[AST_CHANNEL_NAME];
        char dialstring[AST_CHANNEL_NAME];

        pvt = pri->pvts[chanpos];

        core_id = ast_cc_get_current_core_id(pvt->owner);
        if (core_id == -1) {
                return -1;
        }

        cc_params = ast_channel_get_cc_config_params(pvt->owner);
        if (!cc_params) {
                return -1;
        }

        res = -1;
        monitor_policy = ast_get_cc_monitor_policy(cc_params);
        switch (monitor_policy) {
        case AST_CC_MONITOR_NEVER:
                /* CCSS is not enabled. */
                break;
        case AST_CC_MONITOR_NATIVE:
        case AST_CC_MONITOR_ALWAYS:
                /*
                 * If it is AST_CC_MONITOR_ALWAYS and native fails we will attempt the fallback
                 * later in the call to sig_pri_cc_generic_check().
                 */
                ast_channel_get_device_name(pvt->owner, device_name, sizeof(device_name));
                sig_pri_make_cc_dialstring(pvt, dialstring, sizeof(dialstring));
                monitor = sig_pri_cc_monitor_instance_init(core_id, pri, cc_id, device_name);
                if (!monitor) {
                        break;
                }
                res = ast_queue_cc_frame(pvt->owner, sig_pri_cc_type_name, dialstring, service,
                        monitor);
                if (res) {
                        monitor->cc_id = -1;
                        ao2_unlink(sig_pri_cc_monitors, monitor);
                        ao2_ref(monitor, -1);
                }
                break;
        case AST_CC_MONITOR_GENERIC:
                ast_queue_cc_frame(pvt->owner, AST_CC_GENERIC_MONITOR_TYPE,
                        sig_pri_get_orig_dialstring(pvt), service, NULL);
                /* Say it failed to force caller to cancel native CC. */
                break;
        }
        return res;
}
#endif  /* defined(HAVE_PRI_CCSS) */

/*!
 * \internal
 * \brief Check if generic CC monitor is needed and request it.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param chanpos Channel position in the span.
 * \param service CCBS/CCNR indication.
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri_lock_private(pri->pvts[chanpos]) is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_cc_generic_check(struct sig_pri_span *pri, int chanpos, enum ast_cc_service_type service)
{
        struct ast_channel *owner;
        struct ast_cc_config_params *cc_params;
#if defined(HAVE_PRI_CCSS)
        struct ast_cc_monitor *monitor;
        char device_name[AST_CHANNEL_NAME];
#endif  /* defined(HAVE_PRI_CCSS) */
        enum ast_cc_monitor_policies monitor_policy;
        int core_id;

        if (!pri->pvts[chanpos]->outgoing) {
                /* This is not an outgoing call so it cannot be CC monitor. */
                return;
        }

        sig_pri_lock_owner(pri, chanpos);
        owner = pri->pvts[chanpos]->owner;
        if (!owner) {
                return;
        }
        core_id = ast_cc_get_current_core_id(owner);
        if (core_id == -1) {
                /* No CC core setup */
                goto done;
        }

        cc_params = ast_channel_get_cc_config_params(owner);
        if (!cc_params) {
                /* Could not get CC config parameters. */
                goto done;
        }

#if defined(HAVE_PRI_CCSS)
        ast_channel_get_device_name(owner, device_name, sizeof(device_name));
        monitor = ast_cc_get_monitor_by_recall_core_id(core_id, device_name);
        if (monitor) {
                /* CC monitor is already present so no need for generic CC. */
                ao2_ref(monitor, -1);
                goto done;
        }
#endif  /* defined(HAVE_PRI_CCSS) */

        monitor_policy = ast_get_cc_monitor_policy(cc_params);
        switch (monitor_policy) {
        case AST_CC_MONITOR_NEVER:
                /* CCSS is not enabled. */
                break;
        case AST_CC_MONITOR_NATIVE:
                if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
                        /* Request generic CC monitor. */
                        ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
                                sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
                }
                break;
        case AST_CC_MONITOR_ALWAYS:
                if (pri->sig == SIG_BRI_PTMP && pri->nodetype != PRI_NETWORK) {
                        /*
                         * Cannot monitor PTMP TE side since this is not defined.
                         * We are playing the roll of a phone in this case and
                         * a phone cannot monitor a party over the network without
                         * protocol help.
                         */
                        break;
                }
                /*
                 * We are either falling back or this is a PTMP NT span.
                 * Request generic CC monitor.
                 */
                ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
                        sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
                break;
        case AST_CC_MONITOR_GENERIC:
                if (pri->sig == SIG_BRI_PTMP && pri->nodetype == PRI_NETWORK) {
                        /* Request generic CC monitor. */
                        ast_queue_cc_frame(owner, AST_CC_GENERIC_MONITOR_TYPE,
                                sig_pri_get_orig_dialstring(pri->pvts[chanpos]), service, NULL);
                }
                break;
        }

done:
        ast_channel_unlock(owner);
}

#if defined(HAVE_PRI_CCSS)
/*!
 * \internal
 * \brief The CC link canceled the CC instance.
 * \since 1.8
 *
 * \param pri PRI span control structure.
 * \param cc_id CC record ID.
 * \param is_agent TRUE if the cc_id is for an agent.
 *
 * \return Nothing
 */
static void sig_pri_cc_link_canceled(struct sig_pri_span *pri, long cc_id, int is_agent)
{
        if (is_agent) {
                struct ast_cc_agent *agent;

                agent = sig_pri_find_cc_agent_by_cc_id(pri, cc_id);
                if (!agent) {
                        return;
                }
                ast_cc_failed(agent->core_id, "%s agent got canceled by link",
                        sig_pri_cc_type_name);
                ao2_ref(agent, -1);
        } else {
                struct sig_pri_cc_monitor_instance *monitor;

                monitor = sig_pri_find_cc_monitor_by_cc_id(pri, cc_id);
                if (!monitor) {
                        return;
                }
                monitor->cc_id = -1;
                ast_cc_monitor_failed(monitor->core_id, monitor->name,
                        "%s monitor got canceled by link", sig_pri_cc_type_name);
                ao2_ref(monitor, -1);
        }
}
#endif  /* defined(HAVE_PRI_CCSS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert ast_aoc_charged_item to PRI_AOC_CHARGED_ITEM .
 * \since 1.8
 *
 * \param value Value to convert to string.
 *
 * \return PRI_AOC_CHARGED_ITEM
 */
static enum PRI_AOC_CHARGED_ITEM sig_pri_aoc_charged_item_to_pri(enum PRI_AOC_CHARGED_ITEM value)
{
        switch (value) {
        case AST_AOC_CHARGED_ITEM_NA:
                return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
        case AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
                return PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
        case AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
                return PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
        case AST_AOC_CHARGED_ITEM_CALL_ATTEMPT:
                return PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT;
        case AST_AOC_CHARGED_ITEM_CALL_SETUP:
                return PRI_AOC_CHARGED_ITEM_CALL_SETUP;
        case AST_AOC_CHARGED_ITEM_USER_USER_INFO:
                return PRI_AOC_CHARGED_ITEM_USER_USER_INFO;
        case AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
                return PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
        }
        return PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE;
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert PRI_AOC_CHARGED_ITEM to ast_aoc_charged_item.
 * \since 1.8
 *
 * \param value Value to convert to string.
 *
 * \return ast_aoc_charged_item
 */
static enum ast_aoc_s_charged_item sig_pri_aoc_charged_item_to_ast(enum PRI_AOC_CHARGED_ITEM value)
{
        switch (value) {
        case PRI_AOC_CHARGED_ITEM_NOT_AVAILABLE:
                return AST_AOC_CHARGED_ITEM_NA;
        case PRI_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT:
                return AST_AOC_CHARGED_ITEM_SPECIAL_ARRANGEMENT;
        case PRI_AOC_CHARGED_ITEM_BASIC_COMMUNICATION:
                return AST_AOC_CHARGED_ITEM_BASIC_COMMUNICATION;
        case PRI_AOC_CHARGED_ITEM_CALL_ATTEMPT:
                return AST_AOC_CHARGED_ITEM_CALL_ATTEMPT;
        case PRI_AOC_CHARGED_ITEM_CALL_SETUP:
                return AST_AOC_CHARGED_ITEM_CALL_SETUP;
        case PRI_AOC_CHARGED_ITEM_USER_USER_INFO:
                return AST_AOC_CHARGED_ITEM_USER_USER_INFO;
        case PRI_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE:
                return AST_AOC_CHARGED_ITEM_SUPPLEMENTARY_SERVICE;
        }
        return AST_AOC_CHARGED_ITEM_NA;
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert AST_AOC_MULTIPLER to PRI_AOC_MULTIPLIER.
 * \since 1.8
 *
 * \return pri enum equivalent.
 */
static int sig_pri_aoc_multiplier_from_ast(enum ast_aoc_currency_multiplier mult)
{
        switch (mult) {
        case AST_AOC_MULT_ONETHOUSANDTH:
                return PRI_AOC_MULTIPLIER_THOUSANDTH;
        case AST_AOC_MULT_ONEHUNDREDTH:
                return PRI_AOC_MULTIPLIER_HUNDREDTH;
        case AST_AOC_MULT_ONETENTH:
                return PRI_AOC_MULTIPLIER_TENTH;
        case AST_AOC_MULT_ONE:
                return PRI_AOC_MULTIPLIER_ONE;
        case AST_AOC_MULT_TEN:
                return PRI_AOC_MULTIPLIER_TEN;
        case AST_AOC_MULT_HUNDRED:
                return PRI_AOC_MULTIPLIER_HUNDRED;
        case AST_AOC_MULT_THOUSAND:
                return PRI_AOC_MULTIPLIER_THOUSAND;
        default:
                return PRI_AOC_MULTIPLIER_ONE;
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert PRI_AOC_MULTIPLIER to AST_AOC_MULTIPLIER
 * \since 1.8
 *
 * \return ast enum equivalent.
 */
static int sig_pri_aoc_multiplier_from_pri(const int mult)
{
        switch (mult) {
        case PRI_AOC_MULTIPLIER_THOUSANDTH:
                return AST_AOC_MULT_ONETHOUSANDTH;
        case PRI_AOC_MULTIPLIER_HUNDREDTH:
                return AST_AOC_MULT_ONEHUNDREDTH;
        case PRI_AOC_MULTIPLIER_TENTH:
                return AST_AOC_MULT_ONETENTH;
        case PRI_AOC_MULTIPLIER_ONE:
                return AST_AOC_MULT_ONE;
        case PRI_AOC_MULTIPLIER_TEN:
                return AST_AOC_MULT_TEN;
        case PRI_AOC_MULTIPLIER_HUNDRED:
                return AST_AOC_MULT_HUNDRED;
        case PRI_AOC_MULTIPLIER_THOUSAND:
                return AST_AOC_MULT_THOUSAND;
        default:
                return AST_AOC_MULT_ONE;
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert ast_aoc_time_scale representation to PRI_AOC_TIME_SCALE
 * \since 1.8
 *
 * \param value Value to convert to ast representation
 *
 * \return PRI_AOC_TIME_SCALE
 */
static enum PRI_AOC_TIME_SCALE sig_pri_aoc_scale_to_pri(enum ast_aoc_time_scale value)
{
        switch (value) {
        default:
        case AST_AOC_TIME_SCALE_HUNDREDTH_SECOND:
                return PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND;
        case AST_AOC_TIME_SCALE_TENTH_SECOND:
                return PRI_AOC_TIME_SCALE_TENTH_SECOND;
        case AST_AOC_TIME_SCALE_SECOND:
                return PRI_AOC_TIME_SCALE_SECOND;
        case AST_AOC_TIME_SCALE_TEN_SECOND:
                return PRI_AOC_TIME_SCALE_TEN_SECOND;
        case AST_AOC_TIME_SCALE_MINUTE:
                return PRI_AOC_TIME_SCALE_MINUTE;
        case AST_AOC_TIME_SCALE_HOUR:
                return PRI_AOC_TIME_SCALE_HOUR;
        case AST_AOC_TIME_SCALE_DAY:
                return PRI_AOC_TIME_SCALE_DAY;
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Convert PRI_AOC_TIME_SCALE to ast aoc representation
 * \since 1.8
 *
 * \param value Value to convert to ast representation
 *
 * \return ast aoc time scale
 */
static enum ast_aoc_time_scale sig_pri_aoc_scale_to_ast(enum PRI_AOC_TIME_SCALE value)
{
        switch (value) {
        default:
        case PRI_AOC_TIME_SCALE_HUNDREDTH_SECOND:
                return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
        case PRI_AOC_TIME_SCALE_TENTH_SECOND:
                return AST_AOC_TIME_SCALE_TENTH_SECOND;
        case PRI_AOC_TIME_SCALE_SECOND:
                return AST_AOC_TIME_SCALE_SECOND;
        case PRI_AOC_TIME_SCALE_TEN_SECOND:
                return AST_AOC_TIME_SCALE_TEN_SECOND;
        case PRI_AOC_TIME_SCALE_MINUTE:
                return AST_AOC_TIME_SCALE_MINUTE;
        case PRI_AOC_TIME_SCALE_HOUR:
                return AST_AOC_TIME_SCALE_HOUR;
        case PRI_AOC_TIME_SCALE_DAY:
                return AST_AOC_TIME_SCALE_DAY;
        }
        return AST_AOC_TIME_SCALE_HUNDREDTH_SECOND;
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Handle AOC-S control frame
 * \since 1.8
 *
 * \param aoc_s AOC-S event parameters.
 * \param owner Asterisk channel associated with the call.
 * \param passthrough indicating if this message should be queued on the ast channel
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri private is locked
 * \note Assumes the owner channel lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_aoc_s_from_pri(const struct pri_subcmd_aoc_s *aoc_s, struct ast_channel *owner, int passthrough)
{
        struct ast_aoc_decoded *decoded = NULL;
        struct ast_aoc_encoded *encoded = NULL;
        size_t encoded_size = 0;
        int idx;

        if (!owner || !aoc_s) {
                return;
        }

        if (!(decoded = ast_aoc_create(AST_AOC_S, 0, 0))) {
                return;
        }

        for (idx = 0; idx < aoc_s->num_items; ++idx) {
                enum ast_aoc_s_charged_item charged_item;

                charged_item = sig_pri_aoc_charged_item_to_ast(aoc_s->item[idx].chargeable);
                if (charged_item == AST_AOC_CHARGED_ITEM_NA) {
                        /* Delete the unknown charged item from the list. */
                        continue;
                }
                switch (aoc_s->item[idx].rate_type) {
                case PRI_AOC_RATE_TYPE_DURATION:
                        ast_aoc_s_add_rate_duration(decoded,
                                charged_item,
                                aoc_s->item[idx].rate.duration.amount.cost,
                                sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.duration.amount.multiplier),
                                aoc_s->item[idx].rate.duration.currency,
                                aoc_s->item[idx].rate.duration.time.length,
                                sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.time.scale),
                                aoc_s->item[idx].rate.duration.granularity.length,
                                sig_pri_aoc_scale_to_ast(aoc_s->item[idx].rate.duration.granularity.scale),
                                aoc_s->item[idx].rate.duration.charging_type);
                        break;
                case PRI_AOC_RATE_TYPE_FLAT:
                        ast_aoc_s_add_rate_flat(decoded,
                                charged_item,
                                aoc_s->item[idx].rate.flat.amount.cost,
                                sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.flat.amount.multiplier),
                                aoc_s->item[idx].rate.flat.currency);
                        break;
                case PRI_AOC_RATE_TYPE_VOLUME:
                        ast_aoc_s_add_rate_volume(decoded,
                                charged_item,
                                aoc_s->item[idx].rate.volume.unit,
                                aoc_s->item[idx].rate.volume.amount.cost,
                                sig_pri_aoc_multiplier_from_pri(aoc_s->item[idx].rate.volume.amount.multiplier),
                                aoc_s->item[idx].rate.volume.currency);
                        break;
                case PRI_AOC_RATE_TYPE_SPECIAL_CODE:
                        ast_aoc_s_add_rate_special_charge_code(decoded,
                                charged_item,
                                aoc_s->item[idx].rate.special);
                        break;
                case PRI_AOC_RATE_TYPE_FREE:
                        ast_aoc_s_add_rate_free(decoded, charged_item, 0);
                        break;
                case PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
                        ast_aoc_s_add_rate_free(decoded, charged_item, 1);
                        break;
                default:
                        ast_aoc_s_add_rate_na(decoded, charged_item);
                        break;
                }
        }

        if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
                ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
        }

        ast_aoc_manager_event(decoded, owner);

        ast_aoc_destroy_decoded(decoded);
        ast_aoc_destroy_encoded(encoded);
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Generate AOC Request Response
 * \since 1.8
 *
 * \param aoc_request
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri private is locked
 * \note Assumes the owner channel lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_aoc_request_from_pri(const struct pri_subcmd_aoc_request *aoc_request, struct sig_pri_chan *pvt, q931_call *call)
{
        int request;

        if (!aoc_request) {
                return;
        }

        request = aoc_request->charging_request;

        if (request & PRI_AOC_REQUEST_S) {
                if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_S) {
                        /* An AOC-S response must come from the other side, so save off this invoke_id
                         * and see if an AOC-S message comes in before the call is answered. */
                        pvt->aoc_s_request_invoke_id = aoc_request->invoke_id;
                        pvt->aoc_s_request_invoke_id_valid = 1;

                } else {
                        pri_aoc_s_request_response_send(pvt->pri->pri,
                                call,
                                aoc_request->invoke_id,
                                NULL);
                }
        }

        if (request & PRI_AOC_REQUEST_D) {
                if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_D) {
                        pri_aoc_de_request_response_send(pvt->pri->pri,
                                call,
                                PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
                                aoc_request->invoke_id);
                } else {
                        pri_aoc_de_request_response_send(pvt->pri->pri,
                                call,
                                PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
                                aoc_request->invoke_id);
                }
        }

        if (request & PRI_AOC_REQUEST_E) {
                if (pvt->pri->aoc_passthrough_flag & SIG_PRI_AOC_GRANT_E) {
                        pri_aoc_de_request_response_send(pvt->pri->pri,
                                call,
                                PRI_AOC_REQ_RSP_CHARGING_INFO_FOLLOWS,
                                aoc_request->invoke_id);
                } else {
                        pri_aoc_de_request_response_send(pvt->pri->pri,
                                call,
                                PRI_AOC_REQ_RSP_ERROR_NOT_AVAILABLE,
                                aoc_request->invoke_id);
                }
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Generate AOC-D AST_CONTROL_AOC frame
 * \since 1.8
 *
 * \param aoc_e AOC-D event parameters.
 * \param owner Asterisk channel associated with the call.
 * \param passthrough indicating if this message should be queued on the ast channel
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri private is locked
 * \note Assumes the owner channel lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_aoc_d_from_pri(const struct pri_subcmd_aoc_d *aoc_d, struct ast_channel *owner, int passthrough)
{
        struct ast_aoc_decoded *decoded = NULL;
        struct ast_aoc_encoded *encoded = NULL;
        size_t encoded_size = 0;
        enum ast_aoc_charge_type type;

        if (!owner || !aoc_d) {
                return;
        }

        switch (aoc_d->charge) {
        case PRI_AOC_DE_CHARGE_CURRENCY:
                type = AST_AOC_CHARGE_CURRENCY;
                break;
        case PRI_AOC_DE_CHARGE_UNITS:
                type = AST_AOC_CHARGE_UNIT;
                break;
        case PRI_AOC_DE_CHARGE_FREE:
                type = AST_AOC_CHARGE_FREE;
                break;
        default:
                type = AST_AOC_CHARGE_NA;
                break;
        }

        if (!(decoded = ast_aoc_create(AST_AOC_D, type, 0))) {
                return;
        }

        switch (aoc_d->billing_accumulation) {
        default:
                ast_debug(1, "AOC-D billing accumulation has unknown value: %d\n",
                        aoc_d->billing_accumulation);
                /* Fall through */
        case 0:/* subTotal */
                ast_aoc_set_total_type(decoded, AST_AOC_SUBTOTAL);
                break;
        case 1:/* total */
                ast_aoc_set_total_type(decoded, AST_AOC_TOTAL);
                break;
        }

        switch (aoc_d->billing_id) {
        case PRI_AOC_D_BILLING_ID_NORMAL:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
                break;
        case PRI_AOC_D_BILLING_ID_REVERSE:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
                break;
        case PRI_AOC_D_BILLING_ID_CREDIT_CARD:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
                break;
        case PRI_AOC_D_BILLING_ID_NOT_AVAILABLE:
        default:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
                break;
        }

        switch (aoc_d->charge) {
        case PRI_AOC_DE_CHARGE_CURRENCY:
                ast_aoc_set_currency_info(decoded,
                        aoc_d->recorded.money.amount.cost,
                        sig_pri_aoc_multiplier_from_pri(aoc_d->recorded.money.amount.multiplier),
                        aoc_d->recorded.money.currency);
                break;
        case PRI_AOC_DE_CHARGE_UNITS:
                {
                        int i;
                        for (i = 0; i < aoc_d->recorded.unit.num_items; ++i) {
                                /* if type or number are negative, then they are not present */
                                ast_aoc_add_unit_entry(decoded,
                                        (aoc_d->recorded.unit.item[i].number >= 0 ? 1 : 0),
                                        aoc_d->recorded.unit.item[i].number,
                                        (aoc_d->recorded.unit.item[i].type >= 0 ? 1 : 0),
                                        aoc_d->recorded.unit.item[i].type);
                        }
                }
                break;
        }

        if (passthrough && (encoded = ast_aoc_encode(decoded, &encoded_size, owner))) {
                ast_queue_control_data(owner, AST_CONTROL_AOC, encoded, encoded_size);
        }

        ast_aoc_manager_event(decoded, owner);

        ast_aoc_destroy_decoded(decoded);
        ast_aoc_destroy_encoded(encoded);
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief Generate AOC-E AST_CONTROL_AOC frame
 * \since 1.8
 *
 * \param aoc_e AOC-E event parameters.
 * \param owner Asterisk channel associated with the call.
 * \param passthrough indicating if this message should be queued on the ast channel
 *
 * \note Assumes the pri->lock is already obtained.
 * \note Assumes the sig_pri private is locked
 * \note Assumes the owner channel lock is already obtained.
 * \note owner channel may be NULL. In that case, generate event only
 *
 * \return Nothing
 */
static void sig_pri_aoc_e_from_pri(const struct pri_subcmd_aoc_e *aoc_e, struct ast_channel *owner, int passthrough)
{
        struct ast_aoc_decoded *decoded = NULL;
        struct ast_aoc_encoded *encoded = NULL;
        size_t encoded_size = 0;
        enum ast_aoc_charge_type type;

        if (!aoc_e) {
                return;
        }

        switch (aoc_e->charge) {
        case PRI_AOC_DE_CHARGE_CURRENCY:
                type = AST_AOC_CHARGE_CURRENCY;
                break;
        case PRI_AOC_DE_CHARGE_UNITS:
                type = AST_AOC_CHARGE_UNIT;
                break;
        case PRI_AOC_DE_CHARGE_FREE:
                type = AST_AOC_CHARGE_FREE;
                break;
        default:
                type = AST_AOC_CHARGE_NA;
                break;
        }