[asterisk/asterisk.git] / main / bridging.c

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2007 - 2009, Digium, Inc.
 *
 * Joshua Colp <jcolp@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 Channel Bridging API
 *
 * \author Joshua Colp <jcolp@digium.com>
 */

/*** MODULEINFO
        <support_level>core</support_level>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#include <signal.h>

#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/bridging.h"
#include "asterisk/bridging_basic.h"
#include "asterisk/bridging_technology.h"
#include "asterisk/stasis_bridging.h"
#include "asterisk/app.h"
#include "asterisk/file.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
#include "asterisk/pbx.h"
#include "asterisk/test.h"
#include "asterisk/_private.h"

#include "asterisk/heap.h"
#include "asterisk/say.h"
#include "asterisk/timing.h"
#include "asterisk/stringfields.h"
#include "asterisk/musiconhold.h"
#include "asterisk/features.h"
#include "asterisk/cli.h"
#include "asterisk/parking.h"
#include "asterisk/core_local.h"

/*! All bridges container. */
static struct ao2_container *bridges;

static AST_RWLIST_HEAD_STATIC(bridge_technologies, ast_bridge_technology);

/* Initial starting point for the bridge array of channels */
#define BRIDGE_ARRAY_START 128

/* Grow rate of bridge array of channels */
#define BRIDGE_ARRAY_GROW 32

static void cleanup_video_mode(struct ast_bridge *bridge);
static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel);
static void bridge_features_remove_on_pull(struct ast_bridge_features *features);

/*! Default DTMF keys for built in features */
static char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING];

/*! Function handlers for the built in features */
static void *builtin_features_handlers[AST_BRIDGE_BUILTIN_END];

/*! Function handlers for built in interval features */
static ast_bridge_builtin_set_limits_fn builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_END];

/*! Bridge manager service request */
struct bridge_manager_request {
        /*! List of bridge service requests. */
        AST_LIST_ENTRY(bridge_manager_request) node;
        /*! Refed bridge requesting service. */
        struct ast_bridge *bridge;
};

struct bridge_manager_controller {
        /*! Condition, used to wake up the bridge manager thread. */
        ast_cond_t cond;
        /*! Queue of bridge service requests. */
        AST_LIST_HEAD_NOLOCK(, bridge_manager_request) service_requests;
        /*! Manager thread */
        pthread_t thread;
        /*! TRUE if the manager needs to stop. */
        unsigned int stop:1;
};

/*! Bridge manager controller. */
static struct bridge_manager_controller *bridge_manager;

/*!
 * \internal
 * \brief Request service for a bridge from the bridge manager.
 * \since 12.0.0
 *
 * \param bridge Requesting service.
 *
 * \return Nothing
 */
static void bridge_manager_service_req(struct ast_bridge *bridge)
{
        struct bridge_manager_request *request;

        ao2_lock(bridge_manager);
        if (bridge_manager->stop) {
                ao2_unlock(bridge_manager);
                return;
        }

        /* Create the service request. */
        request = ast_calloc(1, sizeof(*request));
        if (!request) {
                /* Well. This isn't good. */
                ao2_unlock(bridge_manager);
                return;
        }
        ao2_ref(bridge, +1);
        request->bridge = bridge;

        /* Put request into the queue and wake the bridge manager. */
        AST_LIST_INSERT_TAIL(&bridge_manager->service_requests, request, node);
        ast_cond_signal(&bridge_manager->cond);
        ao2_unlock(bridge_manager);
}

int __ast_bridge_technology_register(struct ast_bridge_technology *technology, struct ast_module *module)
{
        struct ast_bridge_technology *current;

        /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */
        if (ast_strlen_zero(technology->name)
                || !technology->capabilities
                || !technology->write) {
                ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n",
                        technology->name);
                return -1;
        }

        AST_RWLIST_WRLOCK(&bridge_technologies);

        /* Look for duplicate bridge technology already using this name, or already registered */
        AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
                if ((!strcasecmp(current->name, technology->name)) || (current == technology)) {
                        ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n",
                                technology->name);
                        AST_RWLIST_UNLOCK(&bridge_technologies);
                        return -1;
                }
        }

        /* Copy module pointer so reference counting can keep the module from unloading */
        technology->mod = module;

        /* Insert our new bridge technology into the list and print out a pretty message */
        AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry);

        AST_RWLIST_UNLOCK(&bridge_technologies);

        ast_verb(2, "Registered bridge technology %s\n", technology->name);

        return 0;
}

int ast_bridge_technology_unregister(struct ast_bridge_technology *technology)
{
        struct ast_bridge_technology *current;

        AST_RWLIST_WRLOCK(&bridge_technologies);

        /* Ensure the bridge technology is registered before removing it */
        AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
                if (current == technology) {
                        AST_RWLIST_REMOVE_CURRENT(entry);
                        ast_verb(2, "Unregistered bridge technology %s\n", technology->name);
                        break;
                }
        }
        AST_RWLIST_TRAVERSE_SAFE_END;

        AST_RWLIST_UNLOCK(&bridge_technologies);

        return current ? 0 : -1;
}

void ast_bridge_channel_lock_bridge(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge *bridge;

        for (;;) {
                /* Safely get the bridge pointer */
                ast_bridge_channel_lock(bridge_channel);
                bridge = bridge_channel->bridge;
                ao2_ref(bridge, +1);
                ast_bridge_channel_unlock(bridge_channel);

                /* Lock the bridge and see if it is still the bridge we need to lock. */
                ast_bridge_lock(bridge);
                if (bridge == bridge_channel->bridge) {
                        ao2_ref(bridge, -1);
                        return;
                }
                ast_bridge_unlock(bridge);
                ao2_ref(bridge, -1);
        }
}

static void bridge_channel_poke(struct ast_bridge_channel *bridge_channel)
{
        if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
                while (bridge_channel->waiting) {
                        pthread_kill(bridge_channel->thread, SIGURG);
                        sched_yield();
                }
        }
}

void ast_bridge_change_state_nolock(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
{
/* BUGBUG need cause code for the bridge_channel leaving the bridge. */
        if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                return;
        }

        ast_debug(1, "Setting %p(%s) state from:%d to:%d\n",
                bridge_channel, ast_channel_name(bridge_channel->chan), bridge_channel->state,
                new_state);

        /* Change the state on the bridge channel */
        bridge_channel->state = new_state;

        bridge_channel_poke(bridge_channel);
}

void ast_bridge_change_state(struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state)
{
        ast_bridge_channel_lock(bridge_channel);
        ast_bridge_change_state_nolock(bridge_channel, new_state);
        ast_bridge_channel_unlock(bridge_channel);
}

/*!
 * \internal
 * \brief Put an action onto the specified bridge. Don't dup the action frame.
 * \since 12.0.0
 *
 * \param bridge What to queue the action on.
 * \param action What to do.
 *
 * \return Nothing
 */
static void bridge_queue_action_nodup(struct ast_bridge *bridge, struct ast_frame *action)
{
        ast_debug(1, "Bridge %s: queueing action type:%d sub:%d\n",
                bridge->uniqueid, action->frametype, action->subclass.integer);

        ast_bridge_lock(bridge);
        AST_LIST_INSERT_TAIL(&bridge->action_queue, action, frame_list);
        ast_bridge_unlock(bridge);
        bridge_manager_service_req(bridge);
}

int ast_bridge_queue_action(struct ast_bridge *bridge, struct ast_frame *action)
{
        struct ast_frame *dup;

        dup = ast_frdup(action);
        if (!dup) {
                return -1;
        }
        bridge_queue_action_nodup(bridge, dup);
        return 0;
}

int ast_bridge_channel_queue_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
{
        struct ast_frame *dup;
        char nudge = 0;

        if (bridge_channel->suspended
                /* Also defer DTMF frames. */
                && fr->frametype != AST_FRAME_DTMF_BEGIN
                && fr->frametype != AST_FRAME_DTMF_END
                && !ast_is_deferrable_frame(fr)) {
                /* Drop non-deferable frames when suspended. */
                return 0;
        }

        dup = ast_frdup(fr);
        if (!dup) {
                return -1;
        }

        ast_bridge_channel_lock(bridge_channel);
        if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                /* Drop frames on channels leaving the bridge. */
                ast_bridge_channel_unlock(bridge_channel);
                ast_frfree(dup);
                return 0;
        }

        AST_LIST_INSERT_TAIL(&bridge_channel->wr_queue, dup, frame_list);
        if (write(bridge_channel->alert_pipe[1], &nudge, sizeof(nudge)) != sizeof(nudge)) {
                ast_log(LOG_ERROR, "We couldn't write alert pipe for %p(%s)... something is VERY wrong\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan));
        }
        ast_bridge_channel_unlock(bridge_channel);
        return 0;
}

void ast_bridge_channel_queue_action_data(struct ast_bridge_channel *bridge_channel, enum ast_bridge_action_type action, const void *data, size_t datalen)
{
        struct ast_frame frame = {
                .frametype = AST_FRAME_BRIDGE_ACTION,
                .subclass.integer = action,
                .datalen = datalen,
                .data.ptr = (void *) data,
        };

        ast_bridge_channel_queue_frame(bridge_channel, &frame);
}

void ast_bridge_channel_queue_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
{
        struct ast_frame frame = {
                .frametype = AST_FRAME_CONTROL,
                .subclass.integer = control,
                .datalen = datalen,
                .data.ptr = (void *) data,
        };

        ast_bridge_channel_queue_frame(bridge_channel, &frame);
}

void ast_bridge_channel_restore_formats(struct ast_bridge_channel *bridge_channel)
{
        /* Restore original formats of the channel as they came in */
        if (ast_format_cmp(ast_channel_readformat(bridge_channel->chan), &bridge_channel->read_format) == AST_FORMAT_CMP_NOT_EQUAL) {
                ast_debug(1, "Bridge is returning %p(%s) to read format %s\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&bridge_channel->read_format));
                if (ast_set_read_format(bridge_channel->chan, &bridge_channel->read_format)) {
                        ast_debug(1, "Bridge failed to return %p(%s) to read format %s\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan),
                                ast_getformatname(&bridge_channel->read_format));
                }
        }
        if (ast_format_cmp(ast_channel_writeformat(bridge_channel->chan), &bridge_channel->write_format) == AST_FORMAT_CMP_NOT_EQUAL) {
                ast_debug(1, "Bridge is returning %p(%s) to write format %s\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&bridge_channel->write_format));
                if (ast_set_write_format(bridge_channel->chan, &bridge_channel->write_format)) {
                        ast_debug(1, "Bridge failed to return %p(%s) to write format %s\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan),
                                ast_getformatname(&bridge_channel->write_format));
                }
        }
}

/*!
 * \internal
 * \brief Helper function to find a bridge channel given a channel.
 *
 * \param bridge What to search
 * \param chan What to search for.
 *
 * \note On entry, bridge is already locked.
 *
 * \retval bridge_channel if channel is in the bridge.
 * \retval NULL if not in bridge.
 */
static struct ast_bridge_channel *find_bridge_channel(struct ast_bridge *bridge, struct ast_channel *chan)
{
        struct ast_bridge_channel *bridge_channel;

        AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
                if (bridge_channel->chan == chan) {
                        break;
                }
        }

        return bridge_channel;
}

/*!
 * \internal
 * \brief Dissolve the bridge.
 * \since 12.0.0
 *
 * \param bridge Bridge to eject all channels
 *
 * \details
 * Force out all channels that are not already going out of the
 * bridge.  Any new channels joining will leave immediately.
 *
 * \note On entry, bridge is already locked.
 *
 * \return Nothing
 */
static void bridge_dissolve(struct ast_bridge *bridge)
{
        struct ast_bridge_channel *bridge_channel;
        struct ast_frame action = {
                .frametype = AST_FRAME_BRIDGE_ACTION,
                .subclass.integer = AST_BRIDGE_ACTION_DEFERRED_DISSOLVING,
        };

        if (bridge->dissolved) {
                return;
        }
        bridge->dissolved = 1;

        ast_debug(1, "Bridge %s: dissolving bridge\n", bridge->uniqueid);

/* BUGBUG need a cause code on the bridge for the later ejected channels. */
        AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
                ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
        }

        /* Must defer dissolving bridge because it is already locked. */
        ast_bridge_queue_action(bridge, &action);
}

/*!
 * \internal
 * \brief Check if a bridge should dissolve and do it.
 * \since 12.0.0
 *
 * \param bridge_channel Channel causing the check.
 *
 * \note On entry, bridge_channel->bridge is already locked.
 *
 * \return Nothing
 */
static void bridge_dissolve_check(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge *bridge = bridge_channel->bridge;

        if (bridge->dissolved) {
                return;
        }

        if (!bridge->num_channels
                && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_EMPTY)) {
                /* Last channel leaving the bridge turns off the lights. */
                bridge_dissolve(bridge);
                return;
        }

        switch (bridge_channel->state) {
        case AST_BRIDGE_CHANNEL_STATE_END:
                /* Do we need to dissolve the bridge because this channel hung up? */
                if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)
                        || (bridge_channel->features->usable
                                && ast_test_flag(&bridge_channel->features->feature_flags,
                                        AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP))) {
                        bridge_dissolve(bridge);
                        return;
                }
                break;
        default:
                break;
        }
/* BUGBUG need to implement AST_BRIDGE_CHANNEL_FLAG_LONELY support here */
}

/*!
 * \internal
 * \brief Pull the bridge channel out of its current bridge.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to pull.
 *
 * \note On entry, bridge_channel->bridge is already locked.
 *
 * \return Nothing
 */
static void bridge_channel_pull(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge *bridge = bridge_channel->bridge;

        if (!bridge_channel->in_bridge) {
                return;
        }
        bridge_channel->in_bridge = 0;

        ast_debug(1, "Bridge %s: pulling %p(%s)\n",
                bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));

/* BUGBUG This is where incoming HOLD/UNHOLD memory should write UNHOLD into bridge. (if not local optimizing) */
/* BUGBUG This is where incoming DTMF begin/end memory should write DTMF end into bridge. (if not local optimizing) */
        if (!bridge_channel->just_joined) {
                /* Tell the bridge technology we are leaving so they tear us down */
                ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                        bridge->technology->name);
                if (bridge->technology->leave) {
                        bridge->technology->leave(bridge, bridge_channel);
                }
        }

        /* Remove channel from the bridge */
        if (!bridge_channel->suspended) {
                --bridge->num_active;
        }
        --bridge->num_channels;
        AST_LIST_REMOVE(&bridge->channels, bridge_channel, entry);
        bridge->v_table->pull(bridge, bridge_channel);

        ast_bridge_channel_clear_roles(bridge_channel);

        bridge_dissolve_check(bridge_channel);

        bridge->reconfigured = 1;
        ast_bridge_publish_leave(bridge, bridge_channel->chan);
}

/*!
 * \internal
 * \brief Push the bridge channel into its specified bridge.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to push.
 *
 * \note On entry, bridge_channel->bridge is already locked.
 *
 * \retval 0 on success.
 * \retval -1 on failure.  The channel did not get pushed.
 */
