[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

#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 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_alarm(struct sig_pri_chan *p, int in_alarm)
{
        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) */

/*!
 * \internal
 * \brief Reevaluate the PRI span device state.
 * \since 1.8
 *
 * \param pri Asterisk D channel control structure.
 *
 * \return Nothing
 *
 * \note Assumes the pri->lock is already obtained.
 */
static void 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 inline int 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) {
                        PRI_DEADLOCK_AVOIDANCE(p);
                }
        } while (res);
        /* Then break the poll */
        pthread_kill(pri->master, SIGURG);
        return 0;
}

/*!
 * \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 PRES_ALLOWED_USER_NUMBER_NOT_SCREENED:
                ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
                break;
        case PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
                ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
                break;
        case PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
                ast_presentation = AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
                break;
        case PRES_ALLOWED_NETWORK_NUMBER:
                ast_presentation = AST_PRES_ALLOWED_NETWORK_NUMBER;
                break;
        case PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
                ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
                break;
        case PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
                ast_presentation = AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
                break;
        case PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
                ast_presentation = AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
                break;
        case PRES_PROHIB_NETWORK_NUMBER:
                ast_presentation = AST_PRES_PROHIB_NETWORK_NUMBER;
                break;
        case PRES_NUMBER_NOT_AVAILABLE:
                ast_presentation = AST_PRES_NUMBER_NOT_AVAILABLE;
                break;
        default:
                ast_presentation = AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
                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_USER_NUMBER_NOT_SCREENED:
                pri_presentation = PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
                break;
        case AST_PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN:
                pri_presentation = PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN;
                break;
        case AST_PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN:
                pri_presentation = PRES_ALLOWED_USER_NUMBER_FAILED_SCREEN;
                break;
        case AST_PRES_ALLOWED_NETWORK_NUMBER:
                pri_presentation = PRES_ALLOWED_NETWORK_NUMBER;
                break;
        case AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED:
                pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
                break;
        case AST_PRES_PROHIB_USER_NUMBER_PASSED_SCREEN:
                pri_presentation = PRES_PROHIB_USER_NUMBER_PASSED_SCREEN;
                break;
        case AST_PRES_PROHIB_USER_NUMBER_FAILED_SCREEN:
                pri_presentation = PRES_PROHIB_USER_NUMBER_FAILED_SCREEN;
                break;
        case AST_PRES_PROHIB_NETWORK_NUMBER:
                pri_presentation = PRES_PROHIB_NETWORK_NUMBER;
                break;
        case AST_PRES_NUMBER_NOT_AVAILABLE:
                pri_presentation = PRES_NUMBER_NOT_AVAILABLE;
                break;
        default:
                pri_presentation = PRES_PROHIB_USER_NUMBER_NOT_SCREENED;
                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;
                        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->redirecting.from);
        sig_pri_party_id_from_ast(&pri_redirecting.to, &ast->redirecting.to);
        pri_redirecting.count = ast->redirecting.count;
        pri_redirecting.reason = ast_to_pri_reason(ast->redirecting.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 (!p->owner)
                p->owner = c;
        p->isidlecall = 0;
        p->alreadyhungup = 0;
        c->transfercapability = 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 && !pri_grab(p, p->pri)) {
                sig_pri_span_devstate_changed(p->pri);
                pri_rel(p->pri);
        } else {
                ast_log(LOG_WARNING, "Failed to grab PRI!\n");
        }

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

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_log(LOG_DEBUG, "%s %d\n", __FUNCTION__, p->channel);

        p->outgoing = 1;
        ast = sig_pri_new_ast_channel(p, AST_STATE_RESERVED, law, transfercapability, p->exten, requestor);
        if (!ast) {
                p->outgoing = 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 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 int pri_find_dchan(struct sig_pri_span *pri)
{
        int oldslot = -1;
        struct pri *old;
        int newslot = -1;
        int x;
        old = pri->pri;
        for (x = 0; x < SIG_PRI_NUM_DCHANS; x++) {
                if ((pri->dchanavail[x] == DCHAN_AVAILABLE) && (newslot < 0))
                        newslot = x;
                if (pri->dchans[x] == old) {
                        oldslot = x;
                }
        }
        if (newslot < 0) {
                newslot = 0;
                /* 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, "No D-channels available!  Using Primary channel as D-channel anyway!\n");
                }
        }
        if (old && (oldslot != newslot))
                ast_log(LOG_NOTICE, "Switching from d-channel fd %d to fd %d!\n",
                        pri->fds[oldslot], pri->fds[newslot]);
        pri->pri = pri->dchans[newslot];
        return 0;
}

/*!
 * \internal
 * \brief Obtain the sig_pri owner channel lock if the owner exists.
 * \since 1.8
 *
 * \param pri sig_pri PRI 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);
                PRI_DEADLOCK_AVOIDANCE(pri->pvts[chanpos]);
                ast_mutex_lock(&pri->lock);
        }
}

/*!
 * \internal
 * \brief Queue the given frame onto the owner channel.
 * \since 1.8
 *
 * \param pri sig_pri PRI 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 sig_pri PRI 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);
}

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)) {
                if (!call) {
                        /* Cannot find a call waiting call or held call without a call. */
                        return -1;
                }
                principle = -1;
                for (x = 0; x < pri->numchans; ++x) {
                        if (pri->pvts[x]
                                && pri->pvts[x]->call == call) {
                                principle = x;
                                break;
                        }
                }
                return principle;
        }

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

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

                ast_verb(3, "Moving call from channel %d to channel %d\n",
                        old_chan->channel, new_chan->channel);
                if (new_chan->owner) {
                        ast_log(LOG_WARNING,
                                "Can't fix up channel from %d to %d because %d is already in use\n",
                                old_chan->channel, new_chan->channel, new_chan->channel);
                        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->alerting = old_chan->alerting;
                new_chan->alreadyhungup = old_chan->alreadyhungup;
                new_chan->isidlecall = old_chan->isidlecall;
                new_chan->proceeding = old_chan->proceeding;
                new_chan->progress = old_chan->progress;
                new_chan->setup_ack = old_chan->setup_ack;
                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->alerting = 0;
                old_chan->alreadyhungup = 0;
                old_chan->isidlecall = 0;
                old_chan->proceeding = 0;
                old_chan->progress = 0;
                old_chan->setup_ack = 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. */
#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) */
#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;
                }

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

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

