From cafc1158961f28ad54ebcdc5e042bf8094cbc620 Mon Sep 17 00:00:00 2001 From: Matthew Jordan Date: Thu, 25 Jul 2013 04:06:32 +0000 Subject: A great big renaming patch This patch renames the bridging* files to bridge*. This may seem pedantic and silly, but it fits better in line with current Asterisk naming conventions: * channel is not "channeling" * monitor is not "monitoring" etc. A bridge is an object. It is a first class citizen in Asterisk. "Bridging" is the act of using a bridge on a set of channels - and the API that fulfills that role is more than just the action. (closes issue ASTERISK-22130) git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@395378 65c4cc65-6c06-0410-ace0-fbb531ad65f3 --- main/bridging.c | 4831 ------------------------------------------------------- 1 file changed, 4831 deletions(-) delete mode 100644 main/bridging.c (limited to 'main/bridging.c') diff --git a/main/bridging.c b/main/bridging.c deleted file mode 100644 index 1e1e6c763..000000000 --- a/main/bridging.c +++ /dev/null @@ -1,4831 +0,0 @@ -/* - * Asterisk -- An open source telephony toolkit. - * - * Copyright (C) 2007 - 2009, Digium, Inc. - * - * Joshua Colp - * - * 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 Bridging API - * - * \author Joshua Colp - */ - -/*** MODULEINFO - core - ***/ - -#include "asterisk.h" - -ASTERISK_FILE_VERSION(__FILE__, "$Revision$") - -#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_internal.h" -#include "asterisk/bridging_channel_internal.h" -#include "asterisk/bridging_basic.h" -#include "asterisk/bridging_technology.h" -#include "asterisk/bridging_channel.h" -#include "asterisk/bridging_after.h" -#include "asterisk/stasis_bridging.h" -#include "asterisk/stasis_channels.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" -#include "asterisk/core_unreal.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); - -/*! 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 ast_bridge_hook_callback 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; -} - -/*! - * \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; -} - -/*! - * \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 - */ -void bridge_dissolve(struct ast_bridge *bridge) -{ - struct ast_bridge_channel *bridge_channel; - struct ast_frame action = { - .frametype = AST_FRAME_BRIDGE_ACTION, - .subclass.integer = BRIDGE_CHANNEL_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_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - } - - /* Must defer dissolving bridge because it is already locked. */ - ast_bridge_queue_action(bridge, &action); -} - -/*! - * \internal - * \brief Check if a bridge should dissolve because of a stolen channel and do it. - * \since 12.0.0 - * - * \param bridge Bridge to check. - * \param bridge_channel Stolen channel causing the check. It is not in the bridge to check and may be in another bridge. - * - * \note On entry, bridge and bridge_channel->bridge are already locked. - * - * \return Nothing - */ -static void bridge_dissolve_check_stolen(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) -{ - if (bridge->dissolved) { - return; - } - - if (bridge_channel->features->usable - && ast_test_flag(&bridge_channel->features->feature_flags, - AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP)) { - /* The stolen channel controlled the bridge it was stolen from. */ - bridge_dissolve(bridge); - return; - } - if (bridge->num_channels < 2 - && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)) { - /* - * The stolen channel has not left enough channels to keep the - * bridge alive. Assume the stolen channel hung up. - */ - bridge_dissolve(bridge); - return; - } -} - -/*! - * \internal - * \brief Update connected line information after a bridge has been reconfigured. - * - * \param bridge The bridge itself. - * - * \return Nothing - */ -static void bridge_reconfigured_connected_line_update(struct ast_bridge *bridge) -{ - struct ast_party_connected_line connected; - struct ast_bridge_channel *bridge_channel = AST_LIST_FIRST(&bridge->channels), *peer; - unsigned char data[1024]; - size_t datalen; - - if (!bridge_channel || - !(bridge->technology->capabilities & (AST_BRIDGE_CAPABILITY_1TO1MIX | AST_BRIDGE_CAPABILITY_NATIVE)) || - !(peer = ast_bridge_channel_peer(bridge_channel)) || - ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE) || - ast_test_flag(ast_channel_flags(peer->chan), AST_FLAG_ZOMBIE) || - ast_check_hangup_locked(bridge_channel->chan) || - ast_check_hangup_locked(peer->chan)) { - return; - } - - ast_party_connected_line_init(&connected); - - ast_channel_lock(bridge_channel->chan); - ast_connected_line_copy_from_caller(&connected, ast_channel_caller(bridge_channel->chan)); - ast_channel_unlock(bridge_channel->chan); - - if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) { - ast_bridge_channel_queue_control_data(peer, AST_CONTROL_CONNECTED_LINE, data, datalen); - } - - ast_channel_lock(peer->chan); - ast_connected_line_copy_from_caller(&connected, ast_channel_caller(peer->chan)); - ast_channel_unlock(peer->chan); - - if ((datalen = ast_connected_line_build_data(data, sizeof(data), &connected, NULL)) != (size_t) -1) { - ast_bridge_channel_queue_control_data(bridge_channel, AST_CONTROL_CONNECTED_LINE, data, datalen); - } - - ast_party_connected_line_free(&connected); -} - -/*! - * \internal - * \brief Complete joining a channel to the bridge. - * \since 12.0.0 - * - * \param bridge What to operate upon. - * \param bridge_channel What is joining the bridge technology. - * - * \note On entry, bridge is already locked. - * - * \return Nothing - */ -static void bridge_channel_complete_join(struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) -{ - /* 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 = 1; - return; - } - - bridge_channel->just_joined = 0; -} - -/*! - * \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; - } - bridge_channel_complete_join(bridge, bridge_channel); - } -} - -/*! \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 BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY: - ast_bridge_unlock(bridge); - bridge_tech_deferred_destroy(bridge, action); - ast_bridge_lock(bridge); - break; - case BRIDGE_CHANNEL_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 struct stasis_message *create_bridge_snapshot_message(struct ast_bridge *bridge) -{ - RAII_VAR(struct ast_bridge_snapshot *, snapshot, NULL, ao2_cleanup); - - snapshot = ast_bridge_snapshot_create(bridge); - if (!snapshot) { - return NULL; - } - - return stasis_message_create(ast_bridge_snapshot_type(), snapshot); -} - -static void destroy_bridge(void *obj) -{ - struct ast_bridge *bridge = obj; - - ast_debug(1, "Bridge %s: actually destroying %s bridge, nobody wants it anymore\n", - bridge->uniqueid, bridge->v_table->name); - - if (bridge->construction_completed) { - RAII_VAR(struct stasis_message *, clear_msg, NULL, ao2_cleanup); - - clear_msg = create_bridge_snapshot_message(bridge); - if (clear_msg) { - RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup); - - msg = stasis_cache_clear_create(clear_msg); - 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 stop\n", - bridge->uniqueid, bridge->technology->name); - if (bridge->technology->stop) { - ast_bridge_lock(bridge); - bridge->technology->stop(bridge); - ast_bridge_unlock(bridge); - } - 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 *bridge_register(struct ast_bridge *bridge) -{ - if (bridge) { - bridge->construction_completed = 1; - ast_bridge_publish_state(bridge); - if (!ao2_link(bridges, bridge)) { - ast_bridge_destroy(bridge); - bridge = NULL; - } - } - return bridge; -} - -struct ast_bridge *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 : ""); - ast_assert(0); - return NULL; - } - - bridge = ao2_alloc(size, destroy_bridge); - if (bridge) { - bridge->v_table = v_table; - } - return bridge; -} - -struct ast_bridge *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_log(LOG_WARNING, "Bridge %s: Could not create class %s. No technology to support it.\n", - self->uniqueid, self->v_table->name); - 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_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n", - self->uniqueid, self->technology->name); - ao2_ref(self, -1); - return NULL; - } - ast_debug(1, "Bridge %s: calling %s technology start\n", - self->uniqueid, self->technology->name); - if (self->technology->start && self->technology->start(self)) { - ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\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) -{ - ast_bridge_features_remove(bridge_channel->features, AST_BRIDGE_HOOK_REMOVE_ON_PULL); -} - -/*! - * \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 = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table); - bridge = bridge_base_init(bridge, capabilities, flags); - bridge = 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 = BRIDGE_CHANNEL_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_verb(4, "Bridge %s: switching from %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; - } - - ast_debug(1, "Bridge %s: calling %s technology stop\n", - dummy_bridge.uniqueid, old_technology->name); - if (old_technology->stop) { - old_technology->stop(&dummy_bridge); - } - - /* - * Move existing channels over to the new technology and - * complete joining any new channels to the bridge. - */ - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - if (!bridge_channel->just_joined) { - /* Take existing channel 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); - } - } - - /* Add any new channels or re-add an existing channel to the bridge. */ - bridge_channel_complete_join(bridge, bridge_channel); - } - - ast_debug(1, "Bridge %s: calling %s technology start\n", - bridge->uniqueid, new_technology->name); - if (new_technology->start && new_technology->start(bridge)) { - ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n", - bridge->uniqueid, 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", - dummy_bridge.uniqueid, old_technology->name); - bridge_queue_action_nodup(bridge, deferred_action); - } else { - ast_debug(1, "Bridge %s: calling %s technology destructor\n", - dummy_bridge.uniqueid, old_technology->name); - ast_module_unref(old_technology->mod); - } - - return 0; -} - -/*! - * \internal - * \brief Bridge channel to check if a BRIDGE_PLAY_SOUND needs to be played. - * \since 12.0.0 - * - * \param bridge_channel What to check. - * - * \return Nothing - */ -static void check_bridge_play_sound(struct ast_bridge_channel *bridge_channel) -{ - const char *play_file; - - ast_channel_lock(bridge_channel->chan); - play_file = pbx_builtin_getvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND"); - if (!ast_strlen_zero(play_file)) { - play_file = ast_strdupa(play_file); - pbx_builtin_setvar_helper(bridge_channel->chan, "BRIDGE_PLAY_SOUND", NULL); - } else { - play_file = NULL; - } - ast_channel_unlock(bridge_channel->chan); - - if (play_file) { - ast_bridge_channel_queue_playfile(bridge_channel, NULL, play_file, NULL); - } -} - -/*! - * \internal - * \brief Check for any BRIDGE_PLAY_SOUND channel variables in the bridge. - * \since 12.0.0 - * - * \param bridge What to operate on. - * - * \note On entry, the bridge is already locked. - * - * \return Nothing - */ -static void check_bridge_play_sounds(struct ast_bridge *bridge) -{ - struct ast_bridge_channel *bridge_channel; - - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - check_bridge_play_sound(bridge_channel); - } -} - -static void update_bridge_vars_set(struct ast_channel *chan, const char *name, const char *pvtid) -{ - pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name); - pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid); -} - -/*! - * \internal - * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a 2 party bridge. - * \since 12.0.0 - * - * \param c0 Party of the first part. - * \param c1 Party of the second part. - * - * \note On entry, the bridge is already locked. - * \note The bridge is expected to have exactly two parties. - * - * \return Nothing - */ -static void set_bridge_peer_vars_2party(struct ast_channel *c0, struct ast_channel *c1) -{ - const char *c0_name; - const char *c1_name; - const char *c0_pvtid = NULL; - const char *c1_pvtid = NULL; -#define UPDATE_BRIDGE_VARS_GET(chan, name, pvtid) \ - do { \ - name = ast_strdupa(ast_channel_name(chan)); \ - if (ast_channel_tech(chan)->get_pvt_uniqueid) { \ - pvtid = ast_strdupa(ast_channel_tech(chan)->get_pvt_uniqueid(chan)); \ - } \ - } while (0) - - ast_channel_lock(c1); - UPDATE_BRIDGE_VARS_GET(c1, c1_name, c1_pvtid); - ast_channel_unlock(c1); - - ast_channel_lock(c0); - update_bridge_vars_set(c0, c1_name, c1_pvtid); - UPDATE_BRIDGE_VARS_GET(c0, c0_name, c0_pvtid); - ast_channel_unlock(c0); - - ast_channel_lock(c1); - update_bridge_vars_set(c1, c0_name, c0_pvtid); - ast_channel_unlock(c1); -} - -/*! - * \internal - * \brief Fill the BRIDGEPEER value buffer with a comma separated list of channel names. - * \since 12.0.0 - * - * \param buf Buffer to fill. The caller must guarantee the buffer is large enough. - * \param cur_idx Which index into names[] to skip. - * \param names Channel names to put in the buffer. - * \param num_names Number of names in the array. - * - * \return Nothing - */ -static void fill_bridgepeer_buf(char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names) -{ - int need_separator = 0; - unsigned int idx; - const char *src; - char *pos; - - pos = buf; - for (idx = 0; idx < num_names; ++idx) { - if (idx == cur_idx) { - continue; - } - - if (need_separator) { - *pos++ = ','; - } - need_separator = 1; - - /* Copy name into buffer. */ - src = names[idx]; - while (*src) { - *pos++ = *src++; - } - } - *pos = '\0'; -} - -/*! - * \internal - * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a multi-party bridge. - * \since 12.0.0 - * - * \param bridge What to operate on. - * - * \note On entry, the bridge is already locked. - * \note The bridge is expected to have more than two parties. - * - * \return Nothing - */ -static void set_bridge_peer_vars_multiparty(struct ast_bridge *bridge) -{ -/* - * Set a maximum number of channel names for the BRIDGEPEER - * list. The plus one is for the current channel which is not - * put in the list. - */ -#define MAX_BRIDGEPEER_CHANS (10 + 1) - - unsigned int idx; - unsigned int num_names; - unsigned int len; - const char **names; - char *buf; - struct ast_bridge_channel *bridge_channel; - - /* Get first MAX_BRIDGEPEER_CHANS channel names. */ - num_names = MIN(bridge->num_channels, MAX_BRIDGEPEER_CHANS); - names = ast_alloca(num_names * sizeof(*names)); - idx = 0; - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - if (num_names <= idx) { - break; - } - ast_channel_lock(bridge_channel->chan); - names[idx++] = ast_strdupa(ast_channel_name(bridge_channel->chan)); - ast_channel_unlock(bridge_channel->chan); - } - - /* Determine maximum buf size needed. */ - len = num_names; - for (idx = 0; idx < num_names; ++idx) { - len += strlen(names[idx]); - } - buf = ast_alloca(len); - - /* Set the bridge channel variables. */ - idx = 0; - buf[0] = '\0'; - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - if (idx < num_names) { - fill_bridgepeer_buf(buf, idx, names, num_names); - } - ++idx; - - ast_channel_lock(bridge_channel->chan); - update_bridge_vars_set(bridge_channel->chan, buf, NULL); - ast_channel_unlock(bridge_channel->chan); - } -} - -/*! - * \internal - * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in a holding bridge. - * \since 12.0.0 - * - * \param bridge What to operate on. - * - * \note On entry, the bridge is already locked. - * - * \return Nothing - */ -static void set_bridge_peer_vars_holding(struct ast_bridge *bridge) -{ - struct ast_bridge_channel *bridge_channel; - - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - ast_channel_lock(bridge_channel->chan); - update_bridge_vars_set(bridge_channel->chan, NULL, NULL); - ast_channel_unlock(bridge_channel->chan); - } -} - -/*! - * \internal - * \brief Set BRIDGEPEER and BRIDGEPVTCALLID channel variables in the bridge. - * \since 12.0.0 - * - * \param bridge What to operate on. - * - * \note On entry, the bridge is already locked. - * - * \return Nothing - */ -static void set_bridge_peer_vars(struct ast_bridge *bridge) -{ - if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_HOLDING) { - set_bridge_peer_vars_holding(bridge); - return; - } - if (bridge->num_channels < 2) { - return; - } - if (bridge->num_channels == 2) { - set_bridge_peer_vars_2party(AST_LIST_FIRST(&bridge->channels)->chan, - AST_LIST_LAST(&bridge->channels)->chan); - } else { - set_bridge_peer_vars_multiparty(bridge); - } -} - -void bridge_reconfigured(struct ast_bridge *bridge, unsigned int colp_update) -{ - 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); - - if (bridge->dissolved) { - return; - } - check_bridge_play_sounds(bridge); - set_bridge_peer_vars(bridge); - ast_bridge_publish_state(bridge); - - if (colp_update) { - bridge_reconfigured_connected_line_update(bridge); - } -} - -struct ast_bridge_channel *bridge_find_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; -} - -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 == bridge_find_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, 1); - } - 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 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 bridge_channel_state state; - - bridge_channel = bridge_channel_internal_alloc(bridge); - if (pass_reference) { - ao2_ref(bridge, -1); - } - if (!bridge_channel) { - state = BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE; - 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 = BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE; - 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_internal_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. */ - ast_bridge_run_after_callback(chan); - if (!(ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) - && !ast_bridge_setup_after_goto(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_internal_join(bridge_channel); - - /* cleanup */ - bridge_channel->swap = NULL; - ast_bridge_features_destroy(bridge_channel->features); - bridge_channel->features = NULL; - - ast_bridge_discard_after_callback(bridge_channel->chan, AST_BRIDGE_AFTER_CB_REASON_DEPART); - ast_bridge_discard_after_goto(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_internal_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); - - ast_bridge_run_after_callback(chan); - ast_bridge_run_after_goto(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_internal_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_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - - /* 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 = bridge_find_channel(bridge, chan))) { - ast_bridge_unlock(bridge); - return -1; - } - - ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - - 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); -} - -void bridge_do_merge(struct ast_bridge *dst_bridge, struct ast_bridge *src_bridge, struct ast_bridge_channel **kick_me, unsigned int num_kick, - unsigned int optimized) -{ - 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_internal_pull() alters the list we are traversing. - */ - AST_LIST_TRAVERSE_SAFE_BEGIN(&src_bridge->channels, bridge_channel, entry) { - if (bridge_channel->state != 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_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - break; - } - } - } - bridge_channel_internal_pull(bridge_channel); - if (bridge_channel->state != 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_internal_push(bridge_channel)) { - ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - } - } - 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 == BRIDGE_CHANNEL_STATE_WAIT) { - ast_bridge_channel_leave_bridge_nolock(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - bridge_channel_internal_pull(bridge_channel); - } - ast_bridge_channel_unlock(bridge_channel); - } - } - - bridge_reconfigured(dst_bridge, !optimized); - bridge_reconfigured(src_bridge, !optimized); - - 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] = bridge_find_channel(merge.src, kick_me[idx]); - if (!kick_them[num_to_kick]) { - kick_them[num_to_kick] = bridge_find_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_do_merge(merge.dest, merge.src, kick_them, num_kick, 0); - 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; -} - -int bridge_do_move(struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery, - unsigned int optimized) -{ - 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_internal_pull(bridge_channel); - if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) { - /* - * The channel died as a result of being pulled. Leave it - * pointing to the original bridge. - */ - bridge_reconfigured(orig_bridge, 0); - 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_internal_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_internal_push(bridge_channel)) { - ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - } - } else { - ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - } - res = -1; - } - - bridge_reconfigured(dst_bridge, !optimized); - bridge_reconfigured(orig_bridge, !optimized); - 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 = bridge_find_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 != 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 = bridge_find_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 != 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_do_move(dst_bridge, bridge_channel, attempt_recovery, 0); -} - -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; -} - -int ast_bridge_add_channel(struct ast_bridge *bridge, struct ast_channel *chan, - struct ast_bridge_features *features, int play_tone, const char *xfersound) -{ - RAII_VAR(struct ast_bridge *, chan_bridge, NULL, ao2_cleanup); - RAII_VAR(struct ast_channel *, yanked_chan, NULL, ao2_cleanup); - - ast_channel_lock(chan); - chan_bridge = ast_channel_get_bridge(chan); - ast_channel_unlock(chan); - - if (chan_bridge) { - RAII_VAR(struct ast_bridge_channel *, bridge_channel, NULL, ao2_cleanup); - - ast_bridge_lock_both(bridge, chan_bridge); - bridge_channel = bridge_find_channel(chan_bridge, chan); - if (bridge_move_locked(bridge, chan_bridge, chan, NULL, 1)) { - ast_bridge_unlock(chan_bridge); - ast_bridge_unlock(bridge); - return -1; - } - - /* - * bridge_move_locked() will implicitly ensure that - * bridge_channel is not NULL. - */ - ast_assert(bridge_channel != NULL); - - /* - * Additional checks if the channel we just stole dissolves the - * original bridge. - */ - bridge_dissolve_check_stolen(chan_bridge, bridge_channel); - ast_bridge_unlock(chan_bridge); - ast_bridge_unlock(bridge); - - /* The channel was in a bridge so it is not getting any new features. */ - ast_bridge_features_destroy(features); - } else { - /* Slightly less easy case. We need to yank channel A from - * where he currently is and impart him into our bridge. - */ - yanked_chan = ast_channel_yank(chan); - if (!yanked_chan) { - ast_log(LOG_WARNING, "Could not gain control of channel %s\n", ast_channel_name(chan)); - return -1; - } - if (ast_channel_state(yanked_chan) != AST_STATE_UP) { - ast_answer(yanked_chan); - } - ast_channel_ref(yanked_chan); - if (ast_bridge_impart(bridge, yanked_chan, NULL, features, 1)) { - ast_log(LOG_WARNING, "Could not add %s to the bridge\n", ast_channel_name(chan)); - ast_hangup(yanked_chan); - return -1; - } - } - - if (play_tone && !ast_strlen_zero(xfersound)) { - struct ast_channel *play_chan = yanked_chan ?: chan; - RAII_VAR(struct ast_bridge_channel *, play_bridge_channel, NULL, ao2_cleanup); - - ast_channel_lock(play_chan); - play_bridge_channel = ast_channel_get_bridge_channel(play_chan); - ast_channel_unlock(play_chan); - - if (!play_bridge_channel) { - ast_log(LOG_WARNING, "Unable to play tone for channel %s. No longer in a bridge.\n", - ast_channel_name(play_chan)); - } else { - ast_bridge_channel_queue_playfile(play_bridge_channel, NULL, xfersound, NULL); - } - } - return 0; -} - -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)); -} - -/*! - * \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; - } - if (ast_channel_has_audio_frame_or_monitor(chan)) { - /* Channel has an active monitor, audiohook, or framehook. */ - 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 != BRIDGE_CHANNEL_THREAD_SIMPLE - || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT - || ast_bridge_trylock(bridge)) { - ast_bridge_channel_unlock(bridge_channel); - return NULL; - } - if (!bridge_channel_internal_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; - } - if (ast_channel_has_audio_frame_or_monitor(peer)) { - /* Peer has an active monitor, audiohook, or framehook. */ - 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 != BRIDGE_CHANNEL_THREAD_IDLE - || bridge_channel->state != 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_internal_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 */ - SWAP_TO_CHAN_BRIDGE, - /*! Bridge swap optimization can occur into the peer_bridge */ - SWAP_TO_PEER_BRIDGE, -}; - -/*! - * \internal - * \brief Determine if two bridges allow for swap optimization to occur - * - * \param chan_bridge First bridge being tested - * \param peer_bridge Second bridge being tested - * \return Allowability of swap optimization - */ -static enum bridge_allow_swap bridges_allow_swap_optimization(struct ast_bridge *chan_bridge, - struct ast_bridge *peer_bridge) -{ - int chan_priority; - int peer_priority; - - if (!ast_test_flag(&chan_bridge->feature_flags, - AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | - AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) - && !ast_test_flag(&peer_bridge->feature_flags, - AST_BRIDGE_FLAG_SWAP_INHIBIT_TO | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | - AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY)) { - /* - * Can swap either way. Swap to the higher priority merge - * bridge. - */ - chan_priority = chan_bridge->v_table->get_merge_priority(chan_bridge); - peer_priority = peer_bridge->v_table->get_merge_priority(peer_bridge); - if (chan_bridge->num_channels == 2 - && chan_priority <= peer_priority) { - return SWAP_TO_PEER_BRIDGE; - } else if (peer_bridge->num_channels == 2 - && peer_priority <= chan_priority) { - return SWAP_TO_CHAN_BRIDGE; - } - } else if (chan_bridge->num_channels == 2 - && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) - && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) { - /* Can swap optimize only one way. */ - return SWAP_TO_PEER_BRIDGE; - } else if (peer_bridge->num_channels == 2 - && !ast_test_flag(&peer_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) - && !ast_test_flag(&chan_bridge->feature_flags, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO)) { - /* Can swap optimize only one way. */ - return SWAP_TO_CHAN_BRIDGE; - } - - return SWAP_PROHIBITED; -} - -/*! - * \internal - * \brief Check and attempt to swap optimize out the unreal channels. - * \since 12.0.0 - * - * \param chan_bridge - * \param chan_bridge_channel - * \param peer_bridge - * \param peer_bridge_channel - * \param pvt Unreal data containing callbacks to call if the optimization actually - * happens - * - * \retval 1 if unreal channels failed to optimize out. - * \retval 0 if unreal channels were not optimized out. - * \retval -1 if unreal channels were optimized out. - */ -static int try_swap_optimize_out(struct ast_bridge *chan_bridge, - struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge, - struct ast_bridge_channel *peer_bridge_channel, - struct ast_unreal_pvt *pvt) -{ - struct ast_bridge *dst_bridge; - struct ast_bridge_channel *dst_bridge_channel; - struct ast_bridge_channel *src_bridge_channel; - struct ast_bridge_channel *other; - int res = 1; - - switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) { - case SWAP_TO_CHAN_BRIDGE: - dst_bridge = chan_bridge; - dst_bridge_channel = chan_bridge_channel; - src_bridge_channel = peer_bridge_channel; - break; - case SWAP_TO_PEER_BRIDGE: - dst_bridge = peer_bridge; - dst_bridge_channel = peer_bridge_channel; - src_bridge_channel = chan_bridge_channel; - break; - case SWAP_PROHIBITED: - default: - return 0; - } - - other = ast_bridge_channel_peer(src_bridge_channel); - if (other && other->state == BRIDGE_CHANNEL_STATE_WAIT) { - ast_verb(3, "Move-swap optimizing %s <-- %s.\n", - ast_channel_name(dst_bridge_channel->chan), - ast_channel_name(other->chan)); - - if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks - && pvt->callbacks->optimization_started) { - pvt->callbacks->optimization_started(pvt); - ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN); - } - other->swap = dst_bridge_channel->chan; - if (!bridge_do_move(dst_bridge, other, 1, 1)) { - ast_bridge_channel_leave_bridge(src_bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - res = -1; - if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) { - pvt->callbacks->optimization_finished(pvt); - } - } - } - return res; -} - -/*! - * \internal - * \brief Indicates allowability of a merge optimization - */ -enum bridge_allow_merge { - /*! Bridge properties prohibit merge optimization */ - MERGE_PROHIBITED, - /*! Merge optimization cannot occur because the source bridge has too few channels */ - MERGE_NOT_ENOUGH_CHANNELS, - /*! Merge optimization cannot occur because multimix capability could not be requested */ - MERGE_NO_MULTIMIX, - /*! Merge optimization allowed between bridges */ - MERGE_ALLOWED, -}; - -/*! - * \internal - * \brief Determines allowability of a merge optimization - * - * \note The merge output parameter is undefined if MERGE_PROHIBITED is returned. For success - * and other failure returns, a merge direction was determined, and the parameter is safe to - * access. - * - * \param chan_bridge First bridge being tested - * \param peer_bridge Second bridge being tested - * \param num_kick_channels The number of channels to remove from the bridges during merging - * \param[out] merge Indicates the recommended direction for the bridge merge - */ -static enum bridge_allow_merge bridges_allow_merge_optimization(struct ast_bridge *chan_bridge, - struct ast_bridge *peer_bridge, int num_kick_channels, struct merge_direction *merge) -{ - *merge = bridge_merge_determine_direction(chan_bridge, peer_bridge); - if (!merge->dest) { - return MERGE_PROHIBITED; - } - if (merge->src->num_channels < 2) { - return MERGE_NOT_ENOUGH_CHANNELS; - } else if ((2 + num_kick_channels) < 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))) { - return MERGE_NO_MULTIMIX; - } - - return MERGE_ALLOWED; -} - -/*! - * \internal - * \brief Check and attempt to merge optimize out the unreal channels. - * \since 12.0.0 - * - * \param chan_bridge - * \param chan_bridge_channel - * \param peer_bridge - * \param peer_bridge_channel - * \param pvt Unreal data containing callbacks to call if the optimization actually - * happens - * - * \retval 0 if unreal channels were not optimized out. - * \retval -1 if unreal channels were optimized out. - */ -static int try_merge_optimize_out(struct ast_bridge *chan_bridge, - struct ast_bridge_channel *chan_bridge_channel, struct ast_bridge *peer_bridge, - struct ast_bridge_channel *peer_bridge_channel, - struct ast_unreal_pvt *pvt) -{ - struct merge_direction merge; - struct ast_bridge_channel *kick_me[] = { - chan_bridge_channel, - peer_bridge_channel, - }; - - switch (bridges_allow_merge_optimization(chan_bridge, peer_bridge, ARRAY_LEN(kick_me), &merge)) { - case MERGE_ALLOWED: - break; - case MERGE_PROHIBITED: - return 0; - case MERGE_NOT_ENOUGH_CHANNELS: - ast_debug(4, "Can't optimize %s -- %s out, not enough channels in bridge %s.\n", - ast_channel_name(chan_bridge_channel->chan), - ast_channel_name(peer_bridge_channel->chan), - merge.src->uniqueid); - return 0; - case MERGE_NO_MULTIMIX: - ast_debug(4, "Can't optimize %s -- %s out, multimix is needed and it cannot be acquired.\n", - ast_channel_name(chan_bridge_channel->chan), - ast_channel_name(peer_bridge_channel->chan)); - return 0; - } - - ast_verb(3, "Merge optimizing %s -- %s out.\n", - ast_channel_name(chan_bridge_channel->chan), - ast_channel_name(peer_bridge_channel->chan)); - - if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks - && pvt->callbacks->optimization_started) { - pvt->callbacks->optimization_started(pvt); - ast_set_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN); - } - bridge_do_merge(merge.dest, merge.src, kick_me, ARRAY_LEN(kick_me), 1); - if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) { - pvt->callbacks->optimization_finished(pvt); - } - - return -1; -} - -int ast_bridge_unreal_optimize_out(struct ast_channel *chan, struct ast_channel *peer, struct ast_unreal_pvt *pvt) -{ - struct ast_bridge *chan_bridge; - struct ast_bridge *peer_bridge; - struct ast_bridge_channel *chan_bridge_channel; - struct ast_bridge_channel *peer_bridge_channel; - int res = 0; - - chan_bridge = optimize_lock_chan_stack(chan); - if (!chan_bridge) { - return res; - } - chan_bridge_channel = ast_channel_internal_bridge_channel(chan); - - peer_bridge = optimize_lock_peer_stack(peer); - if (peer_bridge) { - peer_bridge_channel = ast_channel_internal_bridge_channel(peer); - - res = try_swap_optimize_out(chan_bridge, chan_bridge_channel, - peer_bridge, peer_bridge_channel, pvt); - if (!res) { - res = try_merge_optimize_out(chan_bridge, chan_bridge_channel, - peer_bridge, peer_bridge_channel, pvt); - } else if (0 < res) { - res = 0; - } - - /* Release peer locks. */ - ast_bridge_unlock(peer_bridge); - ast_bridge_channel_unlock(peer_bridge_channel); - ast_channel_unlock(peer); - } - - /* Release chan locks. */ - ast_bridge_unlock(chan_bridge); - ast_bridge_channel_unlock(chan_bridge_channel); - - return res; -} - -enum ast_bridge_optimization ast_bridges_allow_optimization(struct ast_bridge *chan_bridge, - struct ast_bridge *peer_bridge) -{ - struct merge_direction merge; - - if (!bridge_allows_optimization(chan_bridge) || !bridge_allows_optimization(peer_bridge)) { - return AST_BRIDGE_OPTIMIZE_PROHIBITED; - } - - switch (bridges_allow_swap_optimization(chan_bridge, peer_bridge)) { - case SWAP_TO_CHAN_BRIDGE: - return AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE; - case SWAP_TO_PEER_BRIDGE: - return AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE; - case SWAP_PROHIBITED: - default: - break; - } - - /* Two channels will be kicked from the bridges, the unreal;1 and unreal;2 channels */ - if (bridges_allow_merge_optimization(chan_bridge, peer_bridge, 2, &merge) != MERGE_ALLOWED) { - return AST_BRIDGE_OPTIMIZE_PROHIBITED; - } - - if (merge.dest == chan_bridge) { - return AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE; - } else { - return AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE; - } -} - -/*! - * \internal - * \brief Adjust the bridge merge inhibit request count. - * \since 12.0.0 - * - * \param bridge What to operate on. - * \param request Inhibit request increment. - * (Positive to add requests. Negative to remove requests.) - * - * \note This function assumes bridge is locked. - * - * \return Nothing - */ -void bridge_merge_inhibit_nolock(struct ast_bridge *bridge, int request) -{ - int new_request; - - new_request = bridge->inhibit_merge + request; - ast_assert(0 <= new_request); - bridge->inhibit_merge = new_request; -} - -void ast_bridge_merge_inhibit(struct ast_bridge *bridge, int request) -{ - ast_bridge_lock(bridge); - bridge_merge_inhibit_nolock(bridge, request); - ast_bridge_unlock(bridge); -} - -int ast_bridge_suspend(struct ast_bridge *bridge, struct ast_channel *chan) -{ - struct ast_bridge_channel *bridge_channel; -/* BUGBUG the case of a disolved bridge while channel is suspended is not handled. */ -/* BUGBUG suspend/unsuspend needs to be rethought. The caller must block until it has successfully suspended the channel for temporary control. */ -/* BUGBUG external suspend/unsuspend needs to be eliminated. The channel may be playing a file at the time and stealing it then is not good. */ - - ast_bridge_lock(bridge); - - if (!(bridge_channel = bridge_find_channel(bridge, chan))) { - ast_bridge_unlock(bridge); - return -1; - } - - bridge_channel_internal_suspend_nolock(bridge_channel); - - ast_bridge_unlock(bridge); - - return 0; -} - -int ast_bridge_unsuspend(struct ast_bridge *bridge, struct ast_channel *chan) -{ - struct ast_bridge_channel *bridge_channel; -/* BUGBUG the case of a disolved bridge while channel is suspended is not handled. */ - - ast_bridge_lock(bridge); - - if (!(bridge_channel = bridge_find_channel(bridge, chan))) { - ast_bridge_unlock(bridge); - return -1; - } - - bridge_channel_internal_unsuspend_nolock(bridge_channel); - - ast_bridge_unlock(bridge); - - return 0; -} - -void ast_bridge_technology_suspend(struct ast_bridge_technology *technology) -{ - technology->suspended = 1; -} - -void ast_bridge_technology_unsuspend(struct ast_bridge_technology *technology) -{ -/* BUGBUG unsuspending a bridge technology probably needs to prod all existing bridges to see if they should start using it. */ - technology->suspended = 0; -} - -int ast_bridge_features_register(enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf) -{ - if (ARRAY_LEN(builtin_features_handlers) <= feature - || builtin_features_handlers[feature]) { - return -1; - } - - if (!ast_strlen_zero(dtmf)) { - ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature])); - } - - builtin_features_handlers[feature] = callback; - - return 0; -} - -int ast_bridge_features_unregister(enum ast_bridge_builtin_feature feature) -{ - if (ARRAY_LEN(builtin_features_handlers) <= feature - || !builtin_features_handlers[feature]) { - return -1; - } - - builtin_features_handlers[feature] = NULL; - - return 0; -} - -int ast_bridge_features_do(enum ast_bridge_builtin_feature feature, struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, void *hook_pvt) -{ - ast_bridge_hook_callback callback; - - if (ARRAY_LEN(builtin_features_handlers) <= feature) { - return -1; - } - - callback = builtin_features_handlers[feature]; - if (!callback) { - return -1; - } - callback(bridge, bridge_channel, hook_pvt); - - return 0; -} - -int ast_bridge_interval_register(enum ast_bridge_builtin_interval interval, ast_bridge_builtin_set_limits_fn callback) -{ - if (ARRAY_LEN(builtin_interval_handlers) <= interval - || builtin_interval_handlers[interval]) { - return -1; - } - - builtin_interval_handlers[interval] = callback; - - return 0; -} - -int ast_bridge_interval_unregister(enum ast_bridge_builtin_interval interval) -{ - if (ARRAY_LEN(builtin_interval_handlers) <= interval - || !builtin_interval_handlers[interval]) { - return -1; - } - - builtin_interval_handlers[interval] = NULL; - - return 0; - -} - -/*! - * \internal - * \brief Bridge hook destructor. - * \since 12.0.0 - * - * \param vhook Object to destroy. - * - * \return Nothing - */ -static void bridge_hook_destroy(void *vhook) -{ - struct ast_bridge_hook *hook = vhook; - - if (hook->destructor) { - hook->destructor(hook->hook_pvt); - } -} - -/*! - * \internal - * \brief Allocate and setup a generic bridge hook. - * \since 12.0.0 - * - * \param size How big an object to allocate. - * \param callback Function to execute upon activation - * \param hook_pvt Unique data - * \param destructor Optional destructor callback for hook_pvt data - * \param remove_flags Dictates what situations the hook should be removed. - * - * \retval hook on success. - * \retval NULL on error. - */ -static struct ast_bridge_hook *bridge_hook_generic(size_t size, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - struct ast_bridge_hook *hook; - - /* Allocate new hook and setup it's basic variables */ - hook = ao2_alloc_options(size, bridge_hook_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK); - if (hook) { - hook->callback = callback; - hook->destructor = destructor; - hook->hook_pvt = hook_pvt; - ast_set_flag(&hook->remove_flags, remove_flags); - } - - return hook; -} - -int ast_bridge_dtmf_hook(struct ast_bridge_features *features, - const char *dtmf, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - struct ast_bridge_hook_dtmf *hook; - int res; - - /* Allocate new hook and setup it's various variables */ - hook = (struct ast_bridge_hook_dtmf *) bridge_hook_generic(sizeof(*hook), callback, - hook_pvt, destructor, remove_flags); - if (!hook) { - return -1; - } - hook->generic.type = AST_BRIDGE_HOOK_TYPE_DTMF; - ast_copy_string(hook->dtmf.code, dtmf, sizeof(hook->dtmf.code)); - - /* Once done we put it in the container. */ - res = ao2_link(features->dtmf_hooks, hook) ? 0 : -1; - if (res) { - /* - * Could not link the hook into the container. - * - * Remove the hook_pvt destructor call from the hook since we - * are returning failure to install the hook. - */ - hook->generic.destructor = NULL; - } - ao2_ref(hook, -1); - - return res; -} - -/*! - * \internal - * \brief Attach an other hook to a bridge features structure - * - * \param features Bridge features structure - * \param callback Function to execute upon activation - * \param hook_pvt Unique data - * \param destructor Optional destructor callback for hook_pvt data - * \param remove_flags Dictates what situations the hook should be removed. - * \param type What type of hook is being attached. - * - * \retval 0 on success - * \retval -1 on failure (The caller must cleanup any hook_pvt resources.) - */ -static int bridge_other_hook(struct ast_bridge_features *features, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags, - enum ast_bridge_hook_type type) -{ - struct ast_bridge_hook *hook; - int res; - - /* Allocate new hook and setup it's various variables */ - hook = bridge_hook_generic(sizeof(*hook), callback, hook_pvt, destructor, - remove_flags); - if (!hook) { - return -1; - } - hook->type = type; - - /* Once done we put it in the container. */ - res = ao2_link(features->other_hooks, hook) ? 0 : -1; - if (res) { - /* - * Could not link the hook into the container. - * - * Remove the hook_pvt destructor call from the hook since we - * are returning failure to install the hook. - */ - hook->destructor = NULL; - } - ao2_ref(hook, -1); - - return res; -} - -int ast_bridge_hangup_hook(struct ast_bridge_features *features, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags, - AST_BRIDGE_HOOK_TYPE_HANGUP); -} - -int ast_bridge_join_hook(struct ast_bridge_features *features, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags, - AST_BRIDGE_HOOK_TYPE_JOIN); -} - -int ast_bridge_leave_hook(struct ast_bridge_features *features, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags, - AST_BRIDGE_HOOK_TYPE_LEAVE); -} - -int ast_bridge_talk_detector_hook(struct ast_bridge_features *features, - ast_bridge_talking_indicate_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - ast_bridge_hook_callback hook_cb = (ast_bridge_hook_callback) callback; - - return bridge_other_hook(features, hook_cb, hook_pvt, destructor, remove_flags, - AST_BRIDGE_HOOK_TYPE_TALK); -} - -int ast_bridge_interval_hook(struct ast_bridge_features *features, - unsigned int interval, - ast_bridge_hook_callback callback, - void *hook_pvt, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - struct ast_bridge_hook_timer *hook; - int res; - - if (!features ||!interval || !callback) { - return -1; - } - - /* Allocate new hook and setup it's various variables */ - hook = (struct ast_bridge_hook_timer *) bridge_hook_generic(sizeof(*hook), callback, - hook_pvt, destructor, remove_flags); - if (!hook) { - return -1; - } - hook->generic.type = AST_BRIDGE_HOOK_TYPE_TIMER; - hook->timer.interval = interval; - hook->timer.trip_time = ast_tvadd(ast_tvnow(), ast_samp2tv(hook->timer.interval, 1000)); - hook->timer.seqno = ast_atomic_fetchadd_int((int *) &features->interval_sequence, +1); - - ast_debug(1, "Putting interval hook %p with interval %u in the heap on features %p\n", - hook, hook->timer.interval, features); - ast_heap_wrlock(features->interval_hooks); - res = ast_heap_push(features->interval_hooks, hook); - ast_heap_unlock(features->interval_hooks); - if (res) { - /* - * Could not push the hook into the heap - * - * Remove the hook_pvt destructor call from the hook since we - * are returning failure to install the hook. - */ - hook->generic.destructor = NULL; - ao2_ref(hook, -1); - } - - return res ? -1 : 0; -} - -int ast_bridge_features_enable(struct ast_bridge_features *features, - enum ast_bridge_builtin_feature feature, - const char *dtmf, - void *config, - ast_bridge_hook_pvt_destructor destructor, - enum ast_bridge_hook_remove_flags remove_flags) -{ - if (ARRAY_LEN(builtin_features_handlers) <= feature - || !builtin_features_handlers[feature]) { - return -1; - } - - /* If no alternate DTMF stream was provided use the default one */ - if (ast_strlen_zero(dtmf)) { - dtmf = builtin_features_dtmf[feature]; - /* If no DTMF is still available (ie: it has been disabled) then error out now */ - if (ast_strlen_zero(dtmf)) { - ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n", - feature, features); - return -1; - } - } - - /* - * The rest is basically pretty easy. We create another hook - * using the built in feature's DTMF callback. Easy as pie. - */ - return ast_bridge_dtmf_hook(features, dtmf, builtin_features_handlers[feature], - config, destructor, remove_flags); -} - -int ast_bridge_features_limits_construct(struct ast_bridge_features_limits *limits) -{ - memset(limits, 0, sizeof(*limits)); - - if (ast_string_field_init(limits, 256)) { - ast_free(limits); - return -1; - } - - return 0; -} - -void ast_bridge_features_limits_destroy(struct ast_bridge_features_limits *limits) -{ - ast_string_field_free_memory(limits); -} - -int ast_bridge_features_set_limits(struct ast_bridge_features *features, - struct ast_bridge_features_limits *limits, enum ast_bridge_hook_remove_flags remove_flags) -{ - if (builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]) { - ast_bridge_builtin_set_limits_fn bridge_features_set_limits_callback; - - bridge_features_set_limits_callback = builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]; - return bridge_features_set_limits_callback(features, limits, remove_flags); - } - - ast_log(LOG_ERROR, "Attempted to set limits without an AST_BRIDGE_BUILTIN_INTERVAL_LIMITS callback registered.\n"); - return -1; -} - -void ast_bridge_features_set_flag(struct ast_bridge_features *features, unsigned int flag) -{ - ast_set_flag(&features->feature_flags, flag); - features->usable = 1; -} - -/*! - * \internal - * \brief ao2 object match hooks with appropriate remove_flags. - * \since 12.0.0 - * - * \param obj Feature hook object. - * \param arg Removal flags - * \param flags Not used - * - * \retval CMP_MATCH if hook's remove_flags match the removal flags set. - * \retval 0 if not match. - */ -static int hook_remove_match(void *obj, void *arg, int flags) -{ - struct ast_bridge_hook *hook = obj; - enum ast_bridge_hook_remove_flags *remove_flags = arg; - - if (ast_test_flag(&hook->remove_flags, *remove_flags)) { - return CMP_MATCH; - } else { - return 0; - } -} - -/*! - * \internal - * \brief Remove all hooks with appropriate remove_flags in the container. - * \since 12.0.0 - * - * \param hooks Hooks container to work on. - * \param remove_flags Determinator for whether hook is removed - * - * \return Nothing - */ -static void hooks_remove_container(struct ao2_container *hooks, enum ast_bridge_hook_remove_flags remove_flags) -{ - ao2_callback(hooks, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, - hook_remove_match, &remove_flags); -} - -/*! - * \internal - * \brief Remove all hooks in the heap with appropriate remove_flags set. - * \since 12.0.0 - * - * \param hooks Hooks heap to work on. - * \param remove_flags Determinator for whether hook is removed - * - * \return Nothing - */ -static void hooks_remove_heap(struct ast_heap *hooks, enum ast_bridge_hook_remove_flags remove_flags) -{ - struct ast_bridge_hook *hook; - int changed; - - ast_heap_wrlock(hooks); - do { - int idx; - - changed = 0; - for (idx = ast_heap_size(hooks); idx; --idx) { - hook = ast_heap_peek(hooks, idx); - if (ast_test_flag(&hook->remove_flags, remove_flags)) { - ast_heap_remove(hooks, hook); - ao2_ref(hook, -1); - changed = 1; - } - } - } while (changed); - ast_heap_unlock(hooks); -} - -void ast_bridge_features_remove(struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags) -{ - hooks_remove_container(features->dtmf_hooks, remove_flags); - hooks_remove_container(features->other_hooks, remove_flags); - hooks_remove_heap(features->interval_hooks, remove_flags); -} - -static int interval_hook_time_cmp(void *a, void *b) -{ - struct ast_bridge_hook_timer *hook_a = a; - struct ast_bridge_hook_timer *hook_b = b; - int cmp; - - cmp = ast_tvcmp(hook_b->timer.trip_time, hook_a->timer.trip_time); - if (cmp) { - return cmp; - } - - cmp = hook_b->timer.seqno - hook_a->timer.seqno; - return cmp; -} - -/*! - * \internal - * \brief DTMF hook container sort comparison function. - * \since 12.0.0 - * - * \param obj_left pointer to the (user-defined part) of an object. - * \param obj_right pointer to the (user-defined part) of an object. - * \param flags flags from ao2_callback() - * OBJ_POINTER - if set, 'obj_right', is an object. - * OBJ_KEY - if set, 'obj_right', is a search key item that is not an object. - * OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object. - * - * \retval <0 if obj_left < obj_right - * \retval =0 if obj_left == obj_right - * \retval >0 if obj_left > obj_right - */ -static int bridge_dtmf_hook_sort(const void *obj_left, const void *obj_right, int flags) -{ - const struct ast_bridge_hook_dtmf *hook_left = obj_left; - const struct ast_bridge_hook_dtmf *hook_right = obj_right; - const char *right_key = obj_right; - int cmp; - - switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) { - default: - case OBJ_POINTER: - right_key = hook_right->dtmf.code; - /* Fall through */ - case OBJ_KEY: - cmp = strcasecmp(hook_left->dtmf.code, right_key); - break; - case OBJ_PARTIAL_KEY: - cmp = strncasecmp(hook_left->dtmf.code, right_key, strlen(right_key)); - break; - } - return cmp; -} - -/* BUGBUG make ast_bridge_features_init() static when make ast_bridge_join() requires features to be allocated. */ -int ast_bridge_features_init(struct ast_bridge_features *features) -{ - /* Zero out the structure */ - memset(features, 0, sizeof(*features)); - - /* Initialize the DTMF hooks container */ - features->dtmf_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, - AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_dtmf_hook_sort, NULL); - if (!features->dtmf_hooks) { - return -1; - } - - /* Initialize the miscellaneous other hooks container */ - features->other_hooks = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, - NULL); - if (!features->other_hooks) { - return -1; - } - - /* Initialize the interval hooks heap */ - features->interval_hooks = ast_heap_create(8, interval_hook_time_cmp, - offsetof(struct ast_bridge_hook_timer, timer.heap_index)); - if (!features->interval_hooks) { - return -1; - } - - return 0; -} - -/* BUGBUG make ast_bridge_features_cleanup() static when make ast_bridge_join() requires features to be allocated. */ -void ast_bridge_features_cleanup(struct ast_bridge_features *features) -{ - struct ast_bridge_hook_timer *hook; - - /* Destroy the interval hooks heap. */ - if (features->interval_hooks) { - while ((hook = ast_heap_pop(features->interval_hooks))) { - ao2_ref(hook, -1); - } - features->interval_hooks = ast_heap_destroy(features->interval_hooks); - } - - /* If the features contains a limits pvt, destroy that as well. */ - if (features->limits) { - ast_bridge_features_limits_destroy(features->limits); - ast_free(features->limits); - features->limits = NULL; - } - - /* Destroy the miscellaneous other hooks container. */ - ao2_cleanup(features->other_hooks); - features->other_hooks = NULL; - - /* Destroy the DTMF hooks container. */ - ao2_cleanup(features->dtmf_hooks); - features->dtmf_hooks = NULL; -} - -void ast_bridge_features_destroy(struct ast_bridge_features *features) -{ - if (!features) { - return; - } - ast_bridge_features_cleanup(features); - ast_free(features); -} - -struct ast_bridge_features *ast_bridge_features_new(void) -{ - struct ast_bridge_features *features; - - features = ast_malloc(sizeof(*features)); - if (features) { - if (ast_bridge_features_init(features)) { - ast_bridge_features_destroy(features); - features = NULL; - } - } - - return features; -} - -void ast_bridge_set_mixing_interval(struct ast_bridge *bridge, unsigned int mixing_interval) -{ - ast_bridge_lock(bridge); - bridge->softmix.internal_mixing_interval = mixing_interval; - ast_bridge_unlock(bridge); -} - -void ast_bridge_set_internal_sample_rate(struct ast_bridge *bridge, unsigned int sample_rate) -{ - ast_bridge_lock(bridge); - bridge->softmix.internal_sample_rate = sample_rate; - ast_bridge_unlock(bridge); -} - -static void cleanup_video_mode(struct ast_bridge *bridge) -{ - switch (bridge->softmix.video_mode.mode) { - case AST_BRIDGE_VIDEO_MODE_NONE: - break; - case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC: - if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc); - } - break; - case AST_BRIDGE_VIDEO_MODE_TALKER_SRC: - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc); - } - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc); - } - } - memset(&bridge->softmix.video_mode, 0, sizeof(bridge->softmix.video_mode)); -} - -void ast_bridge_set_single_src_video_mode(struct ast_bridge *bridge, struct ast_channel *video_src_chan) -{ - ast_bridge_lock(bridge); - cleanup_video_mode(bridge); - bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC; - bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan); - ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to single source\r\nVideo Mode: %d\r\nVideo Channel: %s", - bridge->softmix.video_mode.mode, ast_channel_name(video_src_chan)); - ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE); - ast_bridge_unlock(bridge); -} - -void ast_bridge_set_talker_src_video_mode(struct ast_bridge *bridge) -{ - ast_bridge_lock(bridge); - cleanup_video_mode(bridge); - bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC; - ast_test_suite_event_notify("BRIDGE_VIDEO_MODE", "Message: video mode set to talker source\r\nVideo Mode: %d", - bridge->softmix.video_mode.mode); - ast_bridge_unlock(bridge); -} - -void ast_bridge_update_talker_src_video_mode(struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe) -{ - struct ast_bridge_video_talker_src_data *data; - - /* If the channel doesn't support video, we don't care about it */ - if (!ast_format_cap_has_type(ast_channel_nativeformats(chan), AST_FORMAT_TYPE_VIDEO)) { - return; - } - - ast_bridge_lock(bridge); - data = &bridge->softmix.video_mode.mode_data.talker_src_data; - - if (data->chan_vsrc == chan) { - data->average_talking_energy = talker_energy; - } else if ((data->average_talking_energy < talker_energy) && is_keyframe) { - if (data->chan_old_vsrc) { - ast_channel_unref(data->chan_old_vsrc); - } - if (data->chan_vsrc) { - data->chan_old_vsrc = data->chan_vsrc; - ast_indicate(data->chan_old_vsrc, AST_CONTROL_VIDUPDATE); - } - data->chan_vsrc = ast_channel_ref(chan); - data->average_talking_energy = talker_energy; - ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc)); - ast_indicate(data->chan_vsrc, AST_CONTROL_VIDUPDATE); - } else if ((data->average_talking_energy < talker_energy) && !is_keyframe) { - ast_indicate(chan, AST_CONTROL_VIDUPDATE); - } else if (!data->chan_vsrc && is_keyframe) { - data->chan_vsrc = ast_channel_ref(chan); - data->average_talking_energy = talker_energy; - ast_test_suite_event_notify("BRIDGE_VIDEO_SRC", "Message: video source updated\r\nVideo Channel: %s", ast_channel_name(data->chan_vsrc)); - ast_indicate(chan, AST_CONTROL_VIDUPDATE); - } else if (!data->chan_old_vsrc && is_keyframe) { - data->chan_old_vsrc = ast_channel_ref(chan); - ast_indicate(chan, AST_CONTROL_VIDUPDATE); - } - ast_bridge_unlock(bridge); -} - -int ast_bridge_number_video_src(struct ast_bridge *bridge) -{ - int res = 0; - - ast_bridge_lock(bridge); - switch (bridge->softmix.video_mode.mode) { - case AST_BRIDGE_VIDEO_MODE_NONE: - break; - case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC: - if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) { - res = 1; - } - break; - case AST_BRIDGE_VIDEO_MODE_TALKER_SRC: - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) { - res++; - } - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) { - res++; - } - } - ast_bridge_unlock(bridge); - return res; -} - -int ast_bridge_is_video_src(struct ast_bridge *bridge, struct ast_channel *chan) -{ - int res = 0; - - ast_bridge_lock(bridge); - switch (bridge->softmix.video_mode.mode) { - case AST_BRIDGE_VIDEO_MODE_NONE: - break; - case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC: - if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc == chan) { - res = 1; - } - break; - case AST_BRIDGE_VIDEO_MODE_TALKER_SRC: - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc == chan) { - res = 1; - } else if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) { - res = 2; - } - - } - ast_bridge_unlock(bridge); - return res; -} - -void ast_bridge_remove_video_src(struct ast_bridge *bridge, struct ast_channel *chan) -{ - ast_bridge_lock(bridge); - switch (bridge->softmix.video_mode.mode) { - case AST_BRIDGE_VIDEO_MODE_NONE: - break; - case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC: - if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc == chan) { - if (bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc); - } - bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = NULL; - } - break; - case AST_BRIDGE_VIDEO_MODE_TALKER_SRC: - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc == chan) { - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc); - } - bridge->softmix.video_mode.mode_data.talker_src_data.chan_vsrc = NULL; - bridge->softmix.video_mode.mode_data.talker_src_data.average_talking_energy = 0; - } - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc == chan) { - if (bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc) { - ast_channel_unref(bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc); - } - bridge->softmix.video_mode.mode_data.talker_src_data.chan_old_vsrc = NULL; - } - } - ast_bridge_unlock(bridge); -} - -static int channel_hash(const void *obj, int flags) -{ - const struct ast_channel *chan = obj; - const char *name = obj; - int hash; - - switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) { - default: - case OBJ_POINTER: - name = ast_channel_name(chan); - /* Fall through */ - case OBJ_KEY: - hash = ast_str_hash(name); - break; - case OBJ_PARTIAL_KEY: - /* Should never happen in hash callback. */ - ast_assert(0); - hash = 0; - break; - } - return hash; -} - -static int channel_cmp(void *obj, void *arg, int flags) -{ - const struct ast_channel *left = obj; - const struct ast_channel *right = arg; - const char *right_name = arg; - int cmp; - - switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) { - default: - case OBJ_POINTER: - right_name = ast_channel_name(right); - /* Fall through */ - case OBJ_KEY: - cmp = strcmp(ast_channel_name(left), right_name); - break; - case OBJ_PARTIAL_KEY: - cmp = strncmp(ast_channel_name(left), right_name, strlen(right_name)); - break; - } - return cmp ? 0 : CMP_MATCH; -} - -struct ao2_container *ast_bridge_peers_nolock(struct ast_bridge *bridge) -{ - struct ao2_container *channels; - struct ast_bridge_channel *iter; - - channels = ao2_container_alloc_options(AO2_ALLOC_OPT_LOCK_NOLOCK, - 13, channel_hash, channel_cmp); - if (!channels) { - return NULL; - } - - AST_LIST_TRAVERSE(&bridge->channels, iter, entry) { - ao2_link(channels, iter->chan); - } - - return channels; -} - -struct ao2_container *ast_bridge_peers(struct ast_bridge *bridge) -{ - struct ao2_container *channels; - - ast_bridge_lock(bridge); - channels = ast_bridge_peers_nolock(bridge); - ast_bridge_unlock(bridge); - - return channels; -} - -struct ast_channel *ast_bridge_peer_nolock(struct ast_bridge *bridge, struct ast_channel *chan) -{ - struct ast_channel *peer = NULL; - struct ast_bridge_channel *iter; - - /* Asking for the peer channel only makes sense on a two-party bridge. */ - if (bridge->num_channels == 2 - && bridge->technology->capabilities - & (AST_BRIDGE_CAPABILITY_NATIVE | AST_BRIDGE_CAPABILITY_1TO1MIX)) { - int in_bridge = 0; - - AST_LIST_TRAVERSE(&bridge->channels, iter, entry) { - if (iter->chan != chan) { - peer = iter->chan; - } else { - in_bridge = 1; - } - } - if (in_bridge && peer) { - ast_channel_ref(peer); - } else { - peer = NULL; - } - } - - return peer; -} - -struct ast_channel *ast_bridge_peer(struct ast_bridge *bridge, struct ast_channel *chan) -{ - struct ast_channel *peer; - - ast_bridge_lock(bridge); - peer = ast_bridge_peer_nolock(bridge, chan); - ast_bridge_unlock(bridge); - - return peer; -} - -/*! - * \internal - * \brief Transfer an entire bridge to a specific destination. - * - * This creates a local channel to dial out and swaps the called local channel - * with the transferer channel. By doing so, all participants in the bridge are - * connected to the specified destination. - * - * While this means of transferring would work for both two-party and multi-party - * bridges, this method is only used for multi-party bridges since this method would - * be less efficient for two-party bridges. - * - * \param transferer The channel performing a transfer - * \param bridge The bridge where the transfer is being performed - * \param exten The destination extension for the blind transfer - * \param context The destination context for the blind transfer - * \param hook Framehook to attach to local channel - * \return The success or failure of the operation - */ -static enum ast_transfer_result blind_transfer_bridge(struct ast_channel *transferer, - struct ast_bridge *bridge, const char *exten, const char *context, - transfer_channel_cb new_channel_cb, void *user_data) -{ - struct ast_channel *local; - char chan_name[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2]; - int cause; - - snprintf(chan_name, sizeof(chan_name), "%s@%s", exten, context); - local = ast_request("Local", ast_channel_nativeformats(transferer), transferer, - chan_name, &cause); - if (!local) { - return AST_BRIDGE_TRANSFER_FAIL; - } - - if (new_channel_cb) { - new_channel_cb(local, user_data, AST_BRIDGE_TRANSFER_MULTI_PARTY); - } - - if (ast_call(local, chan_name, 0)) { - ast_hangup(local); - return AST_BRIDGE_TRANSFER_FAIL; - } - if (ast_bridge_impart(bridge, local, transferer, NULL, 1)) { - ast_hangup(local); - return AST_BRIDGE_TRANSFER_FAIL; - } - return AST_BRIDGE_TRANSFER_SUCCESS; -} - -/*! - * \internal - * \brief Base data to publish for stasis attended transfer messages - */ -struct stasis_attended_transfer_publish_data { - /* The bridge between the transferer and transferee, and the transferer channel in this bridge */ - struct ast_bridge_channel_pair to_transferee; - /* The bridge between the transferer and transfer target, and the transferer channel in this bridge */ - struct ast_bridge_channel_pair to_transfer_target; -}; - -static void stasis_publish_data_cleanup(struct stasis_attended_transfer_publish_data *publication) -{ - ast_channel_unref(publication->to_transferee.channel); - ast_channel_unref(publication->to_transfer_target.channel); - ao2_cleanup(publication->to_transferee.bridge); - ao2_cleanup(publication->to_transfer_target.bridge); -} - -/*! - * \internal - * \brief Set up base data for an attended transfer stasis publication - * - * \param to_transferee The original transferer channel, which may be bridged to a transferee - * \param to_transferee_bridge The bridge that to_transferee is in. - * \param to_transfer_target The second transferer channel, which may be bridged to a transfer target - * \param to_target_bridge The bridge that to_transfer_target_is in. - * \param[out] publication A structure to hold the other parameters - */ -static void stasis_publish_data_init(struct ast_channel *to_transferee, - struct ast_bridge *to_transferee_bridge, struct ast_channel *to_transfer_target, - struct ast_bridge *to_target_bridge, - struct stasis_attended_transfer_publish_data *publication) -{ - memset(publication, 0, sizeof(*publication)); - publication->to_transferee.channel = ast_channel_ref(to_transferee); - if (to_transferee_bridge) { - ao2_ref(to_transferee_bridge, +1); - publication->to_transferee.bridge = to_transferee_bridge; - } - - publication->to_transfer_target.channel = ast_channel_ref(to_transfer_target); - if (to_target_bridge) { - ao2_ref(to_target_bridge, +1); - publication->to_transfer_target.bridge = to_target_bridge; - } -} - -/* - * \internal - * \brief Publish a stasis attended transfer resulting in a bridge merge - * - * \param publication Base data about the attended transfer - * \param final_bridge The surviving bridge of the attended transfer - */ -static void publish_attended_transfer_bridge_merge(struct stasis_attended_transfer_publish_data *publication, - struct ast_bridge *final_bridge) -{ - ast_bridge_publish_attended_transfer_bridge_merge(1, AST_BRIDGE_TRANSFER_SUCCESS, - &publication->to_transferee, &publication->to_transfer_target, final_bridge); -} - -/* - * \internal - * \brief Publish a stasis attended transfer to an application - * - * \param publication Base data about the attended transfer - * \param app The app that is running at the conclusion of the transfer - */ -static void publish_attended_transfer_app(struct stasis_attended_transfer_publish_data *publication, - const char *app) -{ - ast_bridge_publish_attended_transfer_app(1, AST_BRIDGE_TRANSFER_SUCCESS, - &publication->to_transferee, &publication->to_transfer_target, app); -} - -/* - * \internal - * \brief Publish a stasis attended transfer showing a link between bridges - * - * \param publication Base data about the attended transfer - * \param local_channel1 Local channel in the original bridge - * \param local_channel2 Local channel in the second bridge - */ -static void publish_attended_transfer_link(struct stasis_attended_transfer_publish_data *publication, - struct ast_channel *local_channel1, struct ast_channel *local_channel2) -{ - struct ast_channel *locals[2] = { local_channel1, local_channel2 }; - - ast_bridge_publish_attended_transfer_link(1, AST_BRIDGE_TRANSFER_SUCCESS, - &publication->to_transferee, &publication->to_transfer_target, locals); -} - -/* - * \internal - * \brief Publish a stasis attended transfer failure - * - * \param publication Base data about the attended transfer - * \param result The transfer result - */ -static void publish_attended_transfer_fail(struct stasis_attended_transfer_publish_data *publication, - enum ast_transfer_result result) -{ - ast_bridge_publish_attended_transfer_fail(1, result, &publication->to_transferee, - &publication->to_transfer_target); -} - -/*! - * \brief Perform an attended transfer of a bridge - * - * This performs an attended transfer of an entire bridge to a target. - * The target varies, depending on what bridges exist during the transfer - * attempt. - * - * If two bridges exist, then a local channel is created to link the two - * bridges together. - * - * If only one bridge exists, then a local channel is created with one end - * placed into the existing bridge and the other end masquerading into - * the unbridged channel. - * - * \param chan1 Transferer channel. Guaranteed to be bridged. - * \param chan2 Other transferer channel. May or may not be bridged. - * \param bridge1 Bridge that chan1 is in. Guaranteed to be non-NULL. - * \param bridge2 Bridge that chan2 is in. If NULL, then chan2 is not bridged. - * \param publication Data to publish for a stasis attended transfer message. - * \retval AST_BRIDGE_TRANSFER_FAIL Internal error occurred - * \retval AST_BRIDGE_TRANSFER_SUCCESS Succesfully transferred the bridge - */ -static enum ast_transfer_result attended_transfer_bridge(struct ast_channel *chan1, - struct ast_channel *chan2, struct ast_bridge *bridge1, struct ast_bridge *bridge2, - struct stasis_attended_transfer_publish_data *publication) -{ - static const char *dest = "_attended@transfer/m"; - struct ast_channel *local_chan; - int cause; - int res; - const char *app = NULL; - - local_chan = ast_request("Local", ast_channel_nativeformats(chan1), chan1, - dest, &cause); - - if (!local_chan) { - return AST_BRIDGE_TRANSFER_FAIL; - } - - if (bridge2) { - res = ast_local_setup_bridge(local_chan, bridge2, chan2, NULL); - } else { - app = ast_strdupa(ast_channel_appl(chan2)); - res = ast_local_setup_masquerade(local_chan, chan2); - } - - if (res) { - ast_hangup(local_chan); - return AST_BRIDGE_TRANSFER_FAIL; - } - - if (ast_call(local_chan, dest, 0)) { - ast_hangup(local_chan); - return AST_BRIDGE_TRANSFER_FAIL; - } - - if (ast_bridge_impart(bridge1, local_chan, chan1, NULL, 1)) { - ast_hangup(local_chan); - return AST_BRIDGE_TRANSFER_FAIL; - } - - if (bridge2) { - RAII_VAR(struct ast_channel *, local_chan2, NULL, ao2_cleanup); - - ast_channel_lock(local_chan); - local_chan2 = ast_local_get_peer(local_chan); - ast_channel_unlock(local_chan); - - ast_assert(local_chan2 != NULL); - - publish_attended_transfer_link(publication, - local_chan, local_chan2); - } else { - publish_attended_transfer_app(publication, app); - } - return AST_BRIDGE_TRANSFER_SUCCESS; -} - -/*! - * \internal - * \brief Get the transferee channel - * - * This is only applicable to cases where a transfer is occurring on a - * two-party bridge. The channels container passed in is expected to only - * contain two channels, the transferer and the transferee. The transferer - * channel is passed in as a parameter to ensure we don't return it as - * the transferee channel. - * - * \param channels A two-channel container containing the transferer and transferee - * \param transferer The party that is transfering the call - * \return The party that is being transferred - */ -static struct ast_channel *get_transferee(struct ao2_container *channels, struct ast_channel *transferer) -{ - struct ao2_iterator channel_iter; - struct ast_channel *transferee; - - for (channel_iter = ao2_iterator_init(channels, 0); - (transferee = ao2_iterator_next(&channel_iter)); - ao2_cleanup(transferee)) { - if (transferee != transferer) { - break; - } - } - - ao2_iterator_destroy(&channel_iter); - return transferee; -} - -enum try_parking_result { - PARKING_SUCCESS, - PARKING_FAILURE, - PARKING_NOT_APPLICABLE, -}; - -static enum try_parking_result try_parking(struct ast_bridge *bridge, struct ast_channel *transferer, - const char *exten, const char *context) -{ - RAII_VAR(struct ast_bridge_channel *, transferer_bridge_channel, NULL, ao2_cleanup); - struct ast_exten *parking_exten; - - ast_channel_lock(transferer); - transferer_bridge_channel = ast_channel_get_bridge_channel(transferer); - ast_channel_unlock(transferer); - - if (!transferer_bridge_channel) { - return PARKING_FAILURE; - } - - parking_exten = ast_get_parking_exten(exten, NULL, context); - if (parking_exten) { - return ast_park_blind_xfer(bridge, transferer_bridge_channel, parking_exten) == 0 ? - PARKING_SUCCESS : PARKING_FAILURE; - } - - return PARKING_NOT_APPLICABLE; -} - -/*! - * \internal - * \brief Set the BLINDTRANSFER variable as appropriate on channels involved in the transfer - * - * The transferer channel will have its BLINDTRANSFER variable set the same as its BRIDGEPEER - * variable. This will account for all channels that it is bridged to. The other channels - * involved in the transfer will have their BLINDTRANSFER variable set to the transferer - * channel's name. - * - * \param transferer The channel performing the blind transfer - * \param channels The channels belonging to the bridge - */ -static void set_blind_transfer_variables(struct ast_channel *transferer, struct ao2_container *channels) -{ - struct ao2_iterator iter; - struct ast_channel *chan; - const char *transferer_name; - const char *transferer_bridgepeer; - - ast_channel_lock(transferer); - transferer_name = ast_strdupa(ast_channel_name(transferer)); - transferer_bridgepeer = ast_strdupa(S_OR(pbx_builtin_getvar_helper(transferer, "BRIDGEPEER"), "")); - ast_channel_unlock(transferer); - - for (iter = ao2_iterator_init(channels, 0); - (chan = ao2_iterator_next(&iter)); - ao2_cleanup(chan)) { - if (chan == transferer) { - pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", transferer_bridgepeer); - } else { - pbx_builtin_setvar_helper(chan, "BLINDTRANSFER", transferer_name); - } - } - - ao2_iterator_destroy(&iter); -} - -static struct ast_bridge *acquire_bridge(struct ast_channel *chan) -{ - struct ast_bridge *bridge; - - ast_channel_lock(chan); - bridge = ast_channel_get_bridge(chan); - ast_channel_unlock(chan); - - if (bridge - && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY)) { - ao2_ref(bridge, -1); - bridge = NULL; - } - - return bridge; -} - -static void publish_blind_transfer(int is_external, enum ast_transfer_result result, - struct ast_channel *transferer, struct ast_bridge *bridge, - const char *context, const char *exten) -{ - struct ast_bridge_channel_pair pair; - pair.channel = transferer; - pair.bridge = bridge; - ast_bridge_publish_blind_transfer(is_external, result, &pair, context, exten); -} - -enum ast_transfer_result ast_bridge_transfer_blind(int is_external, - struct ast_channel *transferer, const char *exten, const char *context, - transfer_channel_cb new_channel_cb, void *user_data) -{ - RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup); - RAII_VAR(struct ast_bridge_channel *, bridge_channel, NULL, ao2_cleanup); - RAII_VAR(struct ao2_container *, channels, NULL, ao2_cleanup); - RAII_VAR(struct ast_channel *, transferee, NULL, ao2_cleanup); - int do_bridge_transfer; - int transfer_prohibited; - enum try_parking_result parking_result; - enum ast_transfer_result transfer_result; - - bridge = acquire_bridge(transferer); - if (!bridge) { - transfer_result = AST_BRIDGE_TRANSFER_INVALID; - goto publish; - } - ast_channel_lock(transferer); - bridge_channel = ast_channel_get_bridge_channel(transferer); - ast_channel_unlock(transferer); - if (!bridge_channel) { - transfer_result = AST_BRIDGE_TRANSFER_INVALID; - goto publish; - } - - /* Take off hold if they are on hold. */ - ast_bridge_channel_write_unhold(bridge_channel); - - parking_result = try_parking(bridge, transferer, exten, context); - switch (parking_result) { - case PARKING_SUCCESS: - transfer_result = AST_BRIDGE_TRANSFER_SUCCESS; - goto publish; - case PARKING_FAILURE: - transfer_result = AST_BRIDGE_TRANSFER_FAIL; - goto publish; - case PARKING_NOT_APPLICABLE: - default: - break; - } - - { - SCOPED_LOCK(lock, bridge, ast_bridge_lock, ast_bridge_unlock); - - channels = ast_bridge_peers_nolock(bridge); - if (!channels) { - transfer_result = AST_BRIDGE_TRANSFER_FAIL; - goto publish; - } - if (ao2_container_count(channels) <= 1) { - transfer_result = AST_BRIDGE_TRANSFER_INVALID; - goto publish; - } - transfer_prohibited = ast_test_flag(&bridge->feature_flags, - AST_BRIDGE_FLAG_TRANSFER_PROHIBITED); - do_bridge_transfer = ast_test_flag(&bridge->feature_flags, - AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) || - ao2_container_count(channels) > 2; - } - - if (transfer_prohibited) { - transfer_result = AST_BRIDGE_TRANSFER_NOT_PERMITTED; - goto publish; - } - - set_blind_transfer_variables(transferer, channels); - - if (do_bridge_transfer) { - transfer_result = blind_transfer_bridge(transferer, bridge, exten, context, - new_channel_cb, user_data); - goto publish; - } - - /* Reaching this portion means that we're dealing with a two-party bridge */ - - transferee = get_transferee(channels, transferer); - if (!transferee) { - transfer_result = AST_BRIDGE_TRANSFER_FAIL; - goto publish; - } - - if (bridge_channel_internal_queue_blind_transfer(transferee, exten, context, - new_channel_cb, user_data)) { - transfer_result = AST_BRIDGE_TRANSFER_FAIL; - goto publish; - } - - ast_bridge_remove(bridge, transferer); - transfer_result = AST_BRIDGE_TRANSFER_SUCCESS; - -publish: - publish_blind_transfer(is_external, transfer_result, transferer, bridge, context, exten); - return transfer_result; -} - -/*! - * \internal - * \brief Performs an attended transfer by moving a channel from one bridge to another - * - * The channel that is bridged to the source_channel is moved into the dest_bridge from - * the source_bridge_channel's bridge. The swap_channel is swapped out of the dest_bridge and placed in - * the source_bridge_channel's bridge. - * - * \note dest_bridge and source_bridge_channel's bridge MUST be locked before calling this function. - * - * \param dest_bridge The final bridge for the attended transfer - * \param source_channel Channel who is bridged to the channel that will move - * \param swap_channel Channel to be swapped out of the dest_bridge - * \return The success or failure of the swap attempt - */ -static enum ast_transfer_result bridge_swap_attended_transfer(struct ast_bridge *dest_bridge, - struct ast_bridge_channel *source_bridge_channel, struct ast_channel *swap_channel) -{ - struct ast_bridge_channel *bridged_to_source; - - bridged_to_source = ast_bridge_channel_peer(source_bridge_channel); - if (bridged_to_source - && bridged_to_source->state == BRIDGE_CHANNEL_STATE_WAIT - && !ast_test_flag(&bridged_to_source->features->feature_flags, - AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE)) { - bridged_to_source->swap = swap_channel; - if (bridge_do_move(dest_bridge, bridged_to_source, 1, 0)) { - return AST_BRIDGE_TRANSFER_FAIL; - } - /* Must kick the source channel out of its bridge. */ - ast_bridge_channel_leave_bridge(source_bridge_channel, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE); - return AST_BRIDGE_TRANSFER_SUCCESS; - } else { - return AST_BRIDGE_TRANSFER_INVALID; - } -} - -/*! - * \internal - * \brief Function that performs an attended transfer when both transferer channels are bridged - * - * The method by which the transfer is performed is dependent on whether the bridges allow for - * optimization to occur between them. If no optimization is permitted, then an unreal channel - * is placed as a link between the two bridges. If optimization is permitted, then that means - * we are free to perform move or merge operations in order to perform the transfer. - * - * \note to_transferee_bridge and to_target_bridge MUST be locked before calling this function - * - * \param to_transferee The channel that is bridged to the transferee - * \param to_transferee_bridge_channel to_transferee's bridge_channel - * \param to_transfer_target The channel that is bridged to the transfer target - * \param to_target_bridge_channel to_transfer_target's bridge_channel - * \param to_transferee_bridge The bridge between to_transferee and the transferee - * \param to_target_bridge The bridge between to_transfer_target and the transfer_target - * \param publication Data to publish for a stasis attended transfer message - * \return The success or failure of the attended transfer - */ -static enum ast_transfer_result two_bridge_attended_transfer(struct ast_channel *to_transferee, - struct ast_bridge_channel *to_transferee_bridge_channel, - struct ast_channel *to_transfer_target, - struct ast_bridge_channel *to_target_bridge_channel, - struct ast_bridge *to_transferee_bridge, struct ast_bridge *to_target_bridge, - struct stasis_attended_transfer_publish_data *publication) -{ - struct ast_bridge_channel *kick_me[] = { - to_transferee_bridge_channel, - to_target_bridge_channel, - }; - enum ast_transfer_result res; - struct ast_bridge *final_bridge = NULL; - - switch (ast_bridges_allow_optimization(to_transferee_bridge, to_target_bridge)) { - case AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE: - final_bridge = to_transferee_bridge; - res = bridge_swap_attended_transfer(to_transferee_bridge, to_target_bridge_channel, to_transferee); - goto end; - case AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE: - final_bridge = to_target_bridge; - res = bridge_swap_attended_transfer(to_target_bridge, to_transferee_bridge_channel, to_transfer_target); - goto end; - case AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE: - final_bridge = to_transferee_bridge; - bridge_do_merge(to_transferee_bridge, to_target_bridge, kick_me, ARRAY_LEN(kick_me), 0); - res = AST_BRIDGE_TRANSFER_SUCCESS; - goto end; - case AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE: - final_bridge = to_target_bridge; - bridge_do_merge(to_target_bridge, to_transferee_bridge, kick_me, ARRAY_LEN(kick_me), 0); - res = AST_BRIDGE_TRANSFER_SUCCESS; - goto end; - case AST_BRIDGE_OPTIMIZE_PROHIBITED: - default: - /* Just because optimization wasn't doable doesn't necessarily mean - * that we can actually perform the transfer. Some reasons for non-optimization - * indicate bridge invalidity, so let's check those before proceeding. - */ - if (to_transferee_bridge->inhibit_merge || to_transferee_bridge->dissolved || - to_target_bridge->inhibit_merge || to_target_bridge->dissolved) { - res = AST_BRIDGE_TRANSFER_INVALID; - goto end; - } - - /* Don't goto end here. attended_transfer_bridge will publish its own - * stasis message if it succeeds - */ - return attended_transfer_bridge(to_transferee, to_transfer_target, - to_transferee_bridge, to_target_bridge, publication); - } - -end: - if (res == AST_BRIDGE_TRANSFER_SUCCESS) { - publish_attended_transfer_bridge_merge(publication, final_bridge); - } - - return res; -} - -enum ast_transfer_result ast_bridge_transfer_attended(struct ast_channel *to_transferee, - struct ast_channel *to_transfer_target) -{ - RAII_VAR(struct ast_bridge *, to_transferee_bridge, NULL, ao2_cleanup); - RAII_VAR(struct ast_bridge *, to_target_bridge, NULL, ao2_cleanup); - RAII_VAR(struct ast_bridge_channel *, to_transferee_bridge_channel, NULL, ao2_cleanup); - RAII_VAR(struct ast_bridge_channel *, to_target_bridge_channel, NULL, ao2_cleanup); - RAII_VAR(struct ao2_container *, channels, NULL, ao2_cleanup); - RAII_VAR(struct ast_channel *, transferee, NULL, ao2_cleanup); - struct ast_bridge *the_bridge; - struct ast_channel *chan_bridged; - struct ast_channel *chan_unbridged; - int transfer_prohibited; - int do_bridge_transfer; - enum ast_transfer_result res; - const char *app = NULL; - struct stasis_attended_transfer_publish_data publication; - - to_transferee_bridge = acquire_bridge(to_transferee); - to_target_bridge = acquire_bridge(to_transfer_target); - - stasis_publish_data_init(to_transferee, to_transferee_bridge, - to_transfer_target, to_target_bridge, &publication); - - /* They can't both be unbridged, you silly goose! */ - if (!to_transferee_bridge && !to_target_bridge) { - res = AST_BRIDGE_TRANSFER_INVALID; - goto end; - } - - ast_channel_lock(to_transferee); - to_transferee_bridge_channel = ast_channel_get_bridge_channel(to_transferee); - ast_channel_unlock(to_transferee); - - ast_channel_lock(to_transfer_target); - to_target_bridge_channel = ast_channel_get_bridge_channel(to_transfer_target); - ast_channel_unlock(to_transfer_target); - - if (to_transferee_bridge_channel) { - /* Take off hold if they are on hold. */ - ast_bridge_channel_write_unhold(to_transferee_bridge_channel); - } - - if (to_target_bridge_channel) { - const char *target_complete_sound; - - /* Take off hold if they are on hold. */ - ast_bridge_channel_write_unhold(to_target_bridge_channel); - - /* Is there a courtesy sound to play to the target? */ - ast_channel_lock(to_transfer_target); - target_complete_sound = pbx_builtin_getvar_helper(to_transfer_target, - "ATTENDED_TRANSFER_COMPLETE_SOUND"); - if (!ast_strlen_zero(target_complete_sound)) { - target_complete_sound = ast_strdupa(target_complete_sound); - } else { - target_complete_sound = NULL; - } - ast_channel_unlock(to_transfer_target); - if (!target_complete_sound) { - ast_channel_lock(to_transferee); - target_complete_sound = pbx_builtin_getvar_helper(to_transferee, - "ATTENDED_TRANSFER_COMPLETE_SOUND"); - if (!ast_strlen_zero(target_complete_sound)) { - target_complete_sound = ast_strdupa(target_complete_sound); - } else { - target_complete_sound = NULL; - } - ast_channel_unlock(to_transferee); - } - if (target_complete_sound) { - ast_bridge_channel_write_playfile(to_target_bridge_channel, NULL, - target_complete_sound, NULL); - } - } - - /* Let's get the easy one out of the way first */ - if (to_transferee_bridge && to_target_bridge) { - - if (!to_transferee_bridge_channel || !to_target_bridge_channel) { - res = AST_BRIDGE_TRANSFER_INVALID; - goto end; - } - - ast_bridge_lock_both(to_transferee_bridge, to_target_bridge); - res = two_bridge_attended_transfer(to_transferee, to_transferee_bridge_channel, - to_transfer_target, to_target_bridge_channel, - to_transferee_bridge, to_target_bridge, &publication); - ast_bridge_unlock(to_transferee_bridge); - ast_bridge_unlock(to_target_bridge); - - goto end; - } - - the_bridge = to_transferee_bridge ?: to_target_bridge; - chan_bridged = to_transferee_bridge ? to_transferee : to_transfer_target; - chan_unbridged = to_transferee_bridge ? to_transfer_target : to_transferee; - - { - int chan_count; - SCOPED_LOCK(lock, the_bridge, ast_bridge_lock, ast_bridge_unlock); - - channels = ast_bridge_peers_nolock(the_bridge); - if (!channels) { - res = AST_BRIDGE_TRANSFER_FAIL; - goto end; - } - chan_count = ao2_container_count(channels); - if (chan_count <= 1) { - res = AST_BRIDGE_TRANSFER_INVALID; - goto end; - } - transfer_prohibited = ast_test_flag(&the_bridge->feature_flags, - AST_BRIDGE_FLAG_TRANSFER_PROHIBITED); - do_bridge_transfer = ast_test_flag(&the_bridge->feature_flags, - AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY) || - chan_count > 2; - } - - if (transfer_prohibited) { - res = AST_BRIDGE_TRANSFER_NOT_PERMITTED; - goto end; - } - - if (do_bridge_transfer) { - res = attended_transfer_bridge(chan_bridged, chan_unbridged, the_bridge, NULL, &publication); - goto end; - } - - transferee = get_transferee(channels, chan_bridged); - if (!transferee) { - res = AST_BRIDGE_TRANSFER_FAIL; - goto end; - } - - app = ast_strdupa(ast_channel_appl(chan_unbridged)); - if (bridge_channel_internal_queue_attended_transfer(transferee, chan_unbridged)) { - res = AST_BRIDGE_TRANSFER_FAIL; - goto end; - } - - ast_bridge_remove(the_bridge, chan_bridged); - - publish_attended_transfer_app(&publication, app); - return AST_BRIDGE_TRANSFER_SUCCESS; - -end: - /* All successful transfer paths have published an appropriate stasis message. - * All failure paths have deferred publishing a stasis message until this point - */ - if (res != AST_BRIDGE_TRANSFER_SUCCESS) { - publish_attended_transfer_fail(&publication, res); - } - stasis_publish_data_cleanup(&publication); - return res; -} - -/*! - * \internal - * \brief Service the bridge manager request. - * \since 12.0.0 - * - * \param bridge requesting service. - * - * \return Nothing - */ -static void bridge_manager_service(struct ast_bridge *bridge) -{ - ast_bridge_lock(bridge); - if (bridge->callid) { - ast_callid_threadassoc_change(bridge->callid); - } - - /* Do any pending bridge actions. */ - bridge_handle_actions(bridge); - ast_bridge_unlock(bridge); -} - -/*! - * \internal - * \brief Bridge manager service thread. - * \since 12.0.0 - * - * \return Nothing - */ -static void *bridge_manager_thread(void *data) -{ - struct bridge_manager_controller *manager = data; - struct bridge_manager_request *request; - - ao2_lock(manager); - while (!manager->stop) { - request = AST_LIST_REMOVE_HEAD(&manager->service_requests, node); - if (!request) { - ast_cond_wait(&manager->cond, ao2_object_get_lockaddr(manager)); - continue; - } - ao2_unlock(manager); - - /* Service the bridge. */ - bridge_manager_service(request->bridge); - ao2_ref(request->bridge, -1); - ast_free(request); - - ao2_lock(manager); - } - ao2_unlock(manager); - - return NULL; -} - -/*! - * \internal - * \brief Destroy the bridge manager controller. - * \since 12.0.0 - * - * \param obj Bridge manager to destroy. - * - * \return Nothing - */ -static void bridge_manager_destroy(void *obj) -{ - struct bridge_manager_controller *manager = obj; - struct bridge_manager_request *request; - - if (manager->thread != AST_PTHREADT_NULL) { - /* Stop the manager thread. */ - ao2_lock(manager); - manager->stop = 1; - ast_cond_signal(&manager->cond); - ao2_unlock(manager); - ast_debug(1, "Waiting for bridge manager thread to die.\n"); - pthread_join(manager->thread, NULL); - } - - /* Destroy the service request queue. */ - while ((request = AST_LIST_REMOVE_HEAD(&manager->service_requests, node))) { - ao2_ref(request->bridge, -1); - ast_free(request); - } - - ast_cond_destroy(&manager->cond); -} - -/*! - * \internal - * \brief Create the bridge manager controller. - * \since 12.0.0 - * - * \retval manager on success. - * \retval NULL on error. - */ -static struct bridge_manager_controller *bridge_manager_create(void) -{ - struct bridge_manager_controller *manager; - - manager = ao2_alloc(sizeof(*manager), bridge_manager_destroy); - if (!manager) { - /* Well. This isn't good. */ - return NULL; - } - ast_cond_init(&manager->cond, NULL); - AST_LIST_HEAD_INIT_NOLOCK(&manager->service_requests); - - /* Create the bridge manager thread. */ - if (ast_pthread_create(&manager->thread, NULL, bridge_manager_thread, manager)) { - /* Well. This isn't good either. */ - manager->thread = AST_PTHREADT_NULL; - ao2_ref(manager, -1); - manager = NULL; - } - - return manager; -} - -/*! - * \internal - * \brief Bridge ao2 container sort function. - * \since 12.0.0 - * - * \param obj_left pointer to the (user-defined part) of an object. - * \param obj_right pointer to the (user-defined part) of an object. - * \param flags flags from ao2_callback() - * OBJ_POINTER - if set, 'obj_right', is an object. - * OBJ_KEY - if set, 'obj_right', is a search key item that is not an object. - * OBJ_PARTIAL_KEY - if set, 'obj_right', is a partial search key item that is not an object. - * - * \retval <0 if obj_left < obj_right - * \retval =0 if obj_left == obj_right - * \retval >0 if obj_left > obj_right - */ -static int bridge_sort_cmp(const void *obj_left, const void *obj_right, int flags) -{ - const struct ast_bridge *bridge_left = obj_left; - const struct ast_bridge *bridge_right = obj_right; - const char *right_key = obj_right; - int cmp; - - switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) { - default: - case OBJ_POINTER: - right_key = bridge_right->uniqueid; - /* Fall through */ - case OBJ_KEY: - cmp = strcmp(bridge_left->uniqueid, right_key); - break; - case OBJ_PARTIAL_KEY: - cmp = strncmp(bridge_left->uniqueid, right_key, strlen(right_key)); - break; - } - return cmp; -} - -static char *complete_bridge(const char *word, int state) -{ - char *ret = NULL; - int wordlen = strlen(word), which = 0; - RAII_VAR(struct ao2_container *, cached_bridges, NULL, ao2_cleanup); - struct ao2_iterator iter; - struct stasis_message *msg; - - if (!(cached_bridges = stasis_cache_dump(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type()))) { - return NULL; - } - - iter = ao2_iterator_init(cached_bridges, 0); - for (; (msg = ao2_iterator_next(&iter)); ao2_ref(msg, -1)) { - struct ast_bridge_snapshot *snapshot = stasis_message_data(msg); - - if (!strncasecmp(word, snapshot->uniqueid, wordlen) && (++which > state)) { - ret = ast_strdup(snapshot->uniqueid); - break; - } - } - ao2_iterator_destroy(&iter); - - return ret; -} - -static char *handle_bridge_show_all(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ -#define FORMAT_HDR "%-36s %5s %-15s %s\n" -#define FORMAT_ROW "%-36s %5u %-15s %s\n" - - RAII_VAR(struct ao2_container *, cached_bridges, NULL, ao2_cleanup); - struct ao2_iterator iter; - struct stasis_message *msg; - - switch (cmd) { - case CLI_INIT: - e->command = "bridge show all"; - e->usage = - "Usage: bridge show all\n" - " List all bridges\n"; - return NULL; - case CLI_GENERATE: - return NULL; - } - - if (!(cached_bridges = stasis_cache_dump(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type()))) { - ast_cli(a->fd, "Failed to retrieve cached bridges\n"); - return CLI_SUCCESS; - } - - ast_cli(a->fd, FORMAT_HDR, "Bridge-ID", "Chans", "Type", "Technology"); - - iter = ao2_iterator_init(cached_bridges, 0); - for (; (msg = ao2_iterator_next(&iter)); ao2_ref(msg, -1)) { - struct ast_bridge_snapshot *snapshot = stasis_message_data(msg); - - ast_cli(a->fd, FORMAT_ROW, - snapshot->uniqueid, - snapshot->num_channels, - S_OR(snapshot->subclass, ""), - S_OR(snapshot->technology, "")); - } - ao2_iterator_destroy(&iter); - return CLI_SUCCESS; - -#undef FORMAT_HDR -#undef FORMAT_ROW -} - -/*! \brief Internal callback function for sending channels in a bridge to the CLI */ -static int bridge_show_specific_print_channel(void *obj, void *arg, int flags) -{ - const char *uniqueid = obj; - struct ast_cli_args *a = arg; - RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup); - struct ast_channel_snapshot *snapshot; - - if (!(msg = stasis_cache_get(ast_channel_topic_all_cached(), ast_channel_snapshot_type(), uniqueid))) { - return 0; - } - snapshot = stasis_message_data(msg); - - ast_cli(a->fd, "Channel: %s\n", snapshot->name); - - return 0; -} - -static char *handle_bridge_show_specific(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ - RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup); - struct ast_bridge_snapshot *snapshot; - - switch (cmd) { - case CLI_INIT: - e->command = "bridge show"; - e->usage = - "Usage: bridge show \n" - " Show information about the bridge\n"; - return NULL; - case CLI_GENERATE: - if (a->pos == 2) { - return complete_bridge(a->word, a->n); - } - return NULL; - } - - if (a->argc != 3) { - return CLI_SHOWUSAGE; - } - - msg = stasis_cache_get(ast_bridge_topic_all_cached(), ast_bridge_snapshot_type(), a->argv[2]); - if (!msg) { - ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]); - return CLI_SUCCESS; - } - - snapshot = stasis_message_data(msg); - ast_cli(a->fd, "Id: %s\n", snapshot->uniqueid); - ast_cli(a->fd, "Type: %s\n", S_OR(snapshot->subclass, "")); - ast_cli(a->fd, "Technology: %s\n", S_OR(snapshot->technology, "")); - ast_cli(a->fd, "Num-Channels: %u\n", snapshot->num_channels); - ao2_callback(snapshot->channels, OBJ_NODATA, bridge_show_specific_print_channel, a); - - return CLI_SUCCESS; -} - -static char *handle_bridge_destroy_specific(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ - struct ast_bridge *bridge; - - switch (cmd) { - case CLI_INIT: - e->command = "bridge destroy"; - e->usage = - "Usage: bridge destroy \n" - " Destroy the bridge\n"; - return NULL; - case CLI_GENERATE: - if (a->pos == 2) { - return complete_bridge(a->word, a->n); - } - return NULL; - } - - if (a->argc != 3) { - return CLI_SHOWUSAGE; - } - - bridge = ao2_find(bridges, a->argv[2], OBJ_KEY); - if (!bridge) { - ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]); - return CLI_SUCCESS; - } - - ast_cli(a->fd, "Destroying bridge '%s'\n", a->argv[2]); - ast_bridge_destroy(bridge); - - return CLI_SUCCESS; -} - -static char *complete_bridge_participant(const char *bridge_name, const char *line, const char *word, int pos, int state) -{ - RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup); - struct ast_bridge_channel *bridge_channel; - int which; - int wordlen; - - bridge = ao2_find(bridges, bridge_name, OBJ_KEY); - if (!bridge) { - return NULL; - } - - { - SCOPED_LOCK(bridge_lock, bridge, ast_bridge_lock, ast_bridge_unlock); - - which = 0; - wordlen = strlen(word); - AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { - if (!strncasecmp(ast_channel_name(bridge_channel->chan), word, wordlen) - && ++which > state) { - return ast_strdup(ast_channel_name(bridge_channel->chan)); - } - } - } - - return NULL; -} - -static char *handle_bridge_kick_channel(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ - RAII_VAR(struct ast_bridge *, bridge, NULL, ao2_cleanup); - RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup); - - switch (cmd) { - case CLI_INIT: - e->command = "bridge kick"; - e->usage = - "Usage: bridge kick \n" - " Kick the channel out of the bridge\n"; - return NULL; - case CLI_GENERATE: - if (a->pos == 2) { - return complete_bridge(a->word, a->n); - } - if (a->pos == 3) { - return complete_bridge_participant(a->argv[2], a->line, a->word, a->pos, a->n); - } - return NULL; - } - - if (a->argc != 4) { - return CLI_SHOWUSAGE; - } - - bridge = ao2_find(bridges, a->argv[2], OBJ_KEY); - if (!bridge) { - ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]); - return CLI_SUCCESS; - } - - chan = ast_channel_get_by_name_prefix(a->argv[3], strlen(a->argv[3])); - if (!chan) { - ast_cli(a->fd, "Channel '%s' not found\n", a->argv[3]); - return CLI_SUCCESS; - } - -/* - * BUGBUG the CLI kick needs to get the bridge to decide if it should dissolve. - * - * Likely the best way to do this is to add a kick method. The - * basic bridge class can then decide to dissolve the bridge if - * one of two channels is kicked. - * - * SIP/foo -- Local;1==Local;2 -- .... -- Local;1==Local;2 -- SIP/bar - * Kick a ;1 channel and the chain toward SIP/foo goes away. - * Kick a ;2 channel and the chain toward SIP/bar goes away. - * - * This can leave a local channel chain between the kicked ;1 - * and ;2 channels that are orphaned until you manually request - * one of those channels to hangup or request the bridge to - * dissolve. - */ - ast_cli(a->fd, "Kicking channel '%s' from bridge '%s'\n", - ast_channel_name(chan), a->argv[2]); - ast_bridge_remove(bridge, chan); - - return CLI_SUCCESS; -} - -/*! Bridge technology capabilities to string. */ -static const char *tech_capability2str(uint32_t capabilities) -{ - const char *type; - - if (capabilities & AST_BRIDGE_CAPABILITY_HOLDING) { - type = "Holding"; - } else if (capabilities & AST_BRIDGE_CAPABILITY_EARLY) { - type = "Early"; - } else if (capabilities & AST_BRIDGE_CAPABILITY_NATIVE) { - type = "Native"; - } else if (capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) { - type = "1to1Mix"; - } else if (capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) { - type = "MultiMix"; - } else { - type = ""; - } - return type; -} - -static char *handle_bridge_technology_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ -#define FORMAT_HDR "%-20s %-20s %8s %s\n" -#define FORMAT_ROW "%-20s %-20s %8d %s\n" - - struct ast_bridge_technology *cur; - - switch (cmd) { - case CLI_INIT: - e->command = "bridge technology show"; - e->usage = - "Usage: bridge technology show\n" - " List registered bridge technologies\n"; - return NULL; - case CLI_GENERATE: - return NULL; - } - - ast_cli(a->fd, FORMAT_HDR, "Name", "Type", "Priority", "Suspended"); - AST_RWLIST_RDLOCK(&bridge_technologies); - AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) { - const char *type; - - /* Decode type for display */ - type = tech_capability2str(cur->capabilities); - - ast_cli(a->fd, FORMAT_ROW, cur->name, type, cur->preference, - AST_CLI_YESNO(cur->suspended)); - } - AST_RWLIST_UNLOCK(&bridge_technologies); - return CLI_SUCCESS; - -#undef FORMAT -} - -static char *complete_bridge_technology(const char *word, int state) -{ - struct ast_bridge_technology *cur; - char *res; - int which; - int wordlen; - - which = 0; - wordlen = strlen(word); - AST_RWLIST_RDLOCK(&bridge_technologies); - AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) { - if (!strncasecmp(cur->name, word, wordlen) && ++which > state) { - res = ast_strdup(cur->name); - AST_RWLIST_UNLOCK(&bridge_technologies); - return res; - } - } - AST_RWLIST_UNLOCK(&bridge_technologies); - return NULL; -} - -static char *handle_bridge_technology_suspend(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) -{ - struct ast_bridge_technology *cur; - int suspend; - int successful; - - switch (cmd) { - case CLI_INIT: - e->command = "bridge technology {suspend|unsuspend}"; - e->usage = - "Usage: bridge technology {suspend|unsuspend} \n" - " Suspend or unsuspend a bridge technology.\n"; - return NULL; - case CLI_GENERATE: - if (a->pos == 3) { - return complete_bridge_technology(a->word, a->n); - } - return NULL; - } - - if (a->argc != 4) { - return CLI_SHOWUSAGE; - } - - suspend = !strcasecmp(a->argv[2], "suspend"); - successful = 0; - AST_RWLIST_WRLOCK(&bridge_technologies); - AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) { - if (!strcasecmp(cur->name, a->argv[3])) { - successful = 1; - if (suspend) { - ast_bridge_technology_suspend(cur); - } else { - ast_bridge_technology_unsuspend(cur); - } - break; - } - } - AST_RWLIST_UNLOCK(&bridge_technologies); - - if (successful) { - if (suspend) { - ast_cli(a->fd, "Suspended bridge technology '%s'\n", a->argv[3]); - } else { - ast_cli(a->fd, "Unsuspended bridge technology '%s'\n", a->argv[3]); - } - } else { - ast_cli(a->fd, "Bridge technology '%s' not found\n", a->argv[3]); - } - - return CLI_SUCCESS; -} - -static struct ast_cli_entry bridge_cli[] = { - AST_CLI_DEFINE(handle_bridge_show_all, "List all bridges"), - AST_CLI_DEFINE(handle_bridge_show_specific, "Show information about a bridge"), - AST_CLI_DEFINE(handle_bridge_destroy_specific, "Destroy a bridge"), - AST_CLI_DEFINE(handle_bridge_kick_channel, "Kick a channel from a bridge"), - AST_CLI_DEFINE(handle_bridge_technology_show, "List registered bridge technologies"), - AST_CLI_DEFINE(handle_bridge_technology_suspend, "Suspend/unsuspend a bridge technology"), -}; - -/*! - * \internal - * \brief Shutdown the bridging system. - * \since 12.0.0 - * - * \return Nothing - */ -static void bridge_shutdown(void) -{ - ast_cli_unregister_multiple(bridge_cli, ARRAY_LEN(bridge_cli)); - ao2_cleanup(bridges); - bridges = NULL; - ao2_cleanup(bridge_manager); - bridge_manager = NULL; -} - -int ast_bridging_init(void) -{ - ast_register_atexit(bridge_shutdown); - - if (ast_stasis_bridging_init()) { - return -1; - } - - bridge_manager = bridge_manager_create(); - if (!bridge_manager) { - return -1; - } - - bridges = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX, - AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, bridge_sort_cmp, NULL); - if (!bridges) { - return -1; - } - - ast_bridging_init_basic(); - -/* BUGBUG need AMI action equivalents to the CLI commands. */ - ast_cli_register_multiple(bridge_cli, ARRAY_LEN(bridge_cli)); - - return 0; -} -- cgit v1.2.3