static int bridge_channel_push(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge *bridge = bridge_channel->bridge;
        struct ast_bridge_channel *swap;

        ast_assert(!bridge_channel->in_bridge);

        swap = find_bridge_channel(bridge, bridge_channel->swap);
        bridge_channel->swap = NULL;

        if (swap) {
                ast_debug(1, "Bridge %s: pushing %p(%s) by swapping with %p(%s)\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                        swap, ast_channel_name(swap->chan));
        } else {
                ast_debug(1, "Bridge %s: pushing %p(%s)\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
        }

        /* Add channel to the bridge */
        if (bridge->dissolved
                || bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT
                || (swap && swap->state != AST_BRIDGE_CHANNEL_STATE_WAIT)
                || bridge->v_table->push(bridge, bridge_channel, swap)
                || ast_bridge_channel_establish_roles(bridge_channel)) {
                ast_debug(1, "Bridge %s: pushing %p(%s) into bridge failed\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
                return -1;
        }
        bridge_channel->in_bridge = 1;
        bridge_channel->just_joined = 1;
        AST_LIST_INSERT_TAIL(&bridge->channels, bridge_channel, entry);
        ++bridge->num_channels;
        if (!bridge_channel->suspended) {
                ++bridge->num_active;
        }
        if (swap) {
                ast_bridge_change_state(swap, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                bridge_channel_pull(swap);
        }

        bridge->reconfigured = 1;
        ast_bridge_publish_enter(bridge, bridge_channel->chan);
        return 0;
}

/*! \brief Internal function to handle DTMF from a channel */
static struct ast_frame *bridge_handle_dtmf(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook;
        char dtmf[2];

/* BUGBUG the feature hook matching needs to be done here.  Any matching feature hook needs to be queued onto the bridge_channel.  Also the feature hook digit timeout needs to be handled. */
/* BUGBUG the AMI atxfer action just sends DTMF end events to initiate DTMF atxfer and dial the extension.  Another reason the DTMF hook matching needs rework. */
        /* See if this DTMF matches the beginnings of any feature hooks, if so we switch to the feature state to either execute the feature or collect more DTMF */
        dtmf[0] = frame->subclass.integer;
        dtmf[1] = '\0';
        hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_PARTIAL_KEY);
        if (hook) {
                struct ast_frame action = {
                        .frametype = AST_FRAME_BRIDGE_ACTION,
                        .subclass.integer = AST_BRIDGE_ACTION_FEATURE,
                };

                ast_frfree(frame);
                frame = NULL;
                ast_bridge_channel_queue_frame(bridge_channel, &action);
                ao2_ref(hook, -1);
        }

        return frame;
}

/*!
 * \internal
 * \brief Handle bridge hangup event.
 * \since 12.0.0
 *
 * \param bridge_channel Which channel is hanging up.
 *
 * \return Nothing
 */
static void bridge_handle_hangup(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook;
        struct ao2_iterator iter;

        /* Run any hangup hooks. */
        iter = ao2_iterator_init(features->hangup_hooks, 0);
        for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
                int failed;

                failed = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
                if (failed) {
                        ast_debug(1, "Hangup hook %p is being removed from %p(%s)\n",
                                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                        ao2_unlink(features->hangup_hooks, hook);
                }
        }
        ao2_iterator_destroy(&iter);

        /* Default hangup action. */
        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END);
}

static int bridge_channel_interval_ready(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook;
        int ready;

        ast_heap_wrlock(features->interval_hooks);
        hook = ast_heap_peek(features->interval_hooks, 1);
        ready = hook && ast_tvdiff_ms(hook->parms.timer.trip_time, ast_tvnow()) <= 0;
        ast_heap_unlock(features->interval_hooks);

        return ready;
}

void ast_bridge_notify_talking(struct ast_bridge_channel *bridge_channel, int started_talking)
{
        struct ast_frame action = {
                .frametype = AST_FRAME_BRIDGE_ACTION,
                .subclass.integer = started_talking
                        ? AST_BRIDGE_ACTION_TALKING_START : AST_BRIDGE_ACTION_TALKING_STOP,
        };

        ast_bridge_channel_queue_frame(bridge_channel, &action);
}

static void bridge_channel_write_frame(struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
{
        ast_bridge_channel_lock_bridge(bridge_channel);
/*
 * BUGBUG need to implement a deferred write queue for when there is no peer channel in the bridge (yet or it was kicked).
 *
 * The tech decides if a frame needs to be pushed back for deferral.
 * simple_bridge/native_bridge are likely the only techs that will do this.
 */
        bridge_channel->bridge->technology->write(bridge_channel->bridge, bridge_channel, frame);
        ast_bridge_unlock(bridge_channel->bridge);
}

void ast_bridge_channel_write_action_data(struct ast_bridge_channel *bridge_channel, enum ast_bridge_action_type action, const void *data, size_t datalen)
{
        struct ast_frame frame = {
                .frametype = AST_FRAME_BRIDGE_ACTION,
                .subclass.integer = action,
                .datalen = datalen,
                .data.ptr = (void *) data,
        };

        bridge_channel_write_frame(bridge_channel, &frame);
}

void ast_bridge_channel_write_control_data(struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
{
        struct ast_frame frame = {
                .frametype = AST_FRAME_CONTROL,
                .subclass.integer = control,
                .datalen = datalen,
                .data.ptr = (void *) data,
        };

        bridge_channel_write_frame(bridge_channel, &frame);
}

static int run_app_helper(struct ast_channel *chan, const char *app_name, const char *app_args)
{
        int res = 0;

        if (!strcasecmp("Gosub", app_name)) {
                ast_app_exec_sub(NULL, chan, app_args, 0);
        } else if (!strcasecmp("Macro", app_name)) {
                ast_app_exec_macro(NULL, chan, app_args);
        } else {
                struct ast_app *app;

                app = pbx_findapp(app_name);
                if (!app) {
                        ast_log(LOG_WARNING, "Could not find application (%s)\n", app_name);
                } else {
                        res = pbx_exec(chan, app, app_args);
                }
        }
        return res;
}

void ast_bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
{
        if (moh_class) {
                if (ast_strlen_zero(moh_class)) {
                        ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD,
                                NULL, 0);
                } else {
                        ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD,
                                moh_class, strlen(moh_class) + 1);
                }
        }
        if (run_app_helper(bridge_channel->chan, app_name, S_OR(app_args, ""))) {
                /* Break the bridge if the app returns non-zero. */
                bridge_handle_hangup(bridge_channel);
        }
        if (moh_class) {
                ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_UNHOLD,
                        NULL, 0);
        }
}

struct bridge_run_app {
        /*! Offset into app_name[] where the MOH class name starts.  (zero if no MOH) */
        int moh_offset;
        /*! Offset into app_name[] where the application argument string starts. (zero if no arguments) */
        int app_args_offset;
        /*! Application name to run. */
        char app_name[0];
};

/*!
 * \internal
 * \brief Handle the run application bridge action.
 * \since 12.0.0
 *
 * \param bridge_channel Which channel to run the application on.
 * \param data Action frame data to run the application.
 *
 * \return Nothing
 */
static void bridge_channel_run_app(struct ast_bridge_channel *bridge_channel, struct bridge_run_app *data)
{
        ast_bridge_channel_run_app(bridge_channel, data->app_name,
                data->app_args_offset ? &data->app_name[data->app_args_offset] : NULL,
                data->moh_offset ? &data->app_name[data->moh_offset] : NULL);
}

static void payload_helper_app(ast_bridge_channel_post_action_data post_it,
        struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
{
        struct bridge_run_app *app_data;
        size_t len_name = strlen(app_name) + 1;
        size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
        size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
        size_t len_data = sizeof(*app_data) + len_name + len_args + len_moh;

        /* Fill in application run frame data. */
        app_data = alloca(len_data);
        app_data->app_args_offset = len_args ? len_name : 0;
        app_data->moh_offset = len_moh ? len_name + len_args : 0;
        strcpy(app_data->app_name, app_name);/* Safe */
        if (len_args) {
                strcpy(&app_data->app_name[app_data->app_args_offset], app_args);/* Safe */
        }
        if (moh_class) {
                strcpy(&app_data->app_name[app_data->moh_offset], moh_class);/* Safe */
        }

        post_it(bridge_channel, AST_BRIDGE_ACTION_RUN_APP, app_data, len_data);
}

void ast_bridge_channel_write_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
{
        payload_helper_app(ast_bridge_channel_write_action_data,
                bridge_channel, app_name, app_args, moh_class);
}

void ast_bridge_channel_queue_app(struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
{
        payload_helper_app(ast_bridge_channel_queue_action_data,
                bridge_channel, app_name, app_args, moh_class);
}

void ast_bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
{
        if (moh_class) {
                if (ast_strlen_zero(moh_class)) {
                        ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD,
                                NULL, 0);
                } else {
                        ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD,
                                moh_class, strlen(moh_class) + 1);
                }
        }
        if (custom_play) {
                custom_play(bridge_channel, playfile);
        } else {
                ast_stream_and_wait(bridge_channel->chan, playfile, AST_DIGIT_NONE);
        }
        if (moh_class) {
                ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_UNHOLD,
                        NULL, 0);
        }

        /*
         * It may be necessary to resume music on hold after we finish
         * playing the announcment.
         *
         * XXX We have no idea what MOH class was in use before playing
         * the file.
         */
        if (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_MOH)) {
                ast_moh_start(bridge_channel->chan, NULL, NULL);
        }
}

struct bridge_playfile {
        /*! Call this function to play the playfile. (NULL if normal sound file to play) */
        ast_bridge_custom_play_fn custom_play;
        /*! Offset into playfile[] where the MOH class name starts.  (zero if no MOH)*/
        int moh_offset;
        /*! Filename to play. */
        char playfile[0];
};

/*!
 * \internal
 * \brief Handle the playfile bridge action.
 * \since 12.0.0
 *
 * \param bridge_channel Which channel to play a file on.
 * \param payload Action frame payload to play a file.
 *
 * \return Nothing
 */
static void bridge_channel_playfile(struct ast_bridge_channel *bridge_channel, struct bridge_playfile *payload)
{
        ast_bridge_channel_playfile(bridge_channel, payload->custom_play, payload->playfile,
                payload->moh_offset ? &payload->playfile[payload->moh_offset] : NULL);
}

static void payload_helper_playfile(ast_bridge_channel_post_action_data post_it,
        struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
{
        struct bridge_playfile *payload;
        size_t len_name = strlen(playfile) + 1;
        size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
        size_t len_payload = sizeof(*payload) + len_name + len_moh;

        /* Fill in play file frame data. */
        payload = alloca(len_payload);
        payload->custom_play = custom_play;
        payload->moh_offset = len_moh ? len_name : 0;
        strcpy(payload->playfile, playfile);/* Safe */
        if (moh_class) {
                strcpy(&payload->playfile[payload->moh_offset], moh_class);/* Safe */
        }

        post_it(bridge_channel, AST_BRIDGE_ACTION_PLAY_FILE, payload, len_payload);
}

void ast_bridge_channel_write_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
{
        payload_helper_playfile(ast_bridge_channel_write_action_data,
                bridge_channel, custom_play, playfile, moh_class);
}

void ast_bridge_channel_queue_playfile(struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
{
        payload_helper_playfile(ast_bridge_channel_queue_action_data,
                bridge_channel, custom_play, playfile, moh_class);
}

struct bridge_park {
        int parker_uuid_offset;
        int app_data_offset;
        /* buffer used for holding those strings */
        char parkee_uuid[0];
};

static void bridge_channel_park(struct ast_bridge_channel *bridge_channel, struct bridge_park *payload)
{
        ast_bridge_channel_park(bridge_channel, payload->parkee_uuid,
                &payload->parkee_uuid[payload->parker_uuid_offset],
                payload->app_data_offset ? &payload->parkee_uuid[payload->app_data_offset] : NULL);
}

static void payload_helper_park(ast_bridge_channel_post_action_data post_it,
        struct ast_bridge_channel *bridge_channel,
        const char *parkee_uuid,
        const char *parker_uuid,
        const char *app_data)
{
        struct bridge_park *payload;
        size_t len_parkee_uuid = strlen(parkee_uuid) + 1;
        size_t len_parker_uuid = strlen(parker_uuid) + 1;
        size_t len_app_data = !app_data ? 0 : strlen(app_data) + 1;
        size_t len_payload = sizeof(*payload) + len_parker_uuid + len_parkee_uuid + len_app_data;

        payload = alloca(len_payload);
        payload->app_data_offset = len_app_data ? len_parkee_uuid + len_parker_uuid : 0;
        payload->parker_uuid_offset = len_parkee_uuid;
        strcpy(payload->parkee_uuid, parkee_uuid);
        strcpy(&payload->parkee_uuid[payload->parker_uuid_offset], parker_uuid);
        if (app_data) {
                strcpy(&payload->parkee_uuid[payload->app_data_offset], app_data);
        }

        post_it(bridge_channel, AST_BRIDGE_ACTION_PARK, payload, len_payload);
}

void ast_bridge_channel_write_park(struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
{
        payload_helper_park(ast_bridge_channel_write_action_data,
                bridge_channel, parkee_uuid, parker_uuid, app_data);
}

/*!
 * \internal
 * \brief Feed notification that a frame is waiting on a channel into the bridging core
 *
 * \param bridge_channel Bridge channel the notification was received on
 */
static void bridge_handle_trip(struct ast_bridge_channel *bridge_channel)
{
        struct ast_frame *frame;

        if (bridge_channel->features->mute) {
                frame = ast_read_noaudio(bridge_channel->chan);
        } else {
                frame = ast_read(bridge_channel->chan);
        }

        if (!frame) {
                bridge_handle_hangup(bridge_channel);
                return;
        }
        switch (frame->frametype) {
        case AST_FRAME_NULL:
                /* Just discard it. */
                ast_frfree(frame);
                return;
        case AST_FRAME_CONTROL:
                switch (frame->subclass.integer) {
                case AST_CONTROL_HANGUP:
                        bridge_handle_hangup(bridge_channel);
                        ast_frfree(frame);
                        return;
/* BUGBUG This is where incoming HOLD/UNHOLD memory should register.  Write UNHOLD into bridge when this channel is pulled. */
                default:
                        break;
                }
                break;
        case AST_FRAME_DTMF_BEGIN:
                frame = bridge_handle_dtmf(bridge_channel, frame);
                if (!frame) {
                        return;
                }
                /* Fall through */
        case AST_FRAME_DTMF_END:
                if (!bridge_channel->features->dtmf_passthrough) {
                        ast_frfree(frame);
                        return;
                }
/* BUGBUG This is where incoming DTMF begin/end memory should register.  Write DTMF end into bridge when this channel is pulled. */
                break;
        default:
                break;
        }

/* BUGBUG bridge join or impart needs to do CONNECTED_LINE updates if the channels are being swapped and it is a 1-1 bridge. */

        /* Simply write the frame out to the bridge technology. */
/* BUGBUG The tech is where AST_CONTROL_ANSWER hook should go. (early bridge) */
/* BUGBUG The tech is where incoming BUSY/CONGESTION hangup should happen? (early bridge) */
        bridge_channel_write_frame(bridge_channel, frame);
        ast_frfree(frame);
}

/*!
 * \internal
 * \brief Complete joining new channels to the bridge.
 * \since 12.0.0
 *
 * \param bridge Check for new channels on this bridge.
 *
 * \note On entry, bridge is already locked.
 *
 * \return Nothing
 */
static void bridge_complete_join(struct ast_bridge *bridge)
{
        struct ast_bridge_channel *bridge_channel;

        if (bridge->dissolved) {
                /*
                 * No sense in completing the join on channels for a dissolved
                 * bridge.  They are just going to be removed soon anyway.
                 * However, we do have reason to abort here because the bridge
                 * technology may not be able to handle the number of channels
                 * still in the bridge.
                 */
                return;
        }

        AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
                if (!bridge_channel->just_joined) {
                        continue;
                }

                /* Make the channel compatible with the bridge */
                bridge_make_compatible(bridge, bridge_channel);

                /* Tell the bridge technology we are joining so they set us up */
                ast_debug(1, "Bridge %s: %p(%s) is joining %s technology\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                        bridge->technology->name);
                if (bridge->technology->join
                        && bridge->technology->join(bridge, bridge_channel)) {
                        ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology\n",
                                bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                                bridge->technology->name);
                }

                bridge_channel->just_joined = 0;
        }
}

/*! \brief Helper function used to find the "best" bridge technology given specified capabilities */
static struct ast_bridge_technology *find_best_technology(uint32_t capabilities, struct ast_bridge *bridge)
{
        struct ast_bridge_technology *current;
        struct ast_bridge_technology *best = NULL;

        AST_RWLIST_RDLOCK(&bridge_technologies);
        AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) {
                if (current->suspended) {
                        ast_debug(1, "Bridge technology %s is suspended. Skipping.\n",
                                current->name);
                        continue;
                }
                if (!(current->capabilities & capabilities)) {
                        ast_debug(1, "Bridge technology %s does not have any capabilities we want.\n",
                                current->name);
                        continue;
                }
                if (best && current->preference <= best->preference) {
                        ast_debug(1, "Bridge technology %s has less preference than %s (%d <= %d). Skipping.\n",
                                current->name, best->name, current->preference, best->preference);
                        continue;
                }
                if (current->compatible && !current->compatible(bridge)) {
                        ast_debug(1, "Bridge technology %s is not compatible with properties of existing bridge.\n",
                                current->name);
                        continue;
                }
                best = current;
        }

        if (best) {
                /* Increment it's module reference count if present so it does not get unloaded while in use */
                ast_module_ref(best->mod);
                ast_debug(1, "Chose bridge technology %s\n", best->name);
        }

        AST_RWLIST_UNLOCK(&bridge_technologies);

        return best;
}

struct tech_deferred_destroy {
        struct ast_bridge_technology *tech;
        void *tech_pvt;
};

/*!
 * \internal
 * \brief Deferred destruction of bridge tech private structure.
 * \since 12.0.0
 *
 * \param bridge What to execute the action on.
 * \param action Deferred bridge tech destruction.
 *
 * \note On entry, bridge must not be locked.
 *
 * \return Nothing
 */
static void bridge_tech_deferred_destroy(struct ast_bridge *bridge, struct ast_frame *action)
{
        struct tech_deferred_destroy *deferred = action->data.ptr;
        struct ast_bridge dummy_bridge = {
                .technology = deferred->tech,
                .tech_pvt = deferred->tech_pvt,
                };

        ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));
        ast_debug(1, "Bridge %s: calling %s technology destructor (deferred, dummy)\n",
                dummy_bridge.uniqueid, dummy_bridge.technology->name);
        dummy_bridge.technology->destroy(&dummy_bridge);
        ast_module_unref(dummy_bridge.technology->mod);
}