static void apply_plan_to_number(char *buf, size_t size, const struct sig_pri_span *pri, const char *number, const 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;
        }
}

/*! \note Assumes the pri->lock is already obtained. */
static int pri_check_restart(struct sig_pri_span *pri)
{
#if defined(HAVE_PRI_SERVICE_MESSAGES)
tryanotherpos:
#endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */
        do {
                pri->resetpos++;
        } while (pri->resetpos < pri->numchans
                && (!pri->pvts[pri->resetpos]
                        || pri->pvts[pri->resetpos]->no_b_channel
                        || pri->pvts[pri->resetpos]->call
                        || pri->pvts[pri->resetpos]->resetting));
        if (pri->resetpos < pri->numchans) {
#if defined(HAVE_PRI_SERVICE_MESSAGES)
                unsigned why;

                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");
                        goto tryanotherpos;
                }
#endif  /* defined(HAVE_PRI_SERVICE_MESSAGES) */

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

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

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
                        && !pri->pvts[x]->inalarm
                        && !pri->pvts[x]->owner) {
                        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 sig_pri span controller to find interface.
 *
 * \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
                        && !pri->pvts[idx]->inalarm
                        && !pri->pvts[idx]->owner) {
                        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) */

#if defined(HAVE_PRI_CALL_HOLD)
/*!
 * \internal
 * \brief Find the channel associated with the libpri call.
 * \since 1.8
 *
 * \param pri sig_pri span controller to find interface.
 * \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_pri_call(struct sig_pri_span *pri, q931_call *call)
{
        int idx;

        for (idx = 0; idx < pri->numchans; ++idx) {
                if (pri->pvts[idx] && pri->pvts[idx]->call == call) {
                        /* Found the channel */
                        return idx;
                }
        }
        return -1;
}
#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", chan->name);
        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", chan->name, 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_copy_string(chan->exten, pvt->pri->idleext, sizeof(chan->exten));
                                ast_copy_string(chan->context, pvt->pri->idlecontext, sizeof(chan->context));
                                chan->priority = 1;
                                ast_verb(4, "Idle channel '%s' answered, sending to %s@%s\n", chan->name, chan->exten, chan->context);
                                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", chan->name);
                                break;
                        case AST_CONTROL_CONGESTION:
                                ast_verb(4, "Idle channel '%s' congested, waiting...\n", chan->name);
                                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 (!chan->tech_pvt) {
                ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", chan->name);
                ast_hangup(chan);
                return NULL;
        }

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

        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, chan->context, exten, 1, p->cid_num)) {
                if (len && !ast_ignore_pattern(chan->context, exten))
                        sig_pri_play_tone(p, -1);
                else
                        sig_pri_play_tone(p, SIG_PRI_TONE_DIALTONE);
                if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num))
                        timeout = pri_matchdigittimeout;
                else
                        timeout = pri_gendigittimeout;
                res = ast_waitfordigit(chan, timeout);
                if (res < 0) {
                        ast_log(LOG_DEBUG, "waitfordigit returned < 0...\n");
                        ast_hangup(chan);
                        return NULL;
                } else if (res) {
                        exten[len++] = res;
                        exten[len] = '\0';
                } else
                        break;
        }
        /* if no extension was received ('unspecified') on overlap call, use the 's' extension */
        if (ast_strlen_zero(exten)) {
                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(chan->dialed.number.str);
                chan->dialed.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(chan->caller.id.tag);
                        chan->caller.id.tag = ast_strdup(p->user_tag);
                }
        }
        sig_pri_play_tone(p, -1);
        if (ast_exists_extension(chan, chan->context, exten, 1, p->cid_num)) {
                /* Start the real PBX */
                ast_copy_string(chan->exten, exten, sizeof(chan->exten));
                sig_pri_dsp_reset_and_flush_digits(p);
                if (p->pri->overlapdial & DAHDI_OVERLAPDIAL_INCOMING) {
                        sig_pri_lock_private(p);
                        if (p->pri->pri) {              
                                if (!pri_grab(p, p->pri)) {
                                        pri_proceeding(p->pri->pri, p->call, PVT_TO_CHANNEL(p), 0);
                                        p->proceeding = 1;
                                        pri_rel(p->pri);
                                } else {
                                        ast_log(LOG_WARNING, "Unable to grab PRI on span %d\n", p->pri->span);
                                }
                        }
                        sig_pri_unlock_private(p);
                }

                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_log(LOG_DEBUG, "No such possible extension '%s' in context '%s'\n", exten, chan->context);
                chan->hangupcause = AST_CAUSE_UNALLOCATED;
                ast_hangup(chan);
                p->exten[0] = '\0';
                /* Since we send release complete here, we won't get one */
                p->call = NULL;
        }
        return NULL;
}

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 Span controlling 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_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 Span controlling 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 Span controlling 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 sig_pri PRI 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. */
                ast_str_append(&msg, 0, "Channel: %s\r\n", owner->name);
                ast_str_append(&msg, 0, "UniqueID: %s\r\n", owner->uniqueid);

                sig_pri_event_party_id(&msg, "CallerID", &owner->connected.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_CALL_HOLD) || defined(HAVE_PRI_TRANSFER)