/*!
 * \internal
 * \brief Handle bridge action frame.
 * \since 12.0.0
 *
 * \param bridge What to execute the action on.
 * \param action What to do.
 *
 * \note On entry, bridge is already locked.
 * \note Can be called by the bridge destructor.
 *
 * \return Nothing
 */
static void bridge_action_bridge(struct ast_bridge *bridge, struct ast_frame *action)
{
#if 0   /* In case we need to know when the destructor is calling us. */
        int in_destructor = !ao2_ref(bridge, 0);
#endif

        switch (action->subclass.integer) {
        case AST_BRIDGE_ACTION_DEFERRED_TECH_DESTROY:
                ast_bridge_unlock(bridge);
                bridge_tech_deferred_destroy(bridge, action);
                ast_bridge_lock(bridge);
                break;
        case AST_BRIDGE_ACTION_DEFERRED_DISSOLVING:
                ast_bridge_unlock(bridge);
                bridge->v_table->dissolving(bridge);
                ast_bridge_lock(bridge);
                break;
        default:
                /* Unexpected deferred action type.  Should never happen. */
                ast_assert(0);
                break;
        }
}

/*!
 * \internal
 * \brief Do any pending bridge actions.
 * \since 12.0.0
 *
 * \param bridge What to do actions on.
 *
 * \note On entry, bridge is already locked.
 * \note Can be called by the bridge destructor.
 *
 * \return Nothing
 */
static void bridge_handle_actions(struct ast_bridge *bridge)
{
        struct ast_frame *action;

        while ((action = AST_LIST_REMOVE_HEAD(&bridge->action_queue, frame_list))) {
                switch (action->frametype) {
                case AST_FRAME_BRIDGE_ACTION:
                        bridge_action_bridge(bridge, action);
                        break;
                default:
                        /* Unexpected deferred frame type.  Should never happen. */
                        ast_assert(0);
                        break;
                }
                ast_frfree(action);
        }
}

static void destroy_bridge(void *obj)
{
        struct ast_bridge *bridge = obj;
        RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);

        ast_debug(1, "Bridge %s: actually destroying %s bridge, nobody wants it anymore\n",
                bridge->uniqueid, bridge->v_table->name);

        msg = stasis_cache_clear_create(ast_bridge_snapshot_type(), bridge->uniqueid);
        if (msg) {
                stasis_publish(ast_bridge_topic(bridge), msg);
        }

        /* Do any pending actions in the context of destruction. */
        ast_bridge_lock(bridge);
        bridge_handle_actions(bridge);
        ast_bridge_unlock(bridge);

        /* There should not be any channels left in the bridge. */
        ast_assert(AST_LIST_EMPTY(&bridge->channels));

        ast_debug(1, "Bridge %s: calling %s bridge destructor\n",
                bridge->uniqueid, bridge->v_table->name);
        bridge->v_table->destroy(bridge);

        /* Pass off the bridge to the technology to destroy if needed */
        if (bridge->technology) {
                ast_debug(1, "Bridge %s: calling %s technology destructor\n",
                        bridge->uniqueid, bridge->technology->name);
                if (bridge->technology->destroy) {
                        bridge->technology->destroy(bridge);
                }
                ast_module_unref(bridge->technology->mod);
                bridge->technology = NULL;
        }

        if (bridge->callid) {
                bridge->callid = ast_callid_unref(bridge->callid);
        }

        cleanup_video_mode(bridge);
}

struct ast_bridge *ast_bridge_register(struct ast_bridge *bridge)
{
        if (bridge) {
                ast_bridge_publish_state(bridge);
                if (!ao2_link(bridges, bridge)) {
                        ast_bridge_destroy(bridge);
                        bridge = NULL;
                }
        }
        return bridge;
}

struct ast_bridge *ast_bridge_alloc(size_t size, const struct ast_bridge_methods *v_table)
{
        struct ast_bridge *bridge;

        /* Check v_table that all methods are present. */
        if (!v_table
                || !v_table->name
                || !v_table->destroy
                || !v_table->dissolving
                || !v_table->push
                || !v_table->pull
                || !v_table->notify_masquerade
                || !v_table->get_merge_priority) {
                ast_log(LOG_ERROR, "Virtual method table for bridge class %s not complete.\n",
                        v_table && v_table->name ? v_table->name : "<unknown>");
                ast_assert(0);
                return NULL;
        }

        bridge = ao2_alloc(size, destroy_bridge);
        if (bridge) {
                bridge->v_table = v_table;
        }
        return bridge;
}

struct ast_bridge *ast_bridge_base_init(struct ast_bridge *self, uint32_t capabilities, unsigned int flags)
{
        if (!self) {
                return NULL;
        }

        ast_uuid_generate_str(self->uniqueid, sizeof(self->uniqueid));
        ast_set_flag(&self->feature_flags, flags);
        self->allowed_capabilities = capabilities;

        /* Use our helper function to find the "best" bridge technology. */
        self->technology = find_best_technology(capabilities, self);
        if (!self->technology) {
                ast_debug(1, "Bridge %s: Could not create.  No technology available to support it.\n",
                        self->uniqueid);
                ao2_ref(self, -1);
                return NULL;
        }

        /* Pass off the bridge to the technology to manipulate if needed */
        ast_debug(1, "Bridge %s: calling %s technology constructor\n",
                self->uniqueid, self->technology->name);
        if (self->technology->create && self->technology->create(self)) {
                ast_debug(1, "Bridge %s: failed to setup %s technology\n",
                        self->uniqueid, self->technology->name);
                ao2_ref(self, -1);
                return NULL;
        }

        if (!ast_bridge_topic(self)) {
                ao2_ref(self, -1);
                return NULL;
        }

        return self;
}

/*!
 * \internal
 * \brief ast_bridge base class destructor.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 *
 * \note Stub because of nothing to do.
 *
 * \return Nothing
 */
static void bridge_base_destroy(struct ast_bridge *self)
{
}

/*!
 * \internal
 * \brief The bridge is being dissolved.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 *
 * \return Nothing
 */
static void bridge_base_dissolving(struct ast_bridge *self)
{
        ao2_unlink(bridges, self);
}

/*!
 * \internal
 * \brief ast_bridge base push method.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 * \param bridge_channel Bridge channel to push.
 * \param swap Bridge channel to swap places with if not NULL.
 *
 * \note On entry, self is already locked.
 * \note Stub because of nothing to do.
 *
 * \retval 0 on success
 * \retval -1 on failure
 */
static int bridge_base_push(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
{
        return 0;
}

/*!
 * \internal
 * \brief ast_bridge base pull method.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 * \param bridge_channel Bridge channel to pull.
 *
 * \note On entry, self is already locked.
 *
 * \return Nothing
 */
static void bridge_base_pull(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
{
        bridge_features_remove_on_pull(bridge_channel->features);
}

/*!
 * \internal
 * \brief ast_bridge base notify_masquerade method.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 * \param bridge_channel Bridge channel that was masqueraded.
 *
 * \note On entry, self is already locked.
 *
 * \return Nothing
 */
static void bridge_base_notify_masquerade(struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
{
        self->reconfigured = 1;
}

/*!
 * \internal
 * \brief Get the merge priority of this bridge.
 * \since 12.0.0
 *
 * \param self Bridge to operate upon.
 *
 * \note On entry, self is already locked.
 *
 * \return Merge priority
 */
static int bridge_base_get_merge_priority(struct ast_bridge *self)
{
        return 0;
}

struct ast_bridge_methods ast_bridge_base_v_table = {
        .name = "base",
        .destroy = bridge_base_destroy,
        .dissolving = bridge_base_dissolving,
        .push = bridge_base_push,
        .pull = bridge_base_pull,
        .notify_masquerade = bridge_base_notify_masquerade,
        .get_merge_priority = bridge_base_get_merge_priority,
};

struct ast_bridge *ast_bridge_base_new(uint32_t capabilities, unsigned int flags)
{
        void *bridge;

        bridge = ast_bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table);
        bridge = ast_bridge_base_init(bridge, capabilities, flags);
        bridge = ast_bridge_register(bridge);
        return bridge;
}

int ast_bridge_destroy(struct ast_bridge *bridge)
{
        ast_debug(1, "Bridge %s: telling all channels to leave the party\n", bridge->uniqueid);
        ast_bridge_lock(bridge);
        bridge_dissolve(bridge);
        ast_bridge_unlock(bridge);

        ao2_ref(bridge, -1);

        return 0;
}

static int bridge_make_compatible(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
{
        struct ast_format read_format;
        struct ast_format write_format;
        struct ast_format best_format;
        char codec_buf[512];

        ast_format_copy(&read_format, ast_channel_readformat(bridge_channel->chan));
        ast_format_copy(&write_format, ast_channel_writeformat(bridge_channel->chan));

        /* Are the formats currently in use something this bridge can handle? */
        if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, ast_channel_readformat(bridge_channel->chan))) {
                ast_best_codec(bridge->technology->format_capabilities, &best_format);

                /* Read format is a no go... */
                ast_debug(1, "Bridge technology %s wants to read any of formats %s but channel has %s\n",
                        bridge->technology->name,
                        ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
                        ast_getformatname(&read_format));

                /* Switch read format to the best one chosen */
                if (ast_set_read_format(bridge_channel->chan, &best_format)) {
                        ast_log(LOG_WARNING, "Failed to set channel %s to read format %s\n",
                                ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
                        return -1;
                }
                ast_debug(1, "Bridge %s put channel %s into read format %s\n",
                        bridge->uniqueid, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&best_format));
        } else {
                ast_debug(1, "Bridge %s is happy that channel %s already has read format %s\n",
                        bridge->uniqueid, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&read_format));
        }

        if (!ast_format_cap_iscompatible(bridge->technology->format_capabilities, &write_format)) {
                ast_best_codec(bridge->technology->format_capabilities, &best_format);

                /* Write format is a no go... */
                ast_debug(1, "Bridge technology %s wants to write any of formats %s but channel has %s\n",
                        bridge->technology->name,
                        ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->format_capabilities),
                        ast_getformatname(&write_format));

                /* Switch write format to the best one chosen */
                if (ast_set_write_format(bridge_channel->chan, &best_format)) {
                        ast_log(LOG_WARNING, "Failed to set channel %s to write format %s\n",
                                ast_channel_name(bridge_channel->chan), ast_getformatname(&best_format));
                        return -1;
                }
                ast_debug(1, "Bridge %s put channel %s into write format %s\n",
                        bridge->uniqueid, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&best_format));
        } else {
                ast_debug(1, "Bridge %s is happy that channel %s already has write format %s\n",
                        bridge->uniqueid, ast_channel_name(bridge_channel->chan),
                        ast_getformatname(&write_format));
        }

        return 0;
}

/*!
 * \internal
 * \brief Perform the smart bridge operation.
 * \since 12.0.0
 *
 * \param bridge Work on this bridge.
 *
 * \details
 * Basically see if a new bridge technology should be used instead
 * of the current one.
 *
 * \note On entry, bridge is already locked.
 *
 * \retval 0 on success.
 * \retval -1 on error.
 */
static int smart_bridge_operation(struct ast_bridge *bridge)
{
        uint32_t new_capabilities;
        struct ast_bridge_technology *new_technology;
        struct ast_bridge_technology *old_technology = bridge->technology;
        struct ast_bridge_channel *bridge_channel;
        struct ast_frame *deferred_action;
        struct ast_bridge dummy_bridge = {
                .technology = bridge->technology,
                .tech_pvt = bridge->tech_pvt,
        };

        if (bridge->dissolved) {
                ast_debug(1, "Bridge %s is dissolved, not performing smart bridge operation.\n",
                        bridge->uniqueid);
                return 0;
        }

        /* Determine new bridge technology capabilities needed. */
        if (2 < bridge->num_channels) {
                new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
                new_capabilities &= bridge->allowed_capabilities;
        } else {
                new_capabilities = AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX;
                new_capabilities &= bridge->allowed_capabilities;
                if (!new_capabilities
                        && (bridge->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
                        /* Allow switching between different multimix bridge technologies. */
                        new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
                }
        }

        /* Find a bridge technology to satisfy the new capabilities. */
        new_technology = find_best_technology(new_capabilities, bridge);
        if (!new_technology) {
                int is_compatible = 0;

                if (old_technology->compatible) {
                        is_compatible = old_technology->compatible(bridge);
                } else if (old_technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) {
                        is_compatible = 1;
                } else if (bridge->num_channels <= 2
                        && (old_technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX)) {
                        is_compatible = 1;
                }

                if (is_compatible) {
                        ast_debug(1, "Bridge %s could not get a new technology, staying with old technology.\n",
                                bridge->uniqueid);
                        return 0;
                }
                ast_log(LOG_WARNING, "Bridge %s has no technology available to support it.\n",
                        bridge->uniqueid);
                return -1;
        }
        if (new_technology == old_technology) {
                ast_debug(1, "Bridge %s is already using the new technology.\n",
                        bridge->uniqueid);
                ast_module_unref(old_technology->mod);
                return 0;
        }

        ast_copy_string(dummy_bridge.uniqueid, bridge->uniqueid, sizeof(dummy_bridge.uniqueid));

        if (old_technology->destroy) {
                struct tech_deferred_destroy deferred_tech_destroy = {
                        .tech = dummy_bridge.technology,
                        .tech_pvt = dummy_bridge.tech_pvt,
                };
                struct ast_frame action = {
                        .frametype = AST_FRAME_BRIDGE_ACTION,
                        .subclass.integer = AST_BRIDGE_ACTION_DEFERRED_TECH_DESTROY,
                        .data.ptr = &deferred_tech_destroy,
                        .datalen = sizeof(deferred_tech_destroy),
                };

                /*
                 * We need to defer the bridge technology destroy callback
                 * because we have the bridge locked.
                 */
                deferred_action = ast_frdup(&action);
                if (!deferred_action) {
                        ast_module_unref(new_technology->mod);
                        return -1;
                }
        } else {
                deferred_action = NULL;
        }

        /*
         * We are now committed to changing the bridge technology.  We
         * must not release the bridge lock until we have installed the
         * new bridge technology.
         */
        ast_debug(1, "Bridge %s: switching %s technology to %s\n",
                bridge->uniqueid, old_technology->name, new_technology->name);

        /*
         * Since we are soon going to pass this bridge to a new
         * technology we need to NULL out the tech_pvt pointer but
         * don't worry as it still exists in dummy_bridge, ditto for the
         * old technology.
         */
        bridge->tech_pvt = NULL;
        bridge->technology = new_technology;

        /* Setup the new bridge technology. */
        ast_debug(1, "Bridge %s: calling %s technology constructor\n",
                bridge->uniqueid, new_technology->name);
        if (new_technology->create && new_technology->create(bridge)) {
                ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
                        bridge->uniqueid, new_technology->name);
                bridge->tech_pvt = dummy_bridge.tech_pvt;
                bridge->technology = dummy_bridge.technology;
                ast_module_unref(new_technology->mod);
                return -1;
        }

        /* Move existing channels over to the new technology. */
        AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
                if (bridge_channel->just_joined) {
                        /*
                         * This channel has not completed joining the bridge so it is
                         * not in the old bridge technology.
                         */
                        continue;
                }

                /* First we part them from the old technology */
                ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology (dummy)\n",
                        dummy_bridge.uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                        old_technology->name);
                if (old_technology->leave) {
                        old_technology->leave(&dummy_bridge, bridge_channel);
                }

                /* Second we make them compatible again with the bridge */
                bridge_make_compatible(bridge, bridge_channel);

                /* Third we join them to the new technology */
                ast_debug(1, "Bridge %s: %p(%s) is joining %s technology\n",
                        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                        new_technology->name);
                if (new_technology->join && new_technology->join(bridge, bridge_channel)) {
                        ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology\n",
                                bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
                                new_technology->name);
                }
        }

        /*
         * Now that all the channels have been moved over we need to get
         * rid of all the information the old technology may have left
         * around.
         */
        if (old_technology->destroy) {
                ast_debug(1, "Bridge %s: deferring %s technology destructor\n",
                        bridge->uniqueid, old_technology->name);
                bridge_queue_action_nodup(bridge, deferred_action);
        } else {
                ast_debug(1, "Bridge %s: calling %s technology destructor\n",
                        bridge->uniqueid, old_technology->name);
                ast_module_unref(old_technology->mod);
        }

        return 0;
}

/*!
 * \internal
 * \brief Notify the bridge that it has been reconfigured.
 * \since 12.0.0
 *
 * \param bridge Reconfigured bridge.
 *
 * \details
 * After a series of bridge_channel_push and
 * bridge_channel_pull calls, you need to call this function
 * to cause the bridge to complete restruturing for the change
 * in the channel makeup of the bridge.
 *
 * \note On entry, the bridge is already locked.
 *
 * \return Nothing
 */
static void bridge_reconfigured(struct ast_bridge *bridge)
{
        if (!bridge->reconfigured) {
                return;
        }
        bridge->reconfigured = 0;
        if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_SMART)
                && smart_bridge_operation(bridge)) {
                /* Smart bridge failed. */
                bridge_dissolve(bridge);
                return;
        }
        bridge_complete_join(bridge);
}

/*!
 * \internal
 * \brief Suspend a channel from a bridge.
 *
 * \param bridge_channel Channel to suspend.
 *
 * \note This function assumes bridge_channel->bridge is locked.
 *
 * \return Nothing
 */
static void bridge_channel_suspend_nolock(struct ast_bridge_channel *bridge_channel)
{
        bridge_channel->suspended = 1;
        if (bridge_channel->in_bridge) {
                --bridge_channel->bridge->num_active;
        }

        /* Get technology bridge threads off of the channel. */
        if (bridge_channel->bridge->technology->suspend) {
                bridge_channel->bridge->technology->suspend(bridge_channel->bridge, bridge_channel);
        }
}

/*!
 * \internal
 * \brief Suspend a channel from a bridge.
 *
 * \param bridge_channel Channel to suspend.
 *
 * \return Nothing
 */
static void bridge_channel_suspend(struct ast_bridge_channel *bridge_channel)
{
        ast_bridge_channel_lock_bridge(bridge_channel);
        bridge_channel_suspend_nolock(bridge_channel);
        ast_bridge_unlock(bridge_channel->bridge);
}

/*!
 * \internal
 * \brief Unsuspend a channel from a bridge.
 *
 * \param bridge_channel Channel to unsuspend.
 *
 * \note This function assumes bridge_channel->bridge is locked.
 *
 * \return Nothing
 */
static void bridge_channel_unsuspend_nolock(struct ast_bridge_channel *bridge_channel)
{
        bridge_channel->suspended = 0;
        if (bridge_channel->in_bridge) {
                ++bridge_channel->bridge->num_active;
        }

        /* Wake technology bridge threads to take care of channel again. */
        if (bridge_channel->bridge->technology->unsuspend) {
                bridge_channel->bridge->technology->unsuspend(bridge_channel->bridge, bridge_channel);
        }

        /* Wake suspended channel. */
        ast_bridge_channel_lock(bridge_channel);
        ast_cond_signal(&bridge_channel->cond);
        ast_bridge_channel_unlock(bridge_channel);
}

/*!
 * \internal
 * \brief Unsuspend a channel from a bridge.
 *
 * \param bridge_channel Channel to unsuspend.
 *
 * \return Nothing
 */
static void bridge_channel_unsuspend(struct ast_bridge_channel *bridge_channel)
{
        ast_bridge_channel_lock_bridge(bridge_channel);
        bridge_channel_unsuspend_nolock(bridge_channel);
        ast_bridge_unlock(bridge_channel->bridge);
}