/*!
 * \internal
 * \brief Attempt to transfer the two calls to each other.
 * \since 1.8
 *
 * \param pri sig_pri PRI control structure.
 * \param call_1 First call involved in the transfer.
 * \param call_1_held TRUE if call_1 is on hold.
 * \param call_2 Second call involved in the transfer.
 * \param call_2_held TRUE if call_2 is on hold.
 *
 * \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, int call_1_held, q931_call *call_2, int call_2_held)
{
        int retval;
        int call_1_chanpos;
        int call_2_chanpos;
        struct ast_channel *call_1_ast;
        struct ast_channel *call_2_ast;
        struct ast_channel *bridged;

        call_1_chanpos = pri_find_pri_call(pri, call_1);
        call_2_chanpos = pri_find_pri_call(pri, call_2);
        if (call_1_chanpos < 0 || call_2_chanpos < 0) {
                return -1;
        }

        /* 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) {
                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]);
                return -1;
        }

        bridged = ast_bridged_channel(call_2_ast);
        if (bridged) {
                if (call_1_held) {
                        ast_queue_control(call_1_ast, AST_CONTROL_UNHOLD);
                }
                if (call_2_held) {
                        ast_queue_control(call_2_ast, AST_CONTROL_UNHOLD);
                }

                ast_verb(3, "TRANSFERRING %s to %s\n", call_2_ast->name, call_1_ast->name);
                retval = ast_channel_masquerade(call_1_ast, bridged);
        } else {
                /* Try masquerading the other way. */
                bridged = ast_bridged_channel(call_1_ast);
                if (bridged) {
                        if (call_1_held) {
                                ast_queue_control(call_1_ast, AST_CONTROL_UNHOLD);
                        }
                        if (call_2_held) {
                                ast_queue_control(call_2_ast, AST_CONTROL_UNHOLD);
                        }

                        ast_verb(3, "TRANSFERRING %s to %s\n", call_1_ast->name, call_2_ast->name);
                        retval = ast_channel_masquerade(call_2_ast, bridged);
                } else {
                        /* Could not transfer. */
                        retval = -1;
                }
        }
        if (bridged && retval) {
                /* Restore HOLD on held calls because masquerade failed. */
                if (call_1_held) {
                        ast_queue_control(call_1_ast, AST_CONTROL_HOLD);
                }
                if (call_2_held) {
                        ast_queue_control(call_2_ast, AST_CONTROL_HOLD);
                }
        }

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

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

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

        switch (aoc_e->associated.charging_type) {
        case PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER:
                if (!aoc_e->associated.charge.number.valid) {
                        break;
                }
                ast_aoc_set_association_number(decoded, aoc_e->associated.charge.number.str, aoc_e->associated.charge.number.plan);
                break;
        case PRI_AOC_E_CHARGING_ASSOCIATION_ID:
                ast_aoc_set_association_id(decoded, aoc_e->associated.charge.id);
                break;
        default:
                break;
        }

        switch (aoc_e->billing_id) {
        case PRI_AOC_E_BILLING_ID_NORMAL:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NORMAL);
                break;
        case PRI_AOC_E_BILLING_ID_REVERSE:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_REVERSE_CHARGE);
                break;
        case PRI_AOC_E_BILLING_ID_CREDIT_CARD:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CREDIT_CARD);
                break;
        case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL);
                break;
        case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_BUSY);
                break;
        case PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_FWD_NO_REPLY);
                break;
        case PRI_AOC_E_BILLING_ID_CALL_DEFLECTION:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_DEFLECTION);
                break;
        case PRI_AOC_E_BILLING_ID_CALL_TRANSFER:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_CALL_TRANSFER);
                break;
        case PRI_AOC_E_BILLING_ID_NOT_AVAILABLE:
        default:
                ast_aoc_set_billing_id(decoded, AST_AOC_BILLING_NA);
                break;
        }

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

        if (passthrough && owner && (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 send an AOC-S message on the current call
 *
 * \param pvt sig_pri private channel structure.
 * \param generic decoded ast AOC message
 *
 * \return Nothing
 *
 * \note Assumes that the PRI lock is already obtained.
 */
static void sig_pri_aoc_s_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
{
        struct pri_subcmd_aoc_s aoc_s = { 0, };
        const struct ast_aoc_s_entry *entry;
        int idx;

        for (idx = 0; idx < ast_aoc_s_get_count(decoded); idx++) {
                if (!(entry = ast_aoc_s_get_rate_info(decoded, idx))) {
                        break;
                }

                aoc_s.item[idx].chargeable = sig_pri_aoc_charged_item_to_pri(entry->charged_item);

                switch (entry->rate_type) {
                case AST_AOC_RATE_TYPE_DURATION:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_DURATION;
                        aoc_s.item[idx].rate.duration.amount.cost = entry->rate.duration.amount;
                        aoc_s.item[idx].rate.duration.amount.multiplier =
                                sig_pri_aoc_multiplier_from_ast(entry->rate.duration.multiplier);
                        aoc_s.item[idx].rate.duration.time.length = entry->rate.duration.time;
                        aoc_s.item[idx].rate.duration.time.scale =
                                sig_pri_aoc_scale_to_pri(entry->rate.duration.time_scale);
                        aoc_s.item[idx].rate.duration.granularity.length = entry->rate.duration.granularity_time;
                        aoc_s.item[idx].rate.duration.granularity.scale =
                                sig_pri_aoc_scale_to_pri(entry->rate.duration.granularity_time_scale);
                        aoc_s.item[idx].rate.duration.charging_type = entry->rate.duration.charging_type;

                        if (!ast_strlen_zero(entry->rate.duration.currency_name)) {
                                ast_copy_string(aoc_s.item[idx].rate.duration.currency,
                                        entry->rate.duration.currency_name,
                                        sizeof(aoc_s.item[idx].rate.duration.currency));
                        }
                        break;
                case AST_AOC_RATE_TYPE_FLAT:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FLAT;
                        aoc_s.item[idx].rate.flat.amount.cost = entry->rate.flat.amount;
                        aoc_s.item[idx].rate.flat.amount.multiplier =
                                sig_pri_aoc_multiplier_from_ast(entry->rate.flat.multiplier);

                        if (!ast_strlen_zero(entry->rate.flat.currency_name)) {
                                ast_copy_string(aoc_s.item[idx].rate.flat.currency,
                                        entry->rate.flat.currency_name,
                                        sizeof(aoc_s.item[idx].rate.flat.currency));
                        }
                        break;
                case AST_AOC_RATE_TYPE_VOLUME:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_VOLUME;
                        aoc_s.item[idx].rate.volume.unit = entry->rate.volume.volume_unit;
                        aoc_s.item[idx].rate.volume.amount.cost = entry->rate.volume.amount;
                        aoc_s.item[idx].rate.volume.amount.multiplier =
                                sig_pri_aoc_multiplier_from_ast(entry->rate.volume.multiplier);

                        if (!ast_strlen_zero(entry->rate.volume.currency_name)) {
                                ast_copy_string(aoc_s.item[idx].rate.volume.currency,
                                        entry->rate.volume.currency_name,
                                        sizeof(aoc_s.item[idx].rate.volume.currency));
                        }
                        break;
                case AST_AOC_RATE_TYPE_SPECIAL_CODE:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_SPECIAL_CODE;
                        aoc_s.item[idx].rate.special = entry->rate.special_code;
                        break;
                case AST_AOC_RATE_TYPE_FREE:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE;
                        break;
                case AST_AOC_RATE_TYPE_FREE_FROM_BEGINNING:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_FREE_FROM_BEGINNING;
                        break;
                default:
                case AST_AOC_RATE_TYPE_NA:
                        aoc_s.item[idx].rate_type = PRI_AOC_RATE_TYPE_NOT_AVAILABLE;
                        break;
                }
        }
        aoc_s.num_items = idx;

        /* if this rate should be sent as a response to an AOC-S request we will
         * have an aoc_s_request_invoke_id associated with this pvt */
        if (pvt->aoc_s_request_invoke_id_valid) {
                pri_aoc_s_request_response_send(pvt->pri->pri, pvt->call, pvt->aoc_s_request_invoke_id, &aoc_s);
                pvt->aoc_s_request_invoke_id_valid = 0;
        } else {
                pri_aoc_s_send(pvt->pri->pri, pvt->call, &aoc_s);
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief send an AOC-D message on the current call
 *
 * \param pvt sig_pri private channel structure.
 * \param generic decoded ast AOC message
 *
 * \return Nothing
 *
 * \note Assumes that the PRI lock is already obtained.
 */
static void sig_pri_aoc_d_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
{
        struct pri_subcmd_aoc_d aoc_d = { 0, };

        aoc_d.billing_accumulation = (ast_aoc_get_total_type(decoded) == AST_AOC_TOTAL) ? 1 : 0;

        switch (ast_aoc_get_billing_id(decoded)) {
        case AST_AOC_BILLING_NORMAL:
                aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NORMAL;
                break;
        case AST_AOC_BILLING_REVERSE_CHARGE:
                aoc_d.billing_id = PRI_AOC_D_BILLING_ID_REVERSE;
                break;
        case AST_AOC_BILLING_CREDIT_CARD:
                aoc_d.billing_id = PRI_AOC_D_BILLING_ID_CREDIT_CARD;
                break;
        case AST_AOC_BILLING_NA:
        default:
                aoc_d.billing_id = PRI_AOC_D_BILLING_ID_NOT_AVAILABLE;
                break;
        }

        switch (ast_aoc_get_charge_type(decoded)) {
        case AST_AOC_CHARGE_FREE:
                aoc_d.charge = PRI_AOC_DE_CHARGE_FREE;
                break;
        case AST_AOC_CHARGE_CURRENCY:
                {
                        const char *currency_name = ast_aoc_get_currency_name(decoded);
                        aoc_d.charge = PRI_AOC_DE_CHARGE_CURRENCY;
                        aoc_d.recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
                        aoc_d.recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
                        if (!ast_strlen_zero(currency_name)) {
                                ast_copy_string(aoc_d.recorded.money.currency, currency_name, sizeof(aoc_d.recorded.money.currency));
                        }
                }
                break;
        case AST_AOC_CHARGE_UNIT:
                {
                        const struct ast_aoc_unit_entry *entry;
                        int i;
                        aoc_d.charge = PRI_AOC_DE_CHARGE_UNITS;
                        for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
                                if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_d.recorded.unit.item)) {
                                        if (entry->valid_amount) {
                                                aoc_d.recorded.unit.item[i].number = entry->amount;
                                        } else {
                                                aoc_d.recorded.unit.item[i].number = -1;
                                        }
                                        if (entry->valid_type) {
                                                aoc_d.recorded.unit.item[i].type = entry->type;
                                        } else {
                                                aoc_d.recorded.unit.item[i].type = -1;
                                        }
                                        aoc_d.recorded.unit.num_items++;
                                } else {
                                        break;
                                }
                        }
                }
                break;
        case AST_AOC_CHARGE_NA:
        default:
                aoc_d.charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
                break;
        }

        pri_aoc_d_send(pvt->pri->pri, pvt->call, &aoc_d);
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief send an AOC-E message on the current call
 *
 * \param pvt sig_pri private channel structure.
 * \param generic decoded ast AOC message
 *
 * \return Nothing
 *
 * \note Assumes that the PRI lock is already obtained.
 */
static void sig_pri_aoc_e_from_ast(struct sig_pri_chan *pvt, struct ast_aoc_decoded *decoded)
{
        struct pri_subcmd_aoc_e *aoc_e = &pvt->aoc_e;
        const struct ast_aoc_charging_association *ca = ast_aoc_get_association_info(decoded);

        memset(aoc_e, 0, sizeof(*aoc_e));
        pvt->holding_aoce = 1;

        switch (ca->charging_type) {
        case AST_AOC_CHARGING_ASSOCIATION_NUMBER:
                aoc_e->associated.charge.number.valid = 1;
                ast_copy_string(aoc_e->associated.charge.number.str,
                        ca->charge.number.number,
                        sizeof(aoc_e->associated.charge.number.str));
                aoc_e->associated.charge.number.plan = ca->charge.number.plan;
                aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_NUMBER;
                break;
        case AST_AOC_CHARGING_ASSOCIATION_ID:
                aoc_e->associated.charge.id = ca->charge.id;
                aoc_e->associated.charging_type = PRI_AOC_E_CHARGING_ASSOCIATION_ID;
                break;
        case AST_AOC_CHARGING_ASSOCIATION_NA:
        default:
                break;
        }

        switch (ast_aoc_get_billing_id(decoded)) {
        case AST_AOC_BILLING_NORMAL:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NORMAL;
                break;
        case AST_AOC_BILLING_REVERSE_CHARGE:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_REVERSE;
                break;
        case AST_AOC_BILLING_CREDIT_CARD:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CREDIT_CARD;
                break;
        case AST_AOC_BILLING_CALL_FWD_UNCONDITIONAL:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_UNCONDITIONAL;
                break;
        case AST_AOC_BILLING_CALL_FWD_BUSY:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_BUSY;
                break;
        case AST_AOC_BILLING_CALL_FWD_NO_REPLY:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_FORWARDING_NO_REPLY;
                break;
        case AST_AOC_BILLING_CALL_DEFLECTION:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_DEFLECTION;
                break;
        case AST_AOC_BILLING_CALL_TRANSFER:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_CALL_TRANSFER;
                break;
        case AST_AOC_BILLING_NA:
        default:
                aoc_e->billing_id = PRI_AOC_E_BILLING_ID_NOT_AVAILABLE;
                break;
        }

        switch (ast_aoc_get_charge_type(decoded)) {
        case AST_AOC_CHARGE_FREE:
                aoc_e->charge = PRI_AOC_DE_CHARGE_FREE;
                break;
        case AST_AOC_CHARGE_CURRENCY:
                {
                        const char *currency_name = ast_aoc_get_currency_name(decoded);
                        aoc_e->charge = PRI_AOC_DE_CHARGE_CURRENCY;
                        aoc_e->recorded.money.amount.cost = ast_aoc_get_currency_amount(decoded);
                        aoc_e->recorded.money.amount.multiplier = sig_pri_aoc_multiplier_from_ast(ast_aoc_get_currency_multiplier(decoded));
                        if (!ast_strlen_zero(currency_name)) {
                                ast_copy_string(aoc_e->recorded.money.currency, currency_name, sizeof(aoc_e->recorded.money.currency));
                        }
                }
                break;
        case AST_AOC_CHARGE_UNIT:
                {
                        const struct ast_aoc_unit_entry *entry;
                        int i;
                        aoc_e->charge = PRI_AOC_DE_CHARGE_UNITS;
                        for (i = 0; i < ast_aoc_get_unit_count(decoded); i++) {
                                if ((entry = ast_aoc_get_unit_info(decoded, i)) && i < ARRAY_LEN(aoc_e->recorded.unit.item)) {
                                        if (entry->valid_amount) {
                                                aoc_e->recorded.unit.item[i].number = entry->amount;
                                        } else {
                                                aoc_e->recorded.unit.item[i].number = -1;
                                        }
                                        if (entry->valid_type) {
                                                aoc_e->recorded.unit.item[i].type = entry->type;
                                        } else {
                                                aoc_e->recorded.unit.item[i].type = -1;
                                        }
                                        aoc_e->recorded.unit.num_items++;
                                }
                        }
                }
                break;
        case AST_AOC_CHARGE_NA:
        default:
                aoc_e->charge = PRI_AOC_DE_CHARGE_NOT_AVAILABLE;
                break;
        }
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief send an AOC-E termination request on ast_channel and set
 * hangup delay.
 *
 * \param pri sig_pri PRI control structure.
 * \param chanpos Channel position in the span.
 * \param ms to delay hangup
 *
 * \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_send_aoce_termination_request(struct sig_pri_span *pri, int chanpos, unsigned int ms)
{
        struct sig_pri_chan *pvt;
        struct ast_aoc_decoded *decoded = NULL;
        struct ast_aoc_encoded *encoded = NULL;
        size_t encoded_size;
        struct timeval whentohangup = { 0, };

        sig_pri_lock_owner(pri, chanpos);
        pvt = pri->pvts[chanpos];
        if (!pvt->owner) {
                return;
        }

        if (!(decoded = ast_aoc_create(AST_AOC_REQUEST, 0, AST_AOC_REQUEST_E))) {
                ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
                goto cleanup_termination_request;
        }

        ast_aoc_set_termination_request(decoded);

        if (!(encoded = ast_aoc_encode(decoded, &encoded_size, pvt->owner))) {
                ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
                goto cleanup_termination_request;
        }

        /* convert ms to timeval */
        whentohangup.tv_usec = (ms % 1000) * 1000;
        whentohangup.tv_sec = ms / 1000;

        if (ast_queue_control_data(pvt->owner, AST_CONTROL_AOC, encoded, encoded_size)) {
                ast_softhangup_nolock(pvt->owner, AST_SOFTHANGUP_DEV);
                goto cleanup_termination_request;
        }

        pvt->waiting_for_aoce = 1;
        ast_channel_setwhentohangup_tv(pvt->owner, whentohangup);
        ast_log(LOG_DEBUG, "Delaying hangup on %s for aoc-e msg\n", pvt->owner->name);

cleanup_termination_request:
        ast_channel_unlock(pvt->owner);
        ast_aoc_destroy_decoded(decoded);
        ast_aoc_destroy_encoded(encoded);
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

/*!
 * \internal
 * \brief TRUE if PRI event came in on a CIS call.
 * \since 1.8
 *
 * \param channel PRI encoded span/channel
 *
 * \retval non-zero if CIS call.
 */
static int sig_pri_is_cis_call(int channel)
{
        return channel != -1 && (channel & PRI_CIS_CALL);
}

/*!
 * \internal
 * \brief Handle the CIS associated PRI subcommand events.
 * \since 1.8
 *
 * \param pri sig_pri PRI control structure.
 * \param event_id PRI event id
 * \param subcmds Subcommands to process if any. (Could be NULL).
 * \param call_rsp libpri opaque call structure to send any responses toward.
 * Could be NULL either because it is not available or the call is for the
 * dummy call reference.  However, this should not be NULL in the cases that
 * need to use the pointer to send a response message back.
 *
 * \note Assumes the pri->lock is already obtained.
 *
 * \return Nothing
 */
static void sig_pri_handle_cis_subcmds(struct sig_pri_span *pri, int event_id,
        const struct pri_subcommands *subcmds, q931_call *call_rsp)
{
        int index;
#if defined(HAVE_PRI_CCSS)
        struct ast_cc_agent *agent;
        struct sig_pri_cc_agent_prv *agent_prv;
        struct sig_pri_cc_monitor_instance *monitor;
#endif  /* defined(HAVE_PRI_CCSS) */

        if (!subcmds) {
                return;
        }
        for (index = 0; index < subcmds->counter_subcmd; ++index) {
                const struct pri_subcommand *subcmd = &subcmds->subcmd[index];

                switch (subcmd->cmd) {
#if defined(STATUS_REQUEST_PLACE_HOLDER)
                case PRI_SUBCMD_STATUS_REQ:
                case PRI_SUBCMD_STATUS_REQ_RSP:
                        /* Ignore for now. */
                        break;
#endif  /* defined(STATUS_REQUEST_PLACE_HOLDER) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_REQ:
                        agent = sig_pri_find_cc_agent_by_cc_id(pri, subcmd->u.cc_request.cc_id);
                        if (!agent) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
                                break;
                        }
                        if (!ast_cc_request_is_within_limits()) {
                                if (pri_cc_req_rsp(pri->pri, subcmd->u.cc_request.cc_id,
                                        5/* queue_full */)) {
                                        pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
                                }
                                ast_cc_failed(agent->core_id, "%s agent system CC queue full",
                                        sig_pri_cc_type_name);
                                ao2_ref(agent, -1);
                                break;
                        }
                        agent_prv = agent->private_data;
                        agent_prv->cc_request_response_pending = 1;
                        if (ast_cc_agent_accept_request(agent->core_id,
                                "%s caller accepted CC offer.", sig_pri_cc_type_name)) {
                                agent_prv->cc_request_response_pending = 0;
                                if (pri_cc_req_rsp(pri->pri, subcmd->u.cc_request.cc_id,
                                        2/* short_term_denial */)) {
                                        pri_cc_cancel(pri->pri, subcmd->u.cc_request.cc_id);
                                }
                                ast_cc_failed(agent->core_id, "%s agent CC core request accept failed",
                                        sig_pri_cc_type_name);
                        }
                        ao2_ref(agent, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_REQ_RSP:
                        monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
                                subcmd->u.cc_request_rsp.cc_id);
                        if (!monitor) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_request_rsp.cc_id);
                                break;
                        }
                        switch (subcmd->u.cc_request_rsp.status) {
                        case 0:/* success */
                                ast_cc_monitor_request_acked(monitor->core_id,
                                        "%s far end accepted CC request", sig_pri_cc_type_name);
                                break;
                        case 1:/* timeout */
                                ast_verb(2, "core_id:%d %s CC request timeout\n", monitor->core_id,
                                        sig_pri_cc_type_name);
                                ast_cc_monitor_failed(monitor->core_id, monitor->name,
                                        "%s CC request timeout", sig_pri_cc_type_name);
                                break;
                        case 2:/* error */
                                ast_verb(2, "core_id:%d %s CC request error: %s\n", monitor->core_id,
                                        sig_pri_cc_type_name,
                                        pri_facility_error2str(subcmd->u.cc_request_rsp.fail_code));
                                ast_cc_monitor_failed(monitor->core_id, monitor->name,
                                        "%s CC request error", sig_pri_cc_type_name);
                                break;
                        case 3:/* reject */
                                ast_verb(2, "core_id:%d %s CC request reject: %s\n", monitor->core_id,
                                        sig_pri_cc_type_name,
                                        pri_facility_reject2str(subcmd->u.cc_request_rsp.fail_code));
                                ast_cc_monitor_failed(monitor->core_id, monitor->name,
                                        "%s CC request reject", sig_pri_cc_type_name);
                                break;
                        default:
                                ast_verb(2, "core_id:%d %s CC request unknown status %d\n",
                                        monitor->core_id, sig_pri_cc_type_name,
                                        subcmd->u.cc_request_rsp.status);
                                ast_cc_monitor_failed(monitor->core_id, monitor->name,
                                        "%s CC request unknown status", sig_pri_cc_type_name);
                                break;
                        }
                        ao2_ref(monitor, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_REMOTE_USER_FREE:
                        monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
                                subcmd->u.cc_remote_user_free.cc_id);
                        if (!monitor) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_remote_user_free.cc_id);
                                break;
                        }
                        ast_cc_monitor_callee_available(monitor->core_id,
                                "%s callee has become available", sig_pri_cc_type_name);
                        ao2_ref(monitor, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_B_FREE:
                        monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
                                subcmd->u.cc_b_free.cc_id);
                        if (!monitor) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_b_free.cc_id);
                                break;
                        }
                        ast_cc_monitor_party_b_free(monitor->core_id);
                        ao2_ref(monitor, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_STATUS_REQ:
                        monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
                                subcmd->u.cc_status_req.cc_id);
                        if (!monitor) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_status_req.cc_id);
                                break;
                        }
                        ast_cc_monitor_status_request(monitor->core_id);
                        ao2_ref(monitor, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_STATUS_REQ_RSP:
                        agent = sig_pri_find_cc_agent_by_cc_id(pri, subcmd->u.cc_status_req_rsp.cc_id);
                        if (!agent) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_status_req_rsp.cc_id);
                                break;
                        }
                        ast_cc_agent_status_response(agent->core_id,
                                subcmd->u.cc_status_req_rsp.status ? AST_DEVICE_INUSE
                                : AST_DEVICE_NOT_INUSE);
                        ao2_ref(agent, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_STATUS:
                        agent = sig_pri_find_cc_agent_by_cc_id(pri, subcmd->u.cc_status.cc_id);
                        if (!agent) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_status.cc_id);
                                break;
                        }
                        if (subcmd->u.cc_status.status) {
                                ast_cc_agent_caller_busy(agent->core_id, "%s agent caller is busy",
                                        sig_pri_cc_type_name);
                        } else {
                                ast_cc_agent_caller_available(agent->core_id,
                                        "%s agent caller is available", sig_pri_cc_type_name);
                        }
                        ao2_ref(agent, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_CANCEL:
                        sig_pri_cc_link_canceled(pri, subcmd->u.cc_cancel.cc_id,
                                subcmd->u.cc_cancel.is_agent);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_CCSS)
                case PRI_SUBCMD_CC_STOP_ALERTING:
                        monitor = sig_pri_find_cc_monitor_by_cc_id(pri,
                                subcmd->u.cc_stop_alerting.cc_id);
                        if (!monitor) {
                                pri_cc_cancel(pri->pri, subcmd->u.cc_stop_alerting.cc_id);
                                break;
                        }
                        ast_cc_monitor_stop_ringing(monitor->core_id);
                        ao2_ref(monitor, -1);
                        break;
#endif  /* defined(HAVE_PRI_CCSS) */
#if defined(HAVE_PRI_AOC_EVENTS)
                case PRI_SUBCMD_AOC_E:
                        /* Queue AST_CONTROL_AOC frame */
                        sig_pri_aoc_e_from_pri(&subcmd->u.aoc_e, NULL, 0);
                        break;
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */
                default:
                        ast_debug(2,
                                "Unknown CIS subcommand(%d) in %s event on span %d.\n",
                                subcmd->cmd, pri_event2str(event_id), pri->span);
                        break;
                }
        }
}

#if defined(HAVE_PRI_AOC_EVENTS)
/*!
 * \internal
 * \brief detect if AOC-S subcmd is present.
 * \since 1.8
 *
 * \param subcmds Subcommands to process if any. (Could be NULL).
 *
 * \note Knowing whether or not an AOC-E subcmd is present on certain
 * PRI hangup events is necessary to determine what method to use to hangup
 * the ast_channel.  If an AOC-E subcmd just came in, then a new AOC-E was queued
 * on the ast_channel.  If a soft hangup is used, the AOC-E msg will never make it
 * across the bridge, but if a AST_CONTROL_HANGUP frame is queued behind it
 * we can ensure the AOC-E frame makes it to it's destination before the hangup
 * frame is read.
 *
 *
 * \retval 0 AOC-E is not present in subcmd list
 * \retval 1 AOC-E is present in subcmd list
 */