/*! \brief Internal function that activates interval hooks on a bridge channel */
static void bridge_channel_interval(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_hook *hook;
        struct timeval start;

        ast_heap_wrlock(bridge_channel->features->interval_hooks);
        start = ast_tvnow();
        while ((hook = ast_heap_peek(bridge_channel->features->interval_hooks, 1))) {
                int interval;
                unsigned int execution_time;

                if (ast_tvdiff_ms(hook->parms.timer.trip_time, start) > 0) {
                        ast_debug(1, "Hook %p on %p(%s) wants to happen in the future, stopping our traversal\n",
                                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                        break;
                }
                ao2_ref(hook, +1);
                ast_heap_unlock(bridge_channel->features->interval_hooks);

                ast_debug(1, "Executing hook %p on %p(%s)\n",
                        hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                interval = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);

                ast_heap_wrlock(bridge_channel->features->interval_hooks);
                if (ast_heap_peek(bridge_channel->features->interval_hooks,
                        hook->parms.timer.heap_index) != hook
                        || !ast_heap_remove(bridge_channel->features->interval_hooks, hook)) {
                        /* Interval hook is already removed from the bridge_channel. */
                        ao2_ref(hook, -1);
                        continue;
                }
                ao2_ref(hook, -1);

                if (interval < 0) {
                        ast_debug(1, "Removed interval hook %p from %p(%s)\n",
                                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                        ao2_ref(hook, -1);
                        continue;
                }
                if (interval) {
                        /* Set new interval for the hook. */
                        hook->parms.timer.interval = interval;
                }

                ast_debug(1, "Updating interval hook %p with interval %u on %p(%s)\n",
                        hook, hook->parms.timer.interval, bridge_channel,
                        ast_channel_name(bridge_channel->chan));

                /* resetting start */
                start = ast_tvnow();

                /*
                 * Resetup the interval hook for the next interval.  We may need
                 * to skip over any missed intervals because the hook was
                 * delayed or took too long.
                 */
                execution_time = ast_tvdiff_ms(start, hook->parms.timer.trip_time);
                while (hook->parms.timer.interval < execution_time) {
                        execution_time -= hook->parms.timer.interval;
                }
                hook->parms.timer.trip_time = ast_tvadd(start, ast_samp2tv(hook->parms.timer.interval - execution_time, 1000));
                hook->parms.timer.seqno = ast_atomic_fetchadd_int((int *) &bridge_channel->features->interval_sequence, +1);

                if (ast_heap_push(bridge_channel->features->interval_hooks, hook)) {
                        /* Could not push the hook back onto the heap. */
                        ao2_ref(hook, -1);
                }
        }
        ast_heap_unlock(bridge_channel->features->interval_hooks);
}

static void bridge_channel_write_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
{
        ast_bridge_channel_write_action_data(bridge_channel,
                AST_BRIDGE_ACTION_DTMF_STREAM, dtmf, strlen(dtmf) + 1);
}

/*!
 * \brief Internal function that executes a feature on a bridge channel
 * \note Neither the bridge nor the bridge_channel locks should be held when entering
 * this function.
 */
static void bridge_channel_feature(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook = NULL;
        char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = "";
        size_t dtmf_len = 0;

        /* The channel is now under our control and we don't really want any begin frames to do our DTMF matching so disable 'em at the core level */
        ast_set_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_END_DTMF_ONLY);

        /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */
        do {
                int res;

                /* If the above timed out simply exit */
                res = ast_waitfordigit(bridge_channel->chan, 3000);
                if (!res) {
                        ast_debug(1, "DTMF feature string collection on %p(%s) timed out\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan));
                        break;
                }
                if (res < 0) {
                        ast_debug(1, "DTMF feature string collection failed on %p(%s) for some reason\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan));
                        break;
                }

/* BUGBUG need to record the duration of DTMF digits so when the string is played back, they are reproduced. */
                /* Add the above DTMF into the DTMF string so we can do our matching */
                dtmf[dtmf_len++] = res;
                ast_debug(1, "DTMF feature string on %p(%s) is now '%s'\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan), dtmf);

                /* See if a DTMF feature hook matches or can match */
                hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_PARTIAL_KEY);
                if (!hook) {
                        ast_debug(1, "No DTMF feature hooks on %p(%s) match '%s'\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan), dtmf);
                        break;
                }
                if (strlen(hook->parms.dtmf.code) == dtmf_len) {
                        ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on %p(%s)\n",
                                hook, dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
                        break;
                }
                ao2_ref(hook, -1);
                hook = NULL;

                /* Stop if we have reached the maximum length of a DTMF feature string. */
        } while (dtmf_len < ARRAY_LEN(dtmf) - 1);

        /* Since we are done bringing DTMF in return to using both begin and end frames */
        ast_clear_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_END_DTMF_ONLY);

        /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */
        if (hook) {
                int failed;

                failed = hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
                if (failed) {
                        ast_debug(1, "DTMF hook %p is being removed from %p(%s)\n",
                                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                        ao2_unlink(features->dtmf_hooks, hook);
                }
                ao2_ref(hook, -1);

                /*
                 * If we are handing the channel off to an external hook for
                 * ownership, we are not guaranteed what kind of state it will
                 * come back in.  If the channel hungup, we need to detect that
                 * here if the hook did not already change the state.
                 */
                if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
                        bridge_handle_hangup(bridge_channel);
                }
        } else if (features->dtmf_passthrough) {
                bridge_channel_write_dtmf_stream(bridge_channel, dtmf);
        }
}

static void bridge_channel_talking(struct ast_bridge_channel *bridge_channel, int talking)
{
        struct ast_bridge_features *features = bridge_channel->features;

        if (features->talker_cb) {
                features->talker_cb(bridge_channel, features->talker_pvt_data, talking);
        }
}

/*! \brief Internal function that plays back DTMF on a bridge channel */
static void bridge_channel_dtmf_stream(struct ast_bridge_channel *bridge_channel, const char *dtmf)
{
        ast_debug(1, "Playing DTMF stream '%s' out to %p(%s)\n",
                dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
        ast_dtmf_stream(bridge_channel->chan, NULL, dtmf, 0, 0);
}

struct blind_transfer_data {
        char exten[AST_MAX_EXTENSION];
        char context[AST_MAX_CONTEXT];
};

static void bridge_channel_blind_transfer(struct ast_bridge_channel *bridge_channel,
                struct blind_transfer_data *blind_data)
{
        ast_async_goto(bridge_channel->chan, blind_data->context, blind_data->exten, 1);
        bridge_handle_hangup(bridge_channel);
}

static void after_bridge_move_channel(struct ast_channel *chan_bridged, void *data)
{
        RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
        ast_channel_move(chan_target, chan_bridged);
}

static void after_bridge_move_channel_fail(enum ast_after_bridge_cb_reason reason, void *data)
{
        RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);

        ast_log(LOG_WARNING, "Unable to complete transfer: %s\n",
                        ast_after_bridge_cb_reason_string(reason));
}

static void bridge_channel_attended_transfer(struct ast_bridge_channel *bridge_channel,
                const char *target_chan_name)
{
        RAII_VAR(struct ast_channel *, chan_target, NULL, ao2_cleanup);
        RAII_VAR(struct ast_channel *, chan_bridged, NULL, ao2_cleanup);

        chan_target = ast_channel_get_by_name(target_chan_name);
        if (!chan_target) {
                /* Dang, it disappeared somehow */
                return;
        }

        {
                SCOPED_CHANNELLOCK(lock, bridge_channel);
                chan_bridged = bridge_channel->chan;
                if (!chan_bridged) {
                        return;
                }
                ao2_ref(chan_bridged, +1);
        }

        if (ast_after_bridge_callback_set(chan_bridged, after_bridge_move_channel,
                        after_bridge_move_channel_fail, ast_channel_ref(chan_target))) {
                return;
        }
        bridge_handle_hangup(bridge_channel);
}

/*!
 * \internal
 * \brief Handle bridge channel bridge action frame.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to execute the action on.
 * \param action What to do.
 *
 * \return Nothing
 */
static void bridge_channel_handle_action(struct ast_bridge_channel *bridge_channel, struct ast_frame *action)
{
        switch (action->subclass.integer) {
        case AST_BRIDGE_ACTION_INTERVAL:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_interval(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_FEATURE:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_feature(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_DTMF_STREAM:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_dtmf_stream(bridge_channel, action->data.ptr);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_TALKING_START:
        case AST_BRIDGE_ACTION_TALKING_STOP:
                bridge_channel_talking(bridge_channel,
                        action->subclass.integer == AST_BRIDGE_ACTION_TALKING_START);
                break;
        case AST_BRIDGE_ACTION_PLAY_FILE:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_playfile(bridge_channel, action->data.ptr);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_PARK:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_park(bridge_channel, action->data.ptr);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_RUN_APP:
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_run_app(bridge_channel, action->data.ptr);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
                break;
        case AST_BRIDGE_ACTION_BLIND_TRANSFER:
                bridge_channel_blind_transfer(bridge_channel, action->data.ptr);
                break;
        case AST_BRIDGE_ACTION_ATTENDED_TRANSFER:
                bridge_channel_attended_transfer(bridge_channel, action->data.ptr);
                break;
        default:
                break;
        }
}

/*!
 * \internal
 * \brief Handle bridge channel control frame action.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to execute the control frame action on.
 * \param fr Control frame to handle.
 *
 * \return Nothing
 */
static void bridge_channel_handle_control(struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
{
        struct ast_channel *chan;
        struct ast_option_header *aoh;
        int is_caller;
        int intercept_failed;

        chan = bridge_channel->chan;
        switch (fr->subclass.integer) {
        case AST_CONTROL_REDIRECTING:
                is_caller = !ast_test_flag(ast_channel_flags(chan), AST_FLAG_OUTGOING);
                bridge_channel_suspend(bridge_channel);
                intercept_failed = ast_channel_redirecting_sub(NULL, chan, fr, 1)
                        && ast_channel_redirecting_macro(NULL, chan, fr, is_caller, 1);
                bridge_channel_unsuspend(bridge_channel);
                if (intercept_failed) {
                        ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
                }
                break;
        case AST_CONTROL_CONNECTED_LINE:
                is_caller = !ast_test_flag(ast_channel_flags(chan), AST_FLAG_OUTGOING);
                bridge_channel_suspend(bridge_channel);
                intercept_failed = ast_channel_connected_line_sub(NULL, chan, fr, 1)
                        && ast_channel_connected_line_macro(NULL, chan, fr, is_caller, 1);
                bridge_channel_unsuspend(bridge_channel);
                if (intercept_failed) {
                        ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
                }
                break;
        case AST_CONTROL_HOLD:
        case AST_CONTROL_UNHOLD:
/*
 * BUGBUG bridge_channels should remember sending/receiving an outstanding HOLD to/from the bridge
 *
 * When the sending channel is pulled from the bridge it needs to write into the bridge an UNHOLD before being pulled.
 * When the receiving channel is pulled from the bridge it needs to generate its own UNHOLD.
 * Something similar needs to be done for DTMF begin/end.
 */
        case AST_CONTROL_VIDUPDATE:
        case AST_CONTROL_SRCUPDATE:
        case AST_CONTROL_SRCCHANGE:
        case AST_CONTROL_T38_PARAMETERS:
/* BUGBUG may have to do something with a jitter buffer for these. */
                ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
                break;
        case AST_CONTROL_OPTION:
                /*
                 * Forward option Requests, but only ones we know are safe These
                 * are ONLY sent by chan_iax2 and I'm not convinced that they
                 * are useful. I haven't deleted them entirely because I just am
                 * not sure of the ramifications of removing them.
                 */
                aoh = fr->data.ptr;
                if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
                        switch (ntohs(aoh->option)) {
                        case AST_OPTION_TONE_VERIFY:
                        case AST_OPTION_TDD:
                        case AST_OPTION_RELAXDTMF:
                        case AST_OPTION_AUDIO_MODE:
                        case AST_OPTION_DIGIT_DETECT:
                        case AST_OPTION_FAX_DETECT:
                                ast_channel_setoption(chan, ntohs(aoh->option), aoh->data,
                                        fr->datalen - sizeof(*aoh), 0);
                                break;
                        default:
                                break;
                        }
                }
                break;
        case AST_CONTROL_ANSWER:
                if (ast_channel_state(chan) != AST_STATE_UP) {
                        ast_answer(chan);
                } else {
                        ast_indicate(chan, -1);
                }
                break;
        default:
                ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
                break;
        }
}

/*!
 * \internal
 * \brief Handle bridge channel write frame to channel.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to write outgoing frame.
 *
 * \return Nothing
 */
static void bridge_channel_handle_write(struct ast_bridge_channel *bridge_channel)
{
        struct ast_frame *fr;
        char nudge;

        ast_bridge_channel_lock(bridge_channel);
        if (read(bridge_channel->alert_pipe[0], &nudge, sizeof(nudge)) < 0) {
                if (errno != EINTR && errno != EAGAIN) {
                        ast_log(LOG_WARNING, "read() failed for alert pipe on %p(%s): %s\n",
                                bridge_channel, ast_channel_name(bridge_channel->chan), strerror(errno));
                }
        }
        fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list);
        ast_bridge_channel_unlock(bridge_channel);
        if (!fr) {
                return;
        }
        switch (fr->frametype) {
        case AST_FRAME_BRIDGE_ACTION:
                bridge_channel_handle_action(bridge_channel, fr);
                break;
        case AST_FRAME_CONTROL:
                bridge_channel_handle_control(bridge_channel, fr);
                break;
        case AST_FRAME_NULL:
                break;
        default:
                /* Write the frame to the channel. */
                bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_SIMPLE;
                ast_write(bridge_channel->chan, fr);
                break;
        }
        ast_frfree(fr);
}

/*!
 * \internal
 * \brief Handle bridge channel interval expiration.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to check interval on.
 *
 * \return Nothing
 */
static void bridge_channel_handle_interval(struct ast_bridge_channel *bridge_channel)
{
        struct ast_timer *interval_timer;

        interval_timer = bridge_channel->features->interval_timer;
        if (interval_timer) {
                if (ast_wait_for_input(ast_timer_fd(interval_timer), 0) == 1) {
                        ast_timer_ack(interval_timer, 1);
                        if (bridge_channel_interval_ready(bridge_channel)) {
/* BUGBUG since this is now only run by the channel thread, there is no need to queue the action once this intervals become a first class wait item in bridge_channel_wait(). */
                                struct ast_frame interval_action = {
                                        .frametype = AST_FRAME_BRIDGE_ACTION,
                                        .subclass.integer = AST_BRIDGE_ACTION_INTERVAL,
                                };

                                ast_bridge_channel_queue_frame(bridge_channel, &interval_action);
                        }
                }
        }
}

/*!
 * \internal
 * \brief Wait for something to happen on the bridge channel and handle it.
 * \since 12.0.0
 *
 * \param bridge_channel Channel to wait.
 *
 * \note Each channel does writing/reading in their own thread.
 *
 * \return Nothing
 */
static void bridge_channel_wait(struct ast_bridge_channel *bridge_channel)
{
        int ms = -1;
        int outfd;
        struct ast_channel *chan;

        /* Wait for data to either come from the channel or us to be signaled */
        ast_bridge_channel_lock(bridge_channel);
        if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
        } else if (bridge_channel->suspended) {
/* BUGBUG the external party use of suspended will go away as will these references because this is the bridge channel thread */
                ast_debug(1, "Bridge %s: %p(%s) is going into a signal wait\n",
                        bridge_channel->bridge->uniqueid, bridge_channel,
                        ast_channel_name(bridge_channel->chan));
                ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
        } else {
                ast_debug(10, "Bridge %s: %p(%s) is going into a waitfor\n",
                        bridge_channel->bridge->uniqueid, bridge_channel,
                        ast_channel_name(bridge_channel->chan));
                bridge_channel->waiting = 1;
                ast_bridge_channel_unlock(bridge_channel);
                outfd = -1;
/* BUGBUG need to make the next expiring active interval setup ms timeout rather than holding up the chan reads. */
                chan = ast_waitfor_nandfds(&bridge_channel->chan, 1,
                        &bridge_channel->alert_pipe[0], 1, NULL, &outfd, &ms);
                bridge_channel->waiting = 0;
                if (ast_channel_softhangup_internal_flag(bridge_channel->chan) & AST_SOFTHANGUP_UNBRIDGE) {
                        ast_channel_clear_softhangup(bridge_channel->chan, AST_SOFTHANGUP_UNBRIDGE);
                        ast_bridge_channel_lock_bridge(bridge_channel);
                        bridge_channel->bridge->reconfigured = 1;
                        bridge_reconfigured(bridge_channel->bridge);
                        ast_bridge_unlock(bridge_channel->bridge);
                }
                ast_bridge_channel_lock(bridge_channel);
                bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_FRAME;
                ast_bridge_channel_unlock(bridge_channel);
                if (!bridge_channel->suspended
                        && bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
                        if (chan) {
                                bridge_channel_handle_interval(bridge_channel);
                                bridge_handle_trip(bridge_channel);
                        } else if (-1 < outfd) {
                                bridge_channel_handle_write(bridge_channel);
                        }
                }
                bridge_channel->activity = AST_BRIDGE_CHANNEL_THREAD_IDLE;
                return;
        }
        ast_bridge_channel_unlock(bridge_channel);
}

/*!
 * \internal
 * \brief Handle bridge channel join event.
 * \since 12.0.0
 *
 * \param bridge_channel Which channel is joining.
 *
 * \return Nothing
 */
static void bridge_channel_handle_join(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook;
        struct ao2_iterator iter;

        /* Run any join hooks. */
        iter = ao2_iterator_init(features->join_hooks, AO2_ITERATOR_UNLINK);
        hook = ao2_iterator_next(&iter);
        if (hook) {
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                do {
                        hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
                        ao2_ref(hook, -1);
                } while ((hook = ao2_iterator_next(&iter)));
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
        }
        ao2_iterator_destroy(&iter);
}

/*!
 * \internal
 * \brief Handle bridge channel leave event.
 * \since 12.0.0
 *
 * \param bridge_channel Which channel is leaving.
 *
 * \return Nothing
 */
static void bridge_channel_handle_leave(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge_features *features = bridge_channel->features;
        struct ast_bridge_hook *hook;
        struct ao2_iterator iter;

        /* Run any leave hooks. */
        iter = ao2_iterator_init(features->leave_hooks, AO2_ITERATOR_UNLINK);
        hook = ao2_iterator_next(&iter);
        if (hook) {
                bridge_channel_suspend(bridge_channel);
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                do {
                        hook->callback(bridge_channel->bridge, bridge_channel, hook->hook_pvt);
                        ao2_ref(hook, -1);
                } while ((hook = ao2_iterator_next(&iter)));
                ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
                bridge_channel_unsuspend(bridge_channel);
        }
        ao2_iterator_destroy(&iter);
}

/*! \brief Join a channel to a bridge and handle anything the bridge may want us to do */
static void bridge_channel_join(struct ast_bridge_channel *bridge_channel)
{
        ast_format_copy(&bridge_channel->read_format, ast_channel_readformat(bridge_channel->chan));
        ast_format_copy(&bridge_channel->write_format, ast_channel_writeformat(bridge_channel->chan));

        ast_debug(1, "Bridge %s: %p(%s) is joining\n",
                bridge_channel->bridge->uniqueid,
                bridge_channel, ast_channel_name(bridge_channel->chan));

        /*
         * Get "in the bridge" before pushing the channel for any
         * masquerades on the channel to happen before bridging.
         */
        ast_channel_lock(bridge_channel->chan);
        ast_channel_internal_bridge_set(bridge_channel->chan, bridge_channel->bridge);
        ast_channel_unlock(bridge_channel->chan);

        /* Add the jitterbuffer if the channel requires it */
        ast_jb_enable_for_channel(bridge_channel->chan);

        /*
         * Directly locking the bridge is safe here because nobody else
         * knows about this bridge_channel yet.
         */
        ast_bridge_lock(bridge_channel->bridge);

        if (!bridge_channel->bridge->callid) {
                bridge_channel->bridge->callid = ast_read_threadstorage_callid();
        }

        if (bridge_channel_push(bridge_channel)) {
                ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
        }
        bridge_reconfigured(bridge_channel->bridge);

        if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
                /*
                 * Indicate a source change since this channel is entering the
                 * bridge system only if the bridge technology is not MULTIMIX
                 * capable.  The MULTIMIX technology has already done it.
                 */
                if (!(bridge_channel->bridge->technology->capabilities
                        & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
                        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
                }

                ast_bridge_unlock(bridge_channel->bridge);
                bridge_channel_handle_join(bridge_channel);
                while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
                        /* Wait for something to do. */
                        bridge_channel_wait(bridge_channel);
                }
                bridge_channel_handle_leave(bridge_channel);
                ast_bridge_channel_lock_bridge(bridge_channel);
        }

        bridge_channel_pull(bridge_channel);
        bridge_reconfigured(bridge_channel->bridge);

        ast_bridge_unlock(bridge_channel->bridge);

        /* Indicate a source change since this channel is leaving the bridge system. */
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);

/* BUGBUG Revisit in regards to moving channels between bridges and local channel optimization. */
/* BUGBUG This is where outgoing HOLD/UNHOLD memory should write UNHOLD to channel. */
        /* Complete any partial DTMF digit before exiting the bridge. */
        if (ast_channel_sending_dtmf_digit(bridge_channel->chan)) {
                ast_bridge_end_dtmf(bridge_channel->chan,
                        ast_channel_sending_dtmf_digit(bridge_channel->chan),
                        ast_channel_sending_dtmf_tv(bridge_channel->chan), "bridge end");
        }

        /*
         * Wait for any dual redirect to complete.
         *
         * Must be done while "still in the bridge" for ast_async_goto()
         * to work right.
         */
        while (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT)) {
                sched_yield();
        }
        ast_channel_lock(bridge_channel->chan);
        ast_channel_internal_bridge_set(bridge_channel->chan, NULL);
        ast_channel_unlock(bridge_channel->chan);

        ast_bridge_channel_restore_formats(bridge_channel);
}