static int detect_aoc_e_subcmd(const struct pri_subcommands *subcmds)
{
        int i;

        if (!subcmds) {
                return 0;
        }
        for (i = 0; i < subcmds->counter_subcmd; ++i) {
                const struct pri_subcommand *subcmd = &subcmds->subcmd[i];
                if (subcmd->cmd == PRI_SUBCMD_AOC_E) {
                        return 1;
                }
        }
        return 0;
}
#endif  /* defined(HAVE_PRI_AOC_EVENTS) */

/*!
 * \internal
 * \brief Handle the call associated PRI subcommand events.
 * \since 1.8
 *
 * \param pri sig_pri PRI control structure.
 * \param chanpos Channel position in the span.
 * \param event_id PRI event id
 * \param channel PRI encoded span/channel
 * \param subcmds Subcommands to process if any. (Could be NULL).
 * \param call_rsp libpri opaque call structure to send any responses toward.
 * Could be NULL either because it is not available or the call is for the
 * dummy call reference.  However, this should not be NULL in the cases that
 * need to use the pointer to send a response message back.
 *
 * \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_handle_subcmds(struct sig_pri_span *pri, int chanpos, int event_id,
        int channel, const struct pri_subcommands *subcmds, q931_call *call_rsp)
{
        int index;
        struct ast_channel *owner;
        struct ast_party_redirecting ast_redirecting;

        if (!subcmds) {
                return;
        }
        for (index = 0; index < subcmds->counter_subcmd; ++index) {
                const struct pri_subcommand *subcmd = &subcmds->subcmd[index];

                switch (subcmd->cmd) {
                case PRI_SUBCMD_CONNECTED_LINE:
                        sig_pri_lock_owner(pri, chanpos);
                        owner = pri->pvts[chanpos]->owner;
                        if (owner) {
                                struct ast_party_connected_line ast_connected;
                                int caller_id_update;

                                /* Extract the connected line information */
                                ast_party_connected_line_init(&ast_connected);
                                sig_pri_party_id_convert(&ast_connected.id, &subcmd->u.connected_line.id,
                                        pri);
                                ast_connected.id.tag = ast_strdup(pri->pvts[chanpos]->user_tag);

                                caller_id_update = 0;
                                if (ast_connected.id.name.str) {
                                        /* Save name for Caller-ID update */
                                        ast_copy_string(pri->pvts[chanpos]->cid_name,
                                                ast_connected.id.name.str, sizeof(pri->pvts[chanpos]->cid_name));
                                        caller_id_update = 1;
                                }
                                if (ast_connected.id.number.str) {
                                        /* Save number for Caller-ID update */
                                        ast_copy_string(pri->pvts[chanpos]->cid_num,
                                                ast_connected.id.number.str, sizeof(pri->pvts[chanpos]->cid_num));
                                        pri->pvts[chanpos]->cid_ton = ast_connected.id.number.plan;
                                        caller_id_update = 1;
                                } else {
                                        ast_connected.id.number.valid = 1;
                                        ast_connected.id.number.str = ast_strdup("");
                                }
                                ast_connected.source = AST_CONNECTED_LINE_UPDATE_SOURCE_ANSWER;

                                pri->pvts[chanpos]->cid_subaddr[0] = '\0';
#if defined(HAVE_PRI_SUBADDR)
                                if (ast_connected.id.subaddress.valid) {
                                        ast_party_subaddress_set(&owner->caller.id.subaddress,
                                                &ast_connected.id.subaddress);
                                        if (ast_connected.id.subaddress.str) {
                                                ast_copy_string(pri->pvts[chanpos]->cid_subaddr,
                                                        ast_connected.id.subaddress.str,
                                                        sizeof(pri->pvts[chanpos]->cid_subaddr));
                                        }
                                }
#endif  /* defined(HAVE_PRI_SUBADDR) */
                                if (caller_id_update) {
                                        pri->pvts[chanpos]->callingpres =
                                                ast_party_id_presentation(&ast_connected.id);
                                        sig_pri_set_caller_id(pri->pvts[chanpos]);
                                        ast_set_callerid(owner, S_OR(ast_connected.id.number.str, NULL),
                                                S_OR(ast_connected.id.name.str, NULL),
                                                S_OR(ast_connected.id.number.str, NULL));
                                }

                                /* Update the connected line information on the other channel */
                                if (event_id != PRI_EVENT_RING) {
                                        /* This connected_line update was not from a SETUP message. */
                                        ast_channel_queue_connected_line_update(owner, &ast_connected, NULL);
                                }

                                ast_party_connected_line_free(&ast_connected);
                                ast_channel_unlock(owner);
                        }
                        break;
                case PRI_SUBCMD_REDIRECTING:
                        sig_pri_lock_owner(pri, chanpos);
                        owner = pri->pvts[chanpos]->owner;
                        if (owner) {
                                sig_pri_redirecting_convert(&ast_redirecting, &subcmd->u.redirecting,
                                        &owner->redirecting, pri);
                                ast_redirecting.from.tag = ast_strdup(pri->pvts[chanpos]->user_tag);
                                ast_redirecting.to.tag = ast_strdup(pri->pvts[chanpos]->user_tag);

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

                                ast_channel_set_redirecting(owner, &ast_redirecting, NULL);
                                if (event_id != PRI_EVENT_RING) {
                                        /* This redirection was not from a SETUP message. */
                                        ast_channel_queue_redirecting_update(owner, &ast_redirecting, NULL);
                                }
                                ast_party_redirecting_free(&ast_redirecting);

                                ast_channel_unlock(owner);
                        }
                        break;