/*!
 * \internal
 * \brief Close a pipe.
 * \since 12.0.0
 *
 * \param my_pipe What to close.
 *
 * \return Nothing
 */
static void pipe_close(int *my_pipe)
{
        if (my_pipe[0] > -1) {
                close(my_pipe[0]);
                my_pipe[0] = -1;
        }
        if (my_pipe[1] > -1) {
                close(my_pipe[1]);
                my_pipe[1] = -1;
        }
}

/*!
 * \internal
 * \brief Initialize a pipe as non-blocking.
 * \since 12.0.0
 *
 * \param my_pipe What to initialize.
 *
 * \retval 0 on success.
 * \retval -1 on error.
 */
static int pipe_init_nonblock(int *my_pipe)
{
        int flags;

        my_pipe[0] = -1;
        my_pipe[1] = -1;
        if (pipe(my_pipe)) {
                ast_log(LOG_WARNING, "Can't create pipe! Try increasing max file descriptors with ulimit -n\n");
                return -1;
        }
        flags = fcntl(my_pipe[0], F_GETFL);
        if (fcntl(my_pipe[0], F_SETFL, flags | O_NONBLOCK) < 0) {
                ast_log(LOG_WARNING, "Unable to set read pipe nonblocking! (%d: %s)\n",
                        errno, strerror(errno));
                return -1;
        }
        flags = fcntl(my_pipe[1], F_GETFL);
        if (fcntl(my_pipe[1], F_SETFL, flags | O_NONBLOCK) < 0) {
                ast_log(LOG_WARNING, "Unable to set write pipe nonblocking! (%d: %s)\n",
                        errno, strerror(errno));
                return -1;
        }
        return 0;
}

/* Destroy elements of the bridge channel structure and the bridge channel structure itself */
static void bridge_channel_destroy(void *obj)
{
        struct ast_bridge_channel *bridge_channel = obj;
        struct ast_frame *fr;

        if (bridge_channel->callid) {
                bridge_channel->callid = ast_callid_unref(bridge_channel->callid);
        }

        if (bridge_channel->bridge) {
                ao2_ref(bridge_channel->bridge, -1);
                bridge_channel->bridge = NULL;
        }

        /* Flush any unhandled wr_queue frames. */
        while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list))) {
                ast_frfree(fr);
        }
        pipe_close(bridge_channel->alert_pipe);

        ast_cond_destroy(&bridge_channel->cond);
}

static struct ast_bridge_channel *bridge_channel_alloc(struct ast_bridge *bridge)
{
        struct ast_bridge_channel *bridge_channel;

        bridge_channel = ao2_alloc(sizeof(struct ast_bridge_channel), bridge_channel_destroy);
        if (!bridge_channel) {
                return NULL;
        }
        ast_cond_init(&bridge_channel->cond, NULL);
        if (pipe_init_nonblock(bridge_channel->alert_pipe)) {
                ao2_ref(bridge_channel, -1);
                return NULL;
        }
        if (bridge) {
                bridge_channel->bridge = bridge;
                ao2_ref(bridge_channel->bridge, +1);
        }

        return bridge_channel;
}

struct after_bridge_cb_ds {
        /*! Desired callback function. */
        ast_after_bridge_cb callback;
        /*! After bridge callback will not be called and destroy any resources data may contain. */
        ast_after_bridge_cb_failed failed;
        /*! Extra data to pass to the callback. */
        void *data;
};

/*!
 * \internal
 * \brief Destroy the after bridge callback datastore.
 * \since 12.0.0
 *
 * \param data After bridge callback data to destroy.
 *
 * \return Nothing
 */
static void after_bridge_cb_destroy(void *data)
{
        struct after_bridge_cb_ds *after_bridge = data;

        if (after_bridge->failed) {
                after_bridge->failed(AST_AFTER_BRIDGE_CB_REASON_DESTROY, after_bridge->data);
                after_bridge->failed = NULL;
        }
}

/*!
 * \internal
 * \brief Fixup the after bridge callback datastore.
 * \since 12.0.0
 *
 * \param data After bridge callback data to fixup.
 * \param old_chan The datastore is moving from this channel.
 * \param new_chan The datastore is moving to this channel.
 *
 * \return Nothing
 */
static void after_bridge_cb_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
{
        /* There can be only one.  Discard any already on the new channel. */
        ast_after_bridge_callback_discard(new_chan, AST_AFTER_BRIDGE_CB_REASON_MASQUERADE);
}

static const struct ast_datastore_info after_bridge_cb_info = {
        .type = "after-bridge-cb",
        .destroy = after_bridge_cb_destroy,
        .chan_fixup = after_bridge_cb_fixup,
};

/*!
 * \internal
 * \brief Remove channel after the bridge callback and return it.
 * \since 12.0.0
 *
 * \param chan Channel to remove after bridge callback.
 *
 * \retval datastore on success.
 * \retval NULL on error or not found.
 */
static struct ast_datastore *after_bridge_cb_remove(struct ast_channel *chan)
{
        struct ast_datastore *datastore;

        ast_channel_lock(chan);
        datastore = ast_channel_datastore_find(chan, &after_bridge_cb_info, NULL);
        if (datastore && ast_channel_datastore_remove(chan, datastore)) {
                datastore = NULL;
        }
        ast_channel_unlock(chan);

        return datastore;
}

void ast_after_bridge_callback_discard(struct ast_channel *chan, enum ast_after_bridge_cb_reason reason)
{
        struct ast_datastore *datastore;

        datastore = after_bridge_cb_remove(chan);
        if (datastore) {
                struct after_bridge_cb_ds *after_bridge = datastore->data;

                if (after_bridge && after_bridge->failed) {
                        after_bridge->failed(reason, after_bridge->data);
                        after_bridge->failed = NULL;
                }
                ast_datastore_free(datastore);
        }
}

/*!
 * \internal
 * \brief Run any after bridge callback if possible.
 * \since 12.0.0
 *
 * \param chan Channel to run after bridge callback.
 *
 * \return Nothing
 */
static void after_bridge_callback_run(struct ast_channel *chan)
{
        struct ast_datastore *datastore;
        struct after_bridge_cb_ds *after_bridge;

        if (ast_check_hangup(chan)) {
                return;
        }

        /* Get after bridge goto datastore. */
        datastore = after_bridge_cb_remove(chan);
        if (!datastore) {
                return;
        }

        after_bridge = datastore->data;
        if (after_bridge) {
                after_bridge->failed = NULL;
                after_bridge->callback(chan, after_bridge->data);
        }

        /* Discard after bridge callback datastore. */
        ast_datastore_free(datastore);
}

int ast_after_bridge_callback_set(struct ast_channel *chan, ast_after_bridge_cb callback, ast_after_bridge_cb_failed failed, void *data)
{
        struct ast_datastore *datastore;
        struct after_bridge_cb_ds *after_bridge;

        /* Sanity checks. */
        ast_assert(chan != NULL);
        if (!chan || !callback) {
                return -1;
        }

        /* Create a new datastore. */
        datastore = ast_datastore_alloc(&after_bridge_cb_info, NULL);
        if (!datastore) {
                return -1;
        }
        after_bridge = ast_calloc(1, sizeof(*after_bridge));
        if (!after_bridge) {
                ast_datastore_free(datastore);
                return -1;
        }

        /* Initialize it. */
        after_bridge->callback = callback;
        after_bridge->failed = failed;
        after_bridge->data = data;
        datastore->data = after_bridge;

        /* Put it on the channel replacing any existing one. */
        ast_channel_lock(chan);
        ast_after_bridge_callback_discard(chan, AST_AFTER_BRIDGE_CB_REASON_REPLACED);
        ast_channel_datastore_add(chan, datastore);
        ast_channel_unlock(chan);

        return 0;
}

const char *reason_strings[] = {
        [AST_AFTER_BRIDGE_CB_REASON_DESTROY] = "Bridge Destroyed",
        [AST_AFTER_BRIDGE_CB_REASON_REPLACED] = "Channel replaced",
        [AST_AFTER_BRIDGE_CB_REASON_MASQUERADE] = "Channel masqueraded",
        [AST_AFTER_BRIDGE_CB_REASON_DEPART] = "Channel departed",
        [AST_AFTER_BRIDGE_CB_REASON_REMOVED] = "Channel removed",
};

const char *ast_after_bridge_cb_reason_string(enum ast_after_bridge_cb_reason reason)
{
        if (reason < AST_AFTER_BRIDGE_CB_REASON_DESTROY || reason > AST_AFTER_BRIDGE_CB_REASON_REMOVED) {
                return "Unknown";
        }

        return reason_strings[reason];
}

struct after_bridge_goto_ds {
        /*! Goto string that can be parsed by ast_parseable_goto(). */
        const char *parseable_goto;
        /*! Specific goto context or default context for parseable_goto. */
        const char *context;
        /*! Specific goto exten or default exten for parseable_goto. */
        const char *exten;
        /*! Specific goto priority or default priority for parseable_goto. */
        int priority;
        /*! TRUE if the peer should run the h exten. */
        unsigned int run_h_exten:1;
        /*! Specific goto location */
        unsigned int specific:1;
};

/*!
 * \internal
 * \brief Destroy the after bridge goto datastore.
 * \since 12.0.0
 *
 * \param data After bridge goto data to destroy.
 *
 * \return Nothing
 */
static void after_bridge_goto_destroy(void *data)
{
        struct after_bridge_goto_ds *after_bridge = data;

        ast_free((char *) after_bridge->parseable_goto);
        ast_free((char *) after_bridge->context);
        ast_free((char *) after_bridge->exten);
}

/*!
 * \internal
 * \brief Fixup the after bridge goto datastore.
 * \since 12.0.0
 *
 * \param data After bridge goto data to fixup.
 * \param old_chan The datastore is moving from this channel.
 * \param new_chan The datastore is moving to this channel.
 *
 * \return Nothing
 */
static void after_bridge_goto_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
{
        /* There can be only one.  Discard any already on the new channel. */
        ast_after_bridge_goto_discard(new_chan);
}

static const struct ast_datastore_info after_bridge_goto_info = {
        .type = "after-bridge-goto",
        .destroy = after_bridge_goto_destroy,
        .chan_fixup = after_bridge_goto_fixup,
};

/*!
 * \internal
 * \brief Remove channel goto location after the bridge and return it.
 * \since 12.0.0
 *
 * \param chan Channel to remove after bridge goto location.
 *
 * \retval datastore on success.
 * \retval NULL on error or not found.
 */
static struct ast_datastore *after_bridge_goto_remove(struct ast_channel *chan)
{
        struct ast_datastore *datastore;

        ast_channel_lock(chan);
        datastore = ast_channel_datastore_find(chan, &after_bridge_goto_info, NULL);
        if (datastore && ast_channel_datastore_remove(chan, datastore)) {
                datastore = NULL;
        }
        ast_channel_unlock(chan);

        return datastore;
}

void ast_after_bridge_goto_discard(struct ast_channel *chan)
{
        struct ast_datastore *datastore;

        datastore = after_bridge_goto_remove(chan);
        if (datastore) {
                ast_datastore_free(datastore);
        }
}

int ast_after_bridge_goto_setup(struct ast_channel *chan)
{
        struct ast_datastore *datastore;
        struct after_bridge_goto_ds *after_bridge;
        int goto_failed = -1;

        /* Determine if we are going to setup a dialplan location and where. */
        if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
                /* An async goto has already setup a location. */
                ast_channel_clear_softhangup(chan, AST_SOFTHANGUP_ASYNCGOTO);
                if (!ast_check_hangup(chan)) {
                        goto_failed = 0;
                }
                return goto_failed;
        }

        /* Get after bridge goto datastore. */
        datastore = after_bridge_goto_remove(chan);
        if (!datastore) {
                return goto_failed;
        }

        after_bridge = datastore->data;
        if (after_bridge->run_h_exten) {
                if (ast_exists_extension(chan, after_bridge->context, "h", 1,
                        S_COR(ast_channel_caller(chan)->id.number.valid,
                                ast_channel_caller(chan)->id.number.str, NULL))) {
                        ast_debug(1, "Running after bridge goto h exten %s,h,1\n",
                                ast_channel_context(chan));
                        ast_pbx_h_exten_run(chan, after_bridge->context);
                }
        } else if (!ast_check_hangup(chan)) {
                if (after_bridge->specific) {
                        goto_failed = ast_explicit_goto(chan, after_bridge->context,
                                after_bridge->exten, after_bridge->priority);
                } else if (!ast_strlen_zero(after_bridge->parseable_goto)) {
                        char *context;
                        char *exten;
                        int priority;

                        /* Option F(x) for Bridge(), Dial(), and Queue() */

                        /* Save current dialplan location in case of failure. */
                        context = ast_strdupa(ast_channel_context(chan));
                        exten = ast_strdupa(ast_channel_exten(chan));
                        priority = ast_channel_priority(chan);

                        /* Set current dialplan position to default dialplan position */
                        ast_explicit_goto(chan, after_bridge->context, after_bridge->exten,
                                after_bridge->priority);

                        /* Then perform the goto */
                        goto_failed = ast_parseable_goto(chan, after_bridge->parseable_goto);
                        if (goto_failed) {
                                /* Restore original dialplan location. */
                                ast_channel_context_set(chan, context);
                                ast_channel_exten_set(chan, exten);
                                ast_channel_priority_set(chan, priority);
                        }
                } else {
                        /* Option F() for Bridge(), Dial(), and Queue() */
                        goto_failed = ast_goto_if_exists(chan, after_bridge->context,
                                after_bridge->exten, after_bridge->priority + 1);
                }
                if (!goto_failed) {
                        ast_debug(1, "Setup after bridge goto location to %s,%s,%d.\n",
                                ast_channel_context(chan),
                                ast_channel_exten(chan),
                                ast_channel_priority(chan));
                }
        }

        /* Discard after bridge goto datastore. */
        ast_datastore_free(datastore);

        return goto_failed;
}

void ast_after_bridge_goto_run(struct ast_channel *chan)
{
        int goto_failed;

        goto_failed = ast_after_bridge_goto_setup(chan);
        if (goto_failed || ast_pbx_run(chan)) {
                ast_hangup(chan);
        }
}