#if defined(HAVE_PRI_CALL_REROUTING)
                case PRI_SUBCMD_REROUTING:
                        sig_pri_lock_owner(pri, chanpos);
                        owner = pri->pvts[chanpos]->owner;
                        if (owner) {
                                struct pri_party_redirecting pri_deflection;

                                if (!call_rsp) {
                                        ast_channel_unlock(owner);
                                        ast_log(LOG_WARNING,
                                                "CallRerouting/CallDeflection to '%s' without call!\n",
                                                subcmd->u.rerouting.deflection.to.number.str);
                                        break;
                                }

                                pri_deflection = subcmd->u.rerouting.deflection;

                                ast_string_field_set(owner, call_forward, pri_deflection.to.number.str);

                                /* Adjust the deflecting to number based upon the subscription option. */
                                switch (subcmd->u.rerouting.subscription_option) {
                                case 0: /* noNotification */
                                case 1: /* notificationWithoutDivertedToNr */
                                        /* Delete the number because the far end is not supposed to see it. */
                                        pri_deflection.to.number.presentation =
                                                PRI_PRES_RESTRICTED | PRI_PRES_USER_NUMBER_UNSCREENED;
                                        pri_deflection.to.number.plan =
                                                (PRI_TON_UNKNOWN << 4) | PRI_NPI_E163_E164;
                                        pri_deflection.to.number.str[0] = '\0';
                                        break;
                                case 2: /* notificationWithDivertedToNr */
                                        break;
                                case 3: /* notApplicable */
                                default:
                                        break;
                                }
                                sig_pri_redirecting_convert(&ast_redirecting, &pri_deflection,
                                        &owner->redirecting, pri);
                                ast_redirecting.from.tag = ast_strdup(pri->pvts[chanpos]->user_tag);
                                ast_redirecting.to.tag = ast_strdup(pri->pvts[chanpos]->user_tag);
                                ast_channel_set_redirecting(owner, &ast_redirecting, NULL);
                                ast_party_redirecting_free(&ast_redirecting);

                                /*
                                 * Send back positive ACK to CallRerouting/CallDeflection.
                                 *
                                 * Note:  This call will be hungup by the dial application when
                                 * it processes the call_forward string set above.
                                 */
                                pri_rerouting_rsp(pri->pri, call_rsp, subcmd->u.rerouting.invoke_id,
                                        PRI_REROUTING_RSP_OK_CLEAR);