/*!
 * \internal
 * \brief Set after bridge goto location of channel.
 * \since 12.0.0
 *
 * \param chan Channel to setup after bridge goto location.
 * \param run_h_exten TRUE if the h exten should be run.
 * \param specific TRUE if the context/exten/priority is exactly specified.
 * \param context Context to goto after bridge.
 * \param exten Exten to goto after bridge. (Could be NULL if run_h_exten)
 * \param priority Priority to goto after bridge.
 * \param parseable_goto User specified goto string. (Could be NULL)
 *
 * \details Add a channel datastore to setup the goto location
 * when the channel leaves the bridge and run a PBX from there.
 *
 * If run_h_exten then execute the h exten found in the given context.
 * Else if specific then goto the given context/exten/priority.
 * Else if parseable_goto then use the given context/exten/priority
 *   as the relative position for the parseable_goto.
 * Else goto the given context/exten/priority+1.
 *
 * \return Nothing
 */
static void __after_bridge_set_goto(struct ast_channel *chan, int run_h_exten, int specific, const char *context, const char *exten, int priority, const char *parseable_goto)
{
        struct ast_datastore *datastore;
        struct after_bridge_goto_ds *after_bridge;

        /* Sanity checks. */
        ast_assert(chan != NULL);
        if (!chan) {
                return;
        }
        if (run_h_exten) {
                ast_assert(run_h_exten && context);
                if (!context) {
                        return;
                }
        } else {
                ast_assert(context && exten && 0 < priority);
                if (!context || !exten || priority < 1) {
                        return;
                }
        }

        /* Create a new datastore. */
        datastore = ast_datastore_alloc(&after_bridge_goto_info, NULL);
        if (!datastore) {
                return;
        }
        after_bridge = ast_calloc(1, sizeof(*after_bridge));
        if (!after_bridge) {
                ast_datastore_free(datastore);
                return;
        }

        /* Initialize it. */
        after_bridge->parseable_goto = ast_strdup(parseable_goto);
        after_bridge->context = ast_strdup(context);
        after_bridge->exten = ast_strdup(exten);
        after_bridge->priority = priority;
        after_bridge->run_h_exten = run_h_exten ? 1 : 0;
        after_bridge->specific = specific ? 1 : 0;
        datastore->data = after_bridge;
        if ((parseable_goto && !after_bridge->parseable_goto)
                || (context && !after_bridge->context)
                || (exten && !after_bridge->exten)) {
                ast_datastore_free(datastore);
                return;
        }

        /* Put it on the channel replacing any existing one. */
        ast_channel_lock(chan);
        ast_after_bridge_goto_discard(chan);
        ast_channel_datastore_add(chan, datastore);
        ast_channel_unlock(chan);
}

void ast_after_bridge_set_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
{
        __after_bridge_set_goto(chan, 0, 1, context, exten, priority, NULL);
}

void ast_after_bridge_set_h(struct ast_channel *chan, const char *context)
{
        __after_bridge_set_goto(chan, 1, 0, context, NULL, 1, NULL);
}

void ast_after_bridge_set_go_on(struct ast_channel *chan, const char *context, const char *exten, int priority, const char *parseable_goto)
{
        char *p_goto;

        if (!ast_strlen_zero(parseable_goto)) {
                p_goto = ast_strdupa(parseable_goto);
                ast_replace_subargument_delimiter(p_goto);
        } else {
                p_goto = NULL;
        }
        __after_bridge_set_goto(chan, 0, 0, context, exten, priority, p_goto);
}

void ast_bridge_notify_masquerade(struct ast_channel *chan)
{
        struct ast_bridge_channel *bridge_channel;
        struct ast_bridge *bridge;

        /* Safely get the bridge_channel pointer for the chan. */
        ast_channel_lock(chan);
        bridge_channel = ast_channel_get_bridge_channel(chan);
        ast_channel_unlock(chan);
        if (!bridge_channel) {
                /* Not in a bridge */
                return;
        }

        ast_bridge_channel_lock_bridge(bridge_channel);
        bridge = bridge_channel->bridge;
        if (bridge_channel == find_bridge_channel(bridge, chan)) {
/* BUGBUG this needs more work.  The channels need to be made compatible again if the formats change. The bridge_channel thread needs to monitor for this case. */
                /* The channel we want to notify is still in a bridge. */
                bridge->v_table->notify_masquerade(bridge, bridge_channel);
                bridge_reconfigured(bridge);
        }
        ast_bridge_unlock(bridge);
        ao2_ref(bridge_channel, -1);
}

/*
 * BUGBUG make ast_bridge_join() require features to be allocated just like ast_bridge_impart() and not expect the struct back.
 *
 * This change is really going to break ConfBridge.  All other
 * users are easily changed.  However, it is needed so the
 * bridging code can manipulate features on all channels
 * consistently no matter how they joined.
 *
 * Need to update the features parameter doxygen when this
 * change is made to be like ast_bridge_impart().
 */
enum ast_bridge_channel_state ast_bridge_join(struct ast_bridge *bridge,
        struct ast_channel *chan,
        struct ast_channel *swap,
        struct ast_bridge_features *features,
        struct ast_bridge_tech_optimizations *tech_args,
        int pass_reference)
{
        struct ast_bridge_channel *bridge_channel;
        enum ast_bridge_channel_state state;

        bridge_channel = bridge_channel_alloc(bridge);
        if (pass_reference) {
                ao2_ref(bridge, -1);
        }
        if (!bridge_channel) {
                state = AST_BRIDGE_CHANNEL_STATE_HANGUP;
                goto join_exit;
        }
/* BUGBUG features cannot be NULL when passed in. When it is changed to allocated we can do like ast_bridge_impart() and allocate one. */
        ast_assert(features != NULL);
        if (!features) {
                ao2_ref(bridge_channel, -1);
                state = AST_BRIDGE_CHANNEL_STATE_HANGUP;
                goto join_exit;
        }
        if (tech_args) {
                bridge_channel->tech_args = *tech_args;
        }

        /* Initialize various other elements of the bridge channel structure that we can't do above */
        ast_channel_lock(chan);
        ast_channel_internal_bridge_channel_set(chan, bridge_channel);
        ast_channel_unlock(chan);
        bridge_channel->thread = pthread_self();
        bridge_channel->chan = chan;
        bridge_channel->swap = swap;
        bridge_channel->features = features;

        bridge_channel_join(bridge_channel);
        state = bridge_channel->state;

        /* Cleanup all the data in the bridge channel after it leaves the bridge. */
        ast_channel_lock(chan);
        ast_channel_internal_bridge_channel_set(chan, NULL);
        ast_channel_unlock(chan);
        bridge_channel->chan = NULL;
        bridge_channel->swap = NULL;
        bridge_channel->features = NULL;

        ao2_ref(bridge_channel, -1);

join_exit:;
/* BUGBUG this is going to cause problems for DTMF atxfer attended bridge between B & C.  Maybe an ast_bridge_join_internal() that does not do the after bridge goto for this case. */
        after_bridge_callback_run(chan);
        if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO)
                && !ast_after_bridge_goto_setup(chan)) {
                /* Claim the after bridge goto is an async goto destination. */
                ast_channel_lock(chan);
                ast_softhangup_nolock(chan, AST_SOFTHANGUP_ASYNCGOTO);
                ast_channel_unlock(chan);
        }
        return state;
}

/*! \brief Thread responsible for imparted bridged channels to be departed */
static void *bridge_channel_depart_thread(void *data)
{
        struct ast_bridge_channel *bridge_channel = data;

        if (bridge_channel->callid) {
                ast_callid_threadassoc_add(bridge_channel->callid);
        }

        bridge_channel_join(bridge_channel);

        /* cleanup */
        bridge_channel->swap = NULL;
        ast_bridge_features_destroy(bridge_channel->features);
        bridge_channel->features = NULL;

        ast_after_bridge_callback_discard(bridge_channel->chan, AST_AFTER_BRIDGE_CB_REASON_DEPART);
        ast_after_bridge_goto_discard(bridge_channel->chan);

        return NULL;
}

/*! \brief Thread responsible for independent imparted bridged channels */
static void *bridge_channel_ind_thread(void *data)
{
        struct ast_bridge_channel *bridge_channel = data;
        struct ast_channel *chan;

        if (bridge_channel->callid) {
                ast_callid_threadassoc_add(bridge_channel->callid);
        }

        bridge_channel_join(bridge_channel);
        chan = bridge_channel->chan;

        /* cleanup */
        ast_channel_lock(chan);
        ast_channel_internal_bridge_channel_set(chan, NULL);
        ast_channel_unlock(chan);
        bridge_channel->chan = NULL;
        bridge_channel->swap = NULL;
        ast_bridge_features_destroy(bridge_channel->features);
        bridge_channel->features = NULL;

        ao2_ref(bridge_channel, -1);

        after_bridge_callback_run(chan);
        ast_after_bridge_goto_run(chan);
        return NULL;
}

int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, int independent)
{
        int res;
        struct ast_bridge_channel *bridge_channel;

        /* Supply an empty features structure if the caller did not. */
        if (!features) {
                features = ast_bridge_features_new();
                if (!features) {
                        return -1;
                }
        }

        /* Try to allocate a structure for the bridge channel */
        bridge_channel = bridge_channel_alloc(bridge);
        if (!bridge_channel) {
                ast_bridge_features_destroy(features);
                return -1;
        }

        /* Setup various parameters */
        ast_channel_lock(chan);
        ast_channel_internal_bridge_channel_set(chan, bridge_channel);
        ast_channel_unlock(chan);
        bridge_channel->chan = chan;
        bridge_channel->swap = swap;
        bridge_channel->features = features;
        bridge_channel->depart_wait = independent ? 0 : 1;
        bridge_channel->callid = ast_read_threadstorage_callid();

        /* Actually create the thread that will handle the channel */
        if (independent) {
                /* Independently imparted channels cannot have a PBX. */
                ast_assert(!ast_channel_pbx(chan));

                res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
                        bridge_channel_ind_thread, bridge_channel);
        } else {
                /* Imparted channels to be departed should not have a PBX either. */
                ast_assert(!ast_channel_pbx(chan));

                res = ast_pthread_create(&bridge_channel->thread, NULL,
                        bridge_channel_depart_thread, bridge_channel);
        }

        if (res) {
                /* cleanup */
                ast_channel_lock(chan);
                ast_channel_internal_bridge_channel_set(chan, NULL);
                ast_channel_unlock(chan);
                bridge_channel->chan = NULL;
                bridge_channel->swap = NULL;
                ast_bridge_features_destroy(bridge_channel->features);
                bridge_channel->features = NULL;

                ao2_ref(bridge_channel, -1);
                return -1;
        }

        return 0;
}

int ast_bridge_depart(struct ast_channel *chan)
{
        struct ast_bridge_channel *bridge_channel;
        int departable;

        ast_channel_lock(chan);
        bridge_channel = ast_channel_internal_bridge_channel(chan);
        departable = bridge_channel && bridge_channel->depart_wait;
        ast_channel_unlock(chan);
        if (!departable) {
                ast_log(LOG_ERROR, "Channel %s cannot be departed.\n",
                        ast_channel_name(chan));
                /*
                 * Should never happen.  It likely means that
                 * ast_bridge_depart() is called by two threads for the same
                 * channel, the channel was never imparted to be departed, or it
                 * has already been departed.
                 */
                ast_assert(0);
                return -1;
        }

        /*
         * We are claiming the reference held by the depart bridge
         * channel thread.
         */

        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);

        /* Wait for the depart thread to die */
        ast_debug(1, "Waiting for %p(%s) bridge thread to die.\n",
                bridge_channel, ast_channel_name(bridge_channel->chan));
        pthread_join(bridge_channel->thread, NULL);

        ast_channel_lock(chan);
        ast_channel_internal_bridge_channel_set(chan, NULL);
        ast_channel_unlock(chan);

        /* We can get rid of the bridge_channel after the depart thread has died. */
        ao2_ref(bridge_channel, -1);
        return 0;
}

int ast_bridge_remove(struct ast_bridge *bridge, struct ast_channel *chan)
{
        struct ast_bridge_channel *bridge_channel;

        ast_bridge_lock(bridge);

        /* Try to find the channel that we want to remove */
        if (!(bridge_channel = find_bridge_channel(bridge, chan))) {
                ast_bridge_unlock(bridge);
                return -1;
        }

        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);

        ast_bridge_unlock(bridge);

        return 0;
}

/*!
 * \internal
 * \brief Point the bridge_channel to a new bridge.
 * \since 12.0.0
 *
 * \param bridge_channel What is to point to a new bridge.
 * \param new_bridge Where the bridge channel should point.
 *
 * \return Nothing
 */
static void bridge_channel_change_bridge(struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
{
        struct ast_bridge *old_bridge;

        ao2_ref(new_bridge, +1);
        ast_bridge_channel_lock(bridge_channel);
        ast_channel_lock(bridge_channel->chan);
        old_bridge = bridge_channel->bridge;
        bridge_channel->bridge = new_bridge;
        ast_channel_internal_bridge_set(bridge_channel->chan, new_bridge);
        ast_channel_unlock(bridge_channel->chan);
        ast_bridge_channel_unlock(bridge_channel);
        ao2_ref(old_bridge, -1);
}

/*!
 * \internal
 * \brief Do the merge of two bridges.
 * \since 12.0.0
 *
 * \param dst_bridge Destination bridge of merge.
 * \param src_bridge Source bridge of merge.
 * \param kick_me Array of channels to kick from the bridges.
 * \param num_kick Number of channels in the kick_me array.
 *
 * \return Nothing
 *
 * \note The two bridges are assumed already locked.
 *
 * This moves the channels in src_bridge into the bridge pointed
 * to by dst_bridge.
 */
static void bridge_merge_do(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick)
{
        struct ast_bridge_channel *bridge_channel;
        unsigned int idx;

        ast_debug(1, "Merging bridge %s into bridge %s\n",
                src_bridge->uniqueid, dst_bridge->uniqueid);

        ast_bridge_publish_merge(dst_bridge, src_bridge);

        /*
         * Move channels from src_bridge over to dst_bridge.
         *
         * We must use AST_LIST_TRAVERSE_SAFE_BEGIN() because
         * bridge_channel_pull() alters the list we are traversing.
         */
        AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) {
                if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                        /*
                         * The channel is already leaving let it leave normally because
                         * pulling it may delete hooks that should run for this channel.
                         */
                        continue;
                }
                if (ast_test_flag(&bridge_channel->features->feature_flags,
                        AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
                        continue;
                }

                if (kick_me) {
                        for (idx = 0; idx < num_kick; ++idx) {
                                if (bridge_channel == kick_me[idx]) {
                                        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                                        break;
                                }
                        }
                }
                bridge_channel_pull(bridge_channel);
                if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                        /*
                         * The channel died as a result of being pulled or it was
                         * kicked.  Leave it pointing to the original bridge.
                         */
                        continue;
                }

                /* Point to new bridge.*/
                bridge_channel_change_bridge(bridge_channel, dst_bridge);

                if (bridge_channel_push(bridge_channel)) {
                        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                }
        }
        AST_LIST_TRAVERSE_SAFE_END;

        if (kick_me) {
                /*
                 * Now we can kick any channels in the dst_bridge without
                 * potentially dissolving the bridge.
                 */
                for (idx = 0; idx < num_kick; ++idx) {
                        bridge_channel = kick_me[idx];
                        ast_bridge_channel_lock(bridge_channel);
                        if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) {
                                ast_bridge_change_state_nolock(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                                bridge_channel_pull(bridge_channel);
                        }
                        ast_bridge_channel_unlock(bridge_channel);
                }
        }

        bridge_reconfigured(dst_bridge);
        bridge_reconfigured(src_bridge);

        ast_debug(1, "Merged bridge %s into bridge %s\n",
                src_bridge->uniqueid, dst_bridge->uniqueid);
}

struct merge_direction {
        /*! Destination merge bridge. */
        struct ast_bridge *dest;
        /*! Source merge bridge. */
        struct ast_bridge *src;
};

/*!
 * \internal
 * \brief Determine which bridge should merge into the other.
 * \since 12.0.0
 *
 * \param bridge1 A bridge for merging
 * \param bridge2 A bridge for merging
 *
 * \note The two bridges are assumed already locked.
 *
 * \return Which bridge merges into which or NULL bridges if cannot merge.
 */
static struct merge_direction bridge_merge_determine_direction(struct ast_bridge *bridge1, struct ast_bridge *bridge2)
{
        struct merge_direction merge = { NULL, NULL };
        int bridge1_priority;
        int bridge2_priority;

        if (!ast_test_flag(&bridge1->feature_flags,
                        AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)
                && !ast_test_flag(&bridge2->feature_flags,
                        AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
                /*
                 * Can merge either way.  Merge to the higher priority merge
                 * bridge.  Otherwise merge to the larger bridge.
                 */
                bridge1_priority = bridge1->v_table->get_merge_priority(bridge1);
                bridge2_priority = bridge2->v_table->get_merge_priority(bridge2);
                if (bridge2_priority < bridge1_priority) {
                        merge.dest = bridge1;
                        merge.src = bridge2;
                } else if (bridge1_priority < bridge2_priority) {
                        merge.dest = bridge2;
                        merge.src = bridge1;
                } else {
                        /* Merge to the larger bridge. */
                        if (bridge2->num_channels <= bridge1->num_channels) {
                                merge.dest = bridge1;
                                merge.src = bridge2;
                        } else {
                                merge.dest = bridge2;
                                merge.src = bridge1;
                        }
                }
        } else if (!ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
                && !ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
                /* Can merge only one way. */
                merge.dest = bridge1;
                merge.src = bridge2;
        } else if (!ast_test_flag(&bridge2->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
                && !ast_test_flag(&bridge1->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
                /* Can merge only one way. */
                merge.dest = bridge2;
                merge.src = bridge1;
        }

        return merge;
}

/*!
 * \internal
 * \brief Merge two bridges together
 * \since 12.0.0
 *
 * \param dst_bridge Destination bridge of merge.
 * \param src_bridge Source bridge of merge.
 * \param merge_best_direction TRUE if don't care about which bridge merges into the other.
 * \param kick_me Array of channels to kick from the bridges.
 * \param num_kick Number of channels in the kick_me array.
 *
 * \note The dst_bridge and src_bridge are assumed already locked.
 *
 * \retval 0 on success
 * \retval -1 on failure
 */
static int bridge_merge_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
{
        struct merge_direction merge;
        struct ast_bridge_channel **kick_them = NULL;

        /* Sanity check. */
        ast_assert(dst_bridge && src_bridge && dst_bridge != src_bridge && (!num_kick || kick_me));

        if (dst_bridge->dissolved || src_bridge->dissolved) {
                ast_debug(1, "Can't merge bridges %s and %s, at least one bridge is dissolved.\n",
                        src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
                || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
                ast_debug(1, "Can't merge bridges %s and %s, masquerade only.\n",
                        src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
                ast_debug(1, "Can't merge bridges %s and %s, merging temporarily inhibited.\n",
                        src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }

        if (merge_best_direction) {
                merge = bridge_merge_determine_direction(dst_bridge, src_bridge);
        } else {
                merge.dest = dst_bridge;
                merge.src = src_bridge;
        }

        if (!merge.dest
                || ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO)
                || ast_test_flag(&merge.src->feature_flags, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM)) {
                ast_debug(1, "Can't merge bridges %s and %s, merging inhibited.\n",
                        src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (merge.src->num_channels < 2) {
                /*
                 * For a two party bridge, a channel may be temporarily removed
                 * from the source bridge or the initial bridge members have not
                 * joined yet.
                 */
                ast_debug(1, "Can't merge bridge %s into bridge %s, not enough channels in source bridge.\n",
                        merge.src->uniqueid, merge.dest->uniqueid);
                return -1;
        }
        if (2 + num_kick < merge.dest->num_channels + merge.src->num_channels
                && !(merge.dest->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX)
                && (!ast_test_flag(&merge.dest->feature_flags, AST_BRIDGE_FLAG_SMART)
                        || !(merge.dest->allowed_capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX))) {
                ast_debug(1, "Can't merge bridge %s into bridge %s, multimix is needed and it cannot be acquired.\n",
                        merge.src->uniqueid, merge.dest->uniqueid);
                return -1;
        }

        if (num_kick) {
                unsigned int num_to_kick = 0;
                unsigned int idx;

                kick_them = ast_alloca(num_kick * sizeof(*kick_them));
                for (idx = 0; idx < num_kick; ++idx) {
                        kick_them[num_to_kick] = find_bridge_channel(merge.src, kick_me[idx]);
                        if (!kick_them[num_to_kick]) {
                                kick_them[num_to_kick] = find_bridge_channel(merge.dest, kick_me[idx]);
                        }
                        if (kick_them[num_to_kick]) {
                                ++num_to_kick;
                        }
                }

                if (num_to_kick != num_kick) {
                        ast_debug(1, "Can't merge bridge %s into bridge %s, at least one kicked channel is not in either bridge.\n",
                                merge.src->uniqueid, merge.dest->uniqueid);
                        return -1;
                }
        }

        bridge_merge_do(merge.dest, merge.src, kick_them, num_kick);
        return 0;
}

int ast_bridge_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, int merge_best_direction, struct ast_channel **kick_me, unsigned int num_kick)
{
        int res;

        /* Sanity check. */
        ast_assert(dst_bridge && src_bridge);

        ast_bridge_lock_both(dst_bridge, src_bridge);
        res = bridge_merge_locked(dst_bridge, src_bridge, merge_best_direction, kick_me, num_kick);
        ast_bridge_unlock(src_bridge);
        ast_bridge_unlock(dst_bridge);
        return res;
}

/*!
 * \internal
 * \brief Move a bridge channel from one bridge to another.
 * \since 12.0.0
 *
 * \param dst_bridge Destination bridge of bridge channel move.
 * \param bridge_channel Channel moving from one bridge to another.
 * \param attempt_recovery TRUE if failure attempts to push channel back into original bridge.
 *
 * \note The dst_bridge and bridge_channel->bridge are assumed already locked.
 *
 * \retval 0 on success.
 * \retval -1 on failure.
 */
static int bridge_move_do(struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery)
{
        struct ast_bridge *orig_bridge;
        int was_in_bridge;
        int res = 0;

/* BUGBUG need bridge move stasis event and a success/fail event. */
        if (bridge_channel->swap) {
                ast_debug(1, "Moving %p(%s) into bridge %s swapping with %s\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid,
                        ast_channel_name(bridge_channel->swap));
        } else {
                ast_debug(1, "Moving %p(%s) into bridge %s\n",
                        bridge_channel, ast_channel_name(bridge_channel->chan), dst_bridge->uniqueid);
        }

        orig_bridge = bridge_channel->bridge;
        was_in_bridge = bridge_channel->in_bridge;

        bridge_channel_pull(bridge_channel);
        if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                /*
                 * The channel died as a result of being pulled.  Leave it
                 * pointing to the original bridge.
                 */
                bridge_reconfigured(orig_bridge);
                return -1;
        }

        /* Point to new bridge.*/
        ao2_ref(orig_bridge, +1);/* Keep a ref in case the push fails. */
        bridge_channel_change_bridge(bridge_channel, dst_bridge);

        if (bridge_channel_push(bridge_channel)) {
                /* Try to put the channel back into the original bridge. */
                if (attempt_recovery && was_in_bridge) {
                        /* Point back to original bridge. */
                        bridge_channel_change_bridge(bridge_channel, orig_bridge);

                        if (bridge_channel_push(bridge_channel)) {
                                ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                        }
                } else {
                        ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP);
                }
                res = -1;
        }

        bridge_reconfigured(dst_bridge);
        bridge_reconfigured(orig_bridge);
        ao2_ref(orig_bridge, -1);
        return res;
}

/*!
 * \internal
 * \brief Move a channel from one bridge to another.
 * \since 12.0.0
 *
 * \param dst_bridge Destination bridge of bridge channel move.
 * \param src_bridge Source bridge of bridge channel move.
 * \param chan Channel to move.
 * \param swap Channel to replace in dst_bridge.
 * \param attempt_recovery TRUE if failure attempts to push channel back into original bridge.
 *
 * \note The dst_bridge and src_bridge are assumed already locked.
 *
 * \retval 0 on success.
 * \retval -1 on failure.
 */
static int bridge_move_locked(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
{
        struct ast_bridge_channel *bridge_channel;

        if (dst_bridge->dissolved || src_bridge->dissolved) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, at least one bridge is dissolved.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (ast_test_flag(&dst_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)
                || ast_test_flag(&src_bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, masquerade only.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (dst_bridge->inhibit_merge || src_bridge->inhibit_merge) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, temporarily inhibited.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }

        bridge_channel = find_bridge_channel(src_bridge, chan);
        if (!bridge_channel) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel not in bridge.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel leaving bridge.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }
        if (ast_test_flag(&bridge_channel->features->feature_flags,
                AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) {
                ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, channel immovable.\n",
                        ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid);
                return -1;
        }

        if (swap) {
                struct ast_bridge_channel *bridge_channel_swap;

                bridge_channel_swap = find_bridge_channel(dst_bridge, swap);
                if (!bridge_channel_swap) {
                        ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s not in bridge.\n",
                                ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
                                ast_channel_name(swap));
                        return -1;
                }
                if (bridge_channel_swap->state != AST_BRIDGE_CHANNEL_STATE_WAIT) {
                        ast_debug(1, "Can't move channel %s from bridge %s into bridge %s, swap channel %s leaving bridge.\n",
                                ast_channel_name(chan), src_bridge->uniqueid, dst_bridge->uniqueid,
                                ast_channel_name(swap));
                        return -1;
                }
        }

        bridge_channel->swap = swap;
        return bridge_move_do(dst_bridge, bridge_channel, attempt_recovery);
}

int ast_bridge_move(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_channel *chan, struct ast_channel *swap, int attempt_recovery)
{
        int res;

        ast_bridge_lock_both(dst_bridge, src_bridge);
        res = bridge_move_locked(dst_bridge, src_bridge, chan, swap, attempt_recovery);
        ast_bridge_unlock(src_bridge);
        ast_bridge_unlock(dst_bridge);
        return res;
}

struct ast_bridge_channel *ast_bridge_channel_peer(struct ast_bridge_channel *bridge_channel)
{
        struct ast_bridge *bridge = bridge_channel->bridge;
        struct ast_bridge_channel *other = NULL;

        if (bridge_channel->in_bridge && bridge->num_channels == 2) {
                AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
                        if (other != bridge_channel) {
                                break;
                        }
                }
        }

        return other;
}

static int bridge_allows_optimization(struct ast_bridge *bridge)
{
        return !(bridge->inhibit_merge
                || bridge->dissolved
                || ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY));
}

static int bridge_channel_allows_optimization(struct ast_bridge_channel *bridge_channel)
{
        return bridge_channel->in_bridge
                && AST_LIST_EMPTY(&bridge_channel->wr_queue);
}

/*!
 * \internal
 * \brief Lock the unreal channel stack for chan and prequalify it.
 * \since 12.0.0
 *
 * \param chan Unreal channel writing a frame into the channel driver.
 *
 * \note It is assumed that chan is already locked.
 *
 * \retval bridge on success with bridge and bridge_channel locked.
 * \retval NULL if cannot do optimization now.
 */
static struct ast_bridge *optimize_lock_chan_stack(struct ast_channel *chan)
{
        struct ast_bridge *bridge;
        struct ast_bridge_channel *bridge_channel;

        if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
                return NULL;
        }
        bridge_channel = ast_channel_internal_bridge_channel(chan);
        if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
                return NULL;
        }
        bridge = bridge_channel->bridge;
        if (bridge_channel->activity != AST_BRIDGE_CHANNEL_THREAD_SIMPLE
                || bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT
                || ast_bridge_trylock(bridge)) {
                ast_bridge_channel_unlock(bridge_channel);
                return NULL;
        }
        if (!bridge_channel_allows_optimization(bridge_channel) ||
                        !bridge_allows_optimization(bridge)) {
                ast_bridge_unlock(bridge);
                ast_bridge_channel_unlock(bridge_channel);
                return NULL;
        }
        return bridge;
}

/*!
 * \internal
 * \brief Lock the unreal channel stack for peer and prequalify it.
 * \since 12.0.0
 *
 * \param peer Other unreal channel in the pair.
 *
 * \retval bridge on success with bridge, bridge_channel, and peer locked.
 * \retval NULL if cannot do optimization now.
 */
static struct ast_bridge *optimize_lock_peer_stack(struct ast_channel *peer)
{
        struct ast_bridge *bridge;
        struct ast_bridge_channel *bridge_channel;

        if (ast_channel_trylock(peer)) {
                return NULL;
        }
        if (!AST_LIST_EMPTY(ast_channel_readq(peer))) {
                ast_channel_unlock(peer);
                return NULL;
        }
        bridge_channel = ast_channel_internal_bridge_channel(peer);
        if (!bridge_channel || ast_bridge_channel_trylock(bridge_channel)) {
                ast_channel_unlock(peer);
                return NULL;
        }
        bridge = bridge_channel->bridge;
        if (bridge_channel->activity != AST_BRIDGE_CHANNEL_THREAD_IDLE
                || bridge_channel->state != AST_BRIDGE_CHANNEL_STATE_WAIT
                || ast_bridge_trylock(bridge)) {
                ast_bridge_channel_unlock(bridge_channel);
                ast_channel_unlock(peer);
                return NULL;
        }
        if (!bridge_allows_optimization(bridge) ||
                        !bridge_channel_allows_optimization(bridge_channel)) {
                ast_bridge_unlock(bridge);
                ast_bridge_channel_unlock(bridge_channel);
                ast_channel_unlock(peer);
                return NULL;
        }
        return bridge;
}

/*!
 * \internal
 * \brief Indicates allowability of a swap optimization
 */
enum bridge_allow_swap {
        /*! Bridges cannot allow for a swap optimization to occur */
        SWAP_PROHIBITED,
        /*! Bridge swap optimization can occur into the chan_bridge */
 &n