bridge.c File Reference

Bridging API. More...

#include "asterisk.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_internal.h"
#include "asterisk/bridge_channel_internal.h"
#include "asterisk/bridge_features.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/bridge_technology.h"
#include "asterisk/bridge_channel.h"
#include "asterisk/bridge_after.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_cache_pattern.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"
#include "asterisk/causes.h"

Include dependency graph for bridge.c:

Go to the source code of this file.

Data Structures
struct	bridge_channel_impart_cond
	Internal bridge impart wait condition and associated conditional. More...
struct	bridge_channel_impart_ds_head
struct	bridge_manager_controller
struct	bridge_manager_request
struct	bridge_technologies
struct	merge_direction
struct	tech_deferred_destroy

Macros
#define	ATTENDEDTRANSFER   "ATTENDEDTRANSFER"
#define	BLINDTRANSFER   "BLINDTRANSFER"
#define	BRIDGE_ARRAY_GROW   32
#define	BRIDGE_ARRAY_START   128
#define	BRIDGE_LOCK_ONE_OR_BOTH(b1, b2)
#define	FORMAT_HDR   "%-36s %5s %-15s %-15s %s\n"
#define	FORMAT_HDR   "%-20s %-20s %8s %s\n"
#define	FORMAT_ROW   "%-36s %5u %-15s %-15s %s\n"
#define	FORMAT_ROW   "%-20s %-20s %8u %s\n"
#define	MAX_BRIDGEPEER_CHANS   (10 + 1)
#define	UPDATE_BRIDGE_VARS_GET(chan, name, pvtid)

Enumerations
enum	bridge_allow_merge { MERGE_PROHIBITED, MERGE_NOT_ENOUGH_CHANNELS, MERGE_NO_MULTIMIX, MERGE_ALLOWED }
enum	bridge_allow_swap { SWAP_PROHIBITED, SWAP_TO_CHAN_BRIDGE, SWAP_TO_PEER_BRIDGE }

Functions
int	__ast_bridge_technology_register (struct ast_bridge_technology *technology, struct ast_module *module)
	Register a bridge technology for use. More...
int	ast_bridge_add_channel (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_bridge_features *features, int play_tone, const char *xfersound)
	Add an arbitrary channel to a bridge. More...
struct ast_bridge *	ast_bridge_base_new (uint32_t capabilities, unsigned int flags, const char *creator, const char *name, const char *id)
	Create a new base class bridge. More...
int	ast_bridge_depart (struct ast_channel *chan)
	Depart a channel from a bridge. More...
int	ast_bridge_destroy (struct ast_bridge *bridge, int cause)
	Destroy a bridge. More...
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)
	Attach a DTMF hook to a bridge features structure. More...
void	ast_bridge_features_cleanup (struct ast_bridge_features *features)
	Clean up the contents of a bridge features structure. More...
void	ast_bridge_features_destroy (struct ast_bridge_features *features)
	Destroy an allocated bridge features struct. More...
int	ast_bridge_features_do (enum ast_bridge_builtin_feature feature, struct ast_bridge_channel *bridge_channel, void *hook_pvt)
	Invoke a built in feature hook now. More...
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)
	Enable a built in feature on a bridge features structure. More...
int	ast_bridge_features_init (struct ast_bridge_features *features)
	Initialize bridge features structure. More...
int	ast_bridge_features_limits_construct (struct ast_bridge_features_limits *limits)
	Constructor function for ast_bridge_features_limits. More...
void	ast_bridge_features_limits_destroy (struct ast_bridge_features_limits *limits)
	Destructor function for ast_bridge_features_limits. More...
void	ast_bridge_features_merge (struct ast_bridge_features *into, const struct ast_bridge_features *from)
	Merge one ast_bridge_features into another. More...
struct ast_bridge_features *	ast_bridge_features_new (void)
	Allocate a new bridge features struct. More...
int	ast_bridge_features_register (enum ast_bridge_builtin_feature feature, ast_bridge_hook_callback callback, const char *dtmf)
	Register a handler for a built in feature. More...
void	ast_bridge_features_remove (struct ast_bridge_features *features, enum ast_bridge_hook_remove_flags remove_flags)
	Remove marked bridge channel feature hooks. More...
void	ast_bridge_features_set_flag (struct ast_bridge_features *features, unsigned int flag)
	Set a flag on a bridge channel features structure. More...
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)
	Limit the amount of time a channel may stay in the bridge and optionally play warning messages as time runs out. More...
int	ast_bridge_features_unregister (enum ast_bridge_builtin_feature feature)
	Unregister a handler for a built in feature. More...
struct ast_bridge *	ast_bridge_find_by_id (const char *bridge_id)
	Find bridge by id. More...
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)
	Attach a hangup hook to a bridge features structure. More...
int	ast_bridge_impart (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, enum ast_bridge_impart_flags flags)
	Impart a channel to a bridge (non-blocking) More...
int	ast_bridge_interval_hook (struct ast_bridge_features *features, enum ast_bridge_hook_timer_option flags, 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)
	Attach an interval hook to a bridge features structure. More...
int	ast_bridge_interval_register (enum ast_bridge_builtin_interval interval, ast_bridge_builtin_set_limits_fn callback)
	Register a handler for a built in interval feature. More...
int	ast_bridge_interval_unregister (enum ast_bridge_builtin_interval interval)
int	ast_bridge_is_video_src (struct ast_bridge *bridge, struct ast_channel *chan)
	Determine if a channel is a video src for the bridge. More...
int	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, enum ast_bridge_join_flags flags)
	Join a channel to a bridge (blocking) More...
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)
	Unregisters a handler for a built in interval feature. More...
int	ast_bridge_kick (struct ast_bridge *bridge, struct ast_channel *chan)
	Kick a channel from a bridge. More...
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)
	Attach a bridge channel leave hook to a bridge features structure. More...
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)
	Merge two bridges together. More...
void	ast_bridge_merge_inhibit (struct ast_bridge *bridge, int request)
	Adjust the bridge merge inhibit request count. More...
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)
	Move a channel from one bridge to another. More...
int	ast_bridge_move_hook (struct ast_bridge_features *features, ast_bridge_move_indicate_callback callback, void *hook_pvt, ast_bridge_hook_pvt_destructor destructor, enum ast_bridge_hook_remove_flags remove_flags)
	Attach a bridge channel move detection hook to a bridge features structure. More...
void	ast_bridge_notify_masquerade (struct ast_channel *chan)
	Notify bridging that this channel was just masqueraded. More...
int	ast_bridge_number_video_src (struct ast_bridge *bridge)
	Returns the number of video sources currently active in the bridge. More...
struct ast_channel *	ast_bridge_peer (struct ast_bridge *bridge, struct ast_channel *chan)
	Get the channel's bridge peer only if the bridge is two-party. More...
struct ast_channel *	ast_bridge_peer_nolock (struct ast_bridge *bridge, struct ast_channel *chan)
	Get the channel's bridge peer only if the bridge is two-party. More...
struct ao2_container *	ast_bridge_peers (struct ast_bridge *bridge)
	Get a container of all channels in the bridge. More...
struct ao2_container *	ast_bridge_peers_nolock (struct ast_bridge *bridge)
	Get a container of all channels in the bridge. More...
int	ast_bridge_queue_action (struct ast_bridge *bridge, struct ast_frame *action)
	Put an action onto the specified bridge. More...
int	ast_bridge_remove (struct ast_bridge *bridge, struct ast_channel *chan)
	Remove a channel from a bridge. More...
void	ast_bridge_remove_video_src (struct ast_bridge *bridge, struct ast_channel *chan)
	remove a channel as a source of video for the bridge. More...
void	ast_bridge_set_binaural_active (struct ast_bridge *bridge, unsigned int binaural_active)
	Activates the use of binaural signals in a conference bridge. More...
void	ast_bridge_set_internal_sample_rate (struct ast_bridge *bridge, unsigned int sample_rate)
	Adjust the internal mixing sample rate of a bridge used during multimix mode. More...
void	ast_bridge_set_maximum_sample_rate (struct ast_bridge *bridge, unsigned int sample_rate)
	Adjust the maximum mixing sample rate of a bridge used during multimix mode. More...
void	ast_bridge_set_mixing_interval (struct ast_bridge *bridge, unsigned int mixing_interval)
	Adjust the internal mixing interval of a bridge used during multimix mode. More...
void	ast_bridge_set_remb_estimated_bitrate (struct ast_bridge *bridge, float estimated_bitrate)
	Force the REMB report estimated bitrate to a specific max value. More...
void	ast_bridge_set_remb_send_interval (struct ast_bridge *bridge, unsigned int remb_send_interval)
	Set the interval at which a combined REMB frame will be sent to video sources. More...
void	ast_bridge_set_send_sdp_label (struct ast_bridge *bridge, unsigned int send_sdp_label)
	Controls whether to send a "label" attribute in each stream in an SDP. More...
void	ast_bridge_set_sfu_video_mode (struct ast_bridge *bridge)
	Set the bridge to be a selective forwarding unit. More...
void	ast_bridge_set_single_src_video_mode (struct ast_bridge *bridge, struct ast_channel *video_src_chan)
	Set a bridge to feed a single video source to all participants. More...
void	ast_bridge_set_talker_src_video_mode (struct ast_bridge *bridge)
	Set the bridge to pick the strongest talker supporting video as the single source video feed. More...
void	ast_bridge_set_transfer_variables (struct ast_channel *chan, const char *value, int attended)
	Set the relevant transfer variables for a single channel. More...
void	ast_bridge_set_video_update_discard (struct ast_bridge *bridge, unsigned int video_update_discard)
	Set the amount of time to discard subsequent video updates after a video update has been sent. More...
int	ast_bridge_suspend (struct ast_bridge *bridge, struct ast_channel *chan)
	Suspend a channel temporarily from a bridge. More...
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)
	Attach a bridge channel talk detection hook to a bridge features structure. More...
void	ast_bridge_technology_suspend (struct ast_bridge_technology *technology)
	Suspend a bridge technology from consideration. More...
int	ast_bridge_technology_unregister (struct ast_bridge_technology *technology)
	Unregister a bridge technology from use. More...
void	ast_bridge_technology_unsuspend (struct ast_bridge_technology *technology)
	Unsuspend a bridge technology. More...
struct ast_bridge *	ast_bridge_transfer_acquire_bridge (struct ast_channel *chan)
	Acquire the channel's bridge for transfer purposes. More...
enum ast_transfer_result	ast_bridge_transfer_attended (struct ast_channel *to_transferee, struct ast_channel *to_transfer_target)
	Attended transfer. More...
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)
	Blind transfer target to the extension and context provided. More...
int	ast_bridge_unreal_optimize_out (struct ast_channel *chan, struct ast_channel *peer, struct ast_unreal_pvt *pvt)
	Check and optimize out the unreal channels between bridges. More...
int	ast_bridge_unsuspend (struct ast_bridge *bridge, struct ast_channel *chan)
	Unsuspend a channel from a bridge. More...
void	ast_bridge_update_talker_src_video_mode (struct ast_bridge *bridge, struct ast_channel *chan, int talker_energy, int is_keyframe)
	Update information about talker energy for talker src video mode. More...
void	ast_bridge_vars_set (struct ast_channel *chan, const char *name, const char *pvtid)
	Sets BRIDGECHANNEL and BRIDGEPVTCALLID for a channel. More...
const char *	ast_bridge_video_mode_to_string (enum ast_bridge_video_mode_type video_mode)
	Converts an enum representation of a bridge video mode to string. More...
struct ao2_container *	ast_bridges (void)
	Returns the global bridges container. More...
enum ast_bridge_optimization	ast_bridges_allow_optimization (struct ast_bridge *chan_bridge, struct ast_bridge *peer_bridge)
	Determine if bridges allow for optimization to occur betweem them. More...
int	ast_bridging_init (void)
	Initialize the bridging system. More...
void	ast_brige_set_remb_behavior (struct ast_bridge *bridge, enum ast_bridge_video_sfu_remb_behavior behavior)
	Set the REMB report generation behavior on a bridge. More...
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 ast_attended_transfer_message *transfer_msg)
	Perform an attended transfer of a bridge. More...
static enum ast_transfer_result	blind_transfer_bridge (int is_external, struct ast_channel *transferer, struct ast_bridge *bridge, const char *exten, const char *context, struct ast_channel *transferee, transfer_channel_cb new_channel_cb, struct transfer_channel_data *user_data_wrapper, struct ast_blind_transfer_message *transfer_message)
static void	bridge_action_bridge (struct ast_bridge *bridge, struct ast_frame *action)
struct ast_bridge *	bridge_alloc (size_t size, const struct ast_bridge_methods *v_table)
static int	bridge_allows_optimization (struct ast_bridge *bridge)
static void	bridge_base_destroy (struct ast_bridge *self)
static void	bridge_base_dissolving (struct ast_bridge *self)
static int	bridge_base_get_merge_priority (struct ast_bridge *self)
struct ast_bridge *	bridge_base_init (struct ast_bridge *self, uint32_t capabilities, unsigned int flags, const char *creator, const char *name, const char *id)
	Initialize the base class of the bridge. More...
static void	bridge_base_notify_masquerade (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
static void	bridge_base_pull (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel)
static int	bridge_base_push (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
static int	bridge_base_push_peek (struct ast_bridge *self, struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
static void	bridge_channel_change_bridge (struct ast_bridge_channel *bridge_channel, struct ast_bridge *new_bridge)
static void	bridge_channel_complete_join (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
static void *	bridge_channel_depart_thread (void *data)
	Thread responsible for imparted bridged channels to be departed. More...
static int	bridge_channel_impart_add (struct ast_channel *chan, struct bridge_channel_impart_cond *cond)
static void	bridge_channel_impart_ds_head_dtor (void *doomed)
static void	bridge_channel_impart_ds_head_fixup (void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
static void	bridge_channel_impart_ds_head_signal (struct bridge_channel_impart_ds_head *ds_head)
void	bridge_channel_impart_signal (struct ast_channel *chan)
	Signal imparting threads to wake up. More...
static void	bridge_channel_impart_wait (struct bridge_channel_impart_cond *cond)
static void *	bridge_channel_ind_thread (void *data)
	Thread responsible for independent imparted bridged channels. More...
static void	bridge_channel_moving (struct ast_bridge_channel *bridge_channel, struct ast_bridge *src, struct ast_bridge *dst)
static void	bridge_cleanup (void)
static void	bridge_complete_join (struct ast_bridge *bridge)
void	bridge_dissolve (struct ast_bridge *bridge, int cause)
static void	bridge_dissolve_check_stolen (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel)
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)
int	bridge_do_move (struct ast_bridge *dst_bridge, struct ast_bridge_channel *bridge_channel, int attempt_recovery, unsigned int optimized)
static int	bridge_dtmf_hook_sort (const void *obj_left, const void *obj_right, int flags)
struct ast_bridge_channel *	bridge_find_channel (struct ast_bridge *bridge, struct ast_channel *chan)
static void	bridge_handle_actions (struct ast_bridge *bridge)
static void	bridge_hook_destroy (void *vhook)
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)
static int	bridge_impart_internal (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, enum ast_bridge_impart_flags flags, struct bridge_channel_impart_cond *cond)
static struct bridge_manager_controller *	bridge_manager_create (void)
static void	bridge_manager_destroy (void *obj)
static void	bridge_manager_service (struct ast_bridge *bridge)
static void	bridge_manager_service_req (struct ast_bridge *bridge)
static void *	bridge_manager_thread (void *data)
static struct merge_direction	bridge_merge_determine_direction (struct ast_bridge *bridge1, struct ast_bridge *bridge2)
void	bridge_merge_inhibit_nolock (struct ast_bridge *bridge, int request)
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)
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)
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)
static void	bridge_prnt_obj (void *v_obj, void *where, ao2_prnt_fn *prnt)
static void	bridge_queue_action_nodup (struct ast_bridge *bridge, struct ast_frame *action)
void	bridge_reconfigured (struct ast_bridge *bridge, unsigned int colp_update)
static void	bridge_reconfigured_connected_line_update (struct ast_bridge *bridge)
struct ast_bridge *	bridge_register (struct ast_bridge *bridge)
	Register the new bridge with the system. More...
static int	bridge_show_specific_print_channel (void *obj, void *arg, int flags)
	Internal callback function for sending channels in a bridge to the CLI. More...
static int	bridge_sort_cmp (const void *obj_left, const void *obj_right, int flags)
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)
static void	bridge_tech_deferred_destroy (struct ast_bridge *bridge, struct ast_frame *action)
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)
static enum bridge_allow_swap	bridges_allow_swap_optimization (struct ast_bridge *chan_bridge, struct ast_bridge *peer_bridge)
static int	channel_cmp (void *obj, void *arg, int flags)
static int	channel_hash (const void *obj, int flags)
static void	check_bridge_play_sound (struct ast_bridge_channel *bridge_channel)
static void	check_bridge_play_sounds (struct ast_bridge *bridge)
static void	cleanup_video_mode (struct ast_bridge *bridge)
static char *	complete_bridge_live (const char *word)
static int	complete_bridge_live_search (void *obj, void *arg, int flags)
static char *	complete_bridge_participant (const char *bridge_name, const char *word)
static char *	complete_bridge_technology (const char *word)
static void	destroy_bridge (void *obj)
static void	fill_bridgepeer_buf (char *buf, unsigned int cur_idx, const char *names[], unsigned int num_names)
static struct ast_bridge_technology *	find_best_technology (uint32_t capabilities, struct ast_bridge *bridge)
	Helper function used to find the "best" bridge technology given specified capabilities. More...
static struct ast_channel *	get_transferee (struct ao2_container *channels, struct ast_channel *transferer)
static char *	handle_bridge_destroy_specific (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bridge_kick_channel (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bridge_show_all (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bridge_show_specific (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bridge_technology_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_bridge_technology_suspend (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	handle_manager_bridge_tech_suspend (struct mansession *s, const struct message *m, int suspend)
static int	hook_remove_match (void *obj, void *arg, int flags)
static void	hooks_remove_container (struct ao2_container *hooks, enum ast_bridge_hook_remove_flags remove_flags)
static void	hooks_remove_heap (struct ast_heap *hooks, enum ast_bridge_hook_remove_flags remove_flags)
static int	interval_hook_time_cmp (void *a, void *b)
static int	interval_wrapper_cb (struct ast_bridge_channel *bridge_channel, void *obj)
	Wrapper for interval hooks that calls into the wrapped hook. More...
static void	interval_wrapper_pvt_dtor (void *obj)
	Destructor for the hook wrapper. More...
static void	kick_it (struct ast_bridge_channel *bridge_channel, const void *payload, size_t payload_size)
static int	manager_bridge_tech_list (struct mansession *s, const struct message *m)
static int	manager_bridge_tech_suspend (struct mansession *s, const struct message *m)
static int	manager_bridge_tech_unsuspend (struct mansession *s, const struct message *m)
static int	merge_container_cb (void *obj, void *data, int flags)
	Callback for merging hook ao2_containers. More...
static struct ast_bridge *	optimize_lock_chan_stack (struct ast_channel *chan)
static struct ast_bridge *	optimize_lock_peer_stack (struct ast_channel *peer)
static void	set_bridge_peer_vars (struct ast_bridge *bridge)
static void	set_bridge_peer_vars_2party (struct ast_channel *c0, struct ast_channel *c1)
static void	set_bridge_peer_vars_holding (struct ast_bridge *bridge)
static void	set_bridge_peer_vars_multiparty (struct ast_bridge *bridge)
static void	set_transfer_variables_all (struct ast_channel *transferer, struct ao2_container *channels, int is_attended)
static int	smart_bridge_operation (struct ast_bridge *bridge)
static const char *	tech_capability2str (uint32_t capabilities)
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)
static enum ast_transfer_result	try_parking (struct ast_channel *transferer, const char *context, const char *exten, transfer_channel_cb new_channel_cb, struct transfer_channel_data *user_data_wrapper)
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)
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 ast_attended_transfer_message *transfer_msg)
static void	wrap_hook (struct ast_bridge_features *features, struct ast_bridge_hook_timer *hook)
	Wrap the provided interval hook and add it to features. More...

Variables
struct ast_bridge_methods	ast_bridge_base_v_table
	Bridge base class virtual method table. More...
static const struct ast_datastore_info	bridge_channel_impart_ds_info
static struct ast_cli_entry	bridge_cli []
static struct bridge_manager_controller *	bridge_manager
static struct bridge_technologies	bridge_technologies = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct ao2_container *	bridges
static char	builtin_features_dtmf [AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING]
static ast_bridge_hook_callback	builtin_features_handlers [AST_BRIDGE_BUILTIN_END]
static ast_bridge_builtin_set_limits_fn	builtin_interval_handlers [AST_BRIDGE_BUILTIN_INTERVAL_END]
static unsigned int	optimization_id

Detailed Description

Bridging API.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file bridge.c.

Macro Definition Documentation

ATTENDEDTRANSFER

#define ATTENDEDTRANSFER   "ATTENDEDTRANSFER"

Definition at line 139 of file bridge.c.

Referenced by ast_bridge_set_transfer_variables(), and attended_transfer_bridge().

BLINDTRANSFER

#define BLINDTRANSFER   "BLINDTRANSFER"

Definition at line 136 of file bridge.c.

Referenced by ast_bridge_set_transfer_variables(), and blind_transfer_bridge().

BRIDGE_ARRAY_GROW

#define BRIDGE_ARRAY_GROW   32

Definition at line 133 of file bridge.c.

BRIDGE_ARRAY_START

#define BRIDGE_ARRAY_START   128

Definition at line 130 of file bridge.c.

BRIDGE_LOCK_ONE_OR_BOTH

#define BRIDGE_LOCK_ONE_OR_BOTH	(		b1,
			b2
	)

Referenced by attended_transfer_bridge().

FORMAT_HDR [1/2]

#define FORMAT_HDR   "%-36s %5s %-15s %-15s %s\n"

Referenced by handle_bridge_show_all(), and handle_bridge_technology_show().

FORMAT_HDR [2/2]

#define FORMAT_HDR   "%-20s %-20s %8s %s\n"

FORMAT_ROW [1/2]

#define FORMAT_ROW   "%-36s %5u %-15s %-15s %s\n"

Referenced by handle_bridge_show_all(), and handle_bridge_technology_show().

FORMAT_ROW [2/2]

#define FORMAT_ROW   "%-20s %-20s %8u %s\n"

MAX_BRIDGEPEER_CHANS

#define MAX_BRIDGEPEER_CHANS   (10 + 1)

Referenced by set_bridge_peer_vars_multiparty().

UPDATE_BRIDGE_VARS_GET

#define UPDATE_BRIDGE_VARS_GET	(		chan,
			name,
			pvtid
	)

Referenced by set_bridge_peer_vars_2party().

Enumeration Type Documentation

bridge_allow_merge

enum bridge_allow_merge

Enumerator
MERGE_PROHIBITED	Bridge properties prohibit merge optimization
MERGE_NOT_ENOUGH_CHANNELS	Merge optimization cannot occur because the source bridge has too few channels
MERGE_NO_MULTIMIX	Merge optimization cannot occur because multimix capability could not be requested
MERGE_ALLOWED	Merge optimization allowed between bridges

Definition at line 2859 of file bridge.c.

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

bridge_allow_swap

enum bridge_allow_swap

Enumerator
SWAP_PROHIBITED	Bridges cannot allow for a swap optimization to occur
SWAP_TO_CHAN_BRIDGE	Bridge swap optimization can occur into the chan_bridge
SWAP_TO_PEER_BRIDGE	Bridge swap optimization can occur into the peer_bridge

Definition at line 2720 of file bridge.c.

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

Function Documentation

__ast_bridge_technology_register()

int __ast_bridge_technology_register	(	struct ast_bridge_technology *	technology,
		struct ast_module *	mod
	)

Register a bridge technology for use.

Parameters

technology	The bridge technology to register
mod	The module that is registering the bridge technology

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_technology_register(&simple_bridge_tech);

This registers a bridge technology declared as the structure simple_bridge_tech with the bridging core and makes it available for use when creating bridges.

Definition at line 214 of file bridge.c.

References ast_log, AST_RWLIST_INSERT_BEFORE_CURRENT, AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero, ast_verb, ast_bridge_technology::capabilities, LOG_WARNING, ast_bridge_technology::mod, ast_bridge_technology::name, ast_bridge_technology::preference, and ast_bridge_technology::write.

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

   /* Find the correct position to insert the technology. */
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) {
      /* Put the highest preference tech's first in the list. */
      if (technology->preference >= current->preference) {
         AST_RWLIST_INSERT_BEFORE_CURRENT(technology, entry);

         break;
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END;

   if (!current) {
      /* Insert our new bridge technology to the end of the list. */
      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;
}

ast_bridge_add_channel()

int ast_bridge_add_channel	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan,
		struct ast_bridge_features *	features,
		int	play_tone,
		const char *	xfersound
	)

Add an arbitrary channel to a bridge.

Since

12.0.0

The channel that is being added to the bridge can be in any state: unbridged, bridged, answered, unanswered, etc. The channel will be added asynchronously, meaning that when this function returns once the channel has been added to the bridge, not once the channel has been removed from the bridge.

In addition, a tone can optionally be played to the channel once the channel is placed into the bridge.

Note

When this function returns, there is no guarantee that the channel that was passed in is valid any longer. Do not attempt to operate on the channel after this function returns.

Parameters

bridge	Bridge to which the channel should be added
chan	The channel to add to the bridge
features	Features for this channel in the bridge
play_tone	Indicates if a tone should be played to the channel
xfersound	Sound that should be used to indicate transfer with play_tone

Note

The features parameter must be NULL or obtained by ast_bridge_features_new(). You must not dereference features after calling even if the call fails.

Return values

0	Success
-1	Failure

Definition at line 2519 of file bridge.c.

References ao2_cleanup, ast_answer(), ast_assert, ast_bridge_channel_queue_playfile(), ast_bridge_features_destroy(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, ast_bridge_lock_both, ast_bridge_unlock, ast_channel_get_bridge(), ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_name(), ast_channel_pbx(), ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_channel_yank(), ast_hangup(), ast_log, ast_moh_stop(), AST_STATE_UP, ast_strlen_zero, bridge_dissolve_check_stolen(), bridge_find_channel(), bridge_move_locked(), LOG_WARNING, NULL, and RAII_VAR.

Referenced by action_bridge(), bridge_exec(), and manager_park_unbridged().

{
   RAII_VAR(struct ast_bridge *, chan_bridge, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel *, yanked_chan, NULL, ao2_cleanup);

   ast_moh_stop(chan);

   ast_channel_lock(chan);
   chan_bridge = ast_channel_get_bridge(chan);
   ast_channel_unlock(chan);

   if (chan_bridge) {
      struct ast_bridge_channel *bridge_channel;

      /* The channel is in a bridge so it is not getting any new features. */
      ast_bridge_features_destroy(features);

      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);
   } 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));
         ast_bridge_features_destroy(features);
         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,
         AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
         /* It is possible for us to yank a channel and have some other
          * thread start a PBX on the channl after we yanked it. In particular,
          * this can theoretically happen on the ;2 of a Local channel if we
          * yank it prior to the ;1 being answered. Make sure that it isn't
          * executing a PBX before hanging it up.
          */
         if (ast_channel_pbx(yanked_chan)) {
            ast_channel_unref(yanked_chan);
         } else {
            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;
}

ast_bridge_base_new()

struct ast_bridge* ast_bridge_base_new	(	uint32_t	capabilities,
		unsigned int	flags,
		const char *	creator,
		const char *	name,
		const char *	id
	)

Create a new base class bridge.

Parameters

capabilities	The capabilities that we require to be used on the bridge
flags	Flags that will alter the behavior of the bridge
creator	Entity that created the bridge (optional)
name	Name given to the bridge by its creator (optional, requires named creator)
id	Unique ID given to the bridge by its creator (optional)

Return values

a	pointer to a new bridge on success
NULL	on failure

Example usage:

struct ast_bridge *bridge;
bridge = ast_bridge_base_new(AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_FLAG_DISSOLVE_HANGUP);

This creates a no frills two party bridge that will be destroyed once one of the channels hangs up.

Definition at line 960 of file bridge.c.

References bridge_manager_request::bridge, bridge_alloc(), bridge_base_init(), and bridge_register().

Referenced by AST_TEST_DEFINE(), get_wait_bridge_wrapper(), and join_conference_bridge().

{
   void *bridge;

   bridge = bridge_alloc(sizeof(struct ast_bridge), &ast_bridge_base_v_table);
   bridge = bridge_base_init(bridge, capabilities, flags, creator, name, id);
   bridge = bridge_register(bridge);
   return bridge;
}

ast_bridge_depart()

int ast_bridge_depart

(

struct ast_channel *

chan

)

Depart a channel from a bridge.

Parameters

chan	Channel to depart

Note

chan is locked by this function.

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_depart(chan);

This removes the channel pointed to by the chan pointer from any bridge it may be in and gives control to the calling thread. This does not hang up the channel.

Note

This API call can only be used on channels that were added to the bridge using the ast_bridge_impart API call with the AST_BRIDGE_IMPART_CHAN_DEPARTABLE flag.

Definition at line 1952 of file bridge.c.

References ao2_ref, ast_assert, ast_bridge_channel_leave_bridge(), AST_CAUSE_NORMAL_CLEARING, ast_channel_internal_bridge_channel(), ast_channel_internal_bridge_channel_set(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, ast_log, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, ast_bridge_channel::chan, ast_bridge_channel::depart_wait, LOG_ERROR, NULL, SCOPE_TRACE, and ast_bridge_channel::thread.

Referenced by app_control_continue(), AST_TEST_DEFINE(), control_swap_channel_in_bridge(), depart_channel(), and stasis_app_exec().

{
   struct ast_bridge_channel *bridge_channel;
   int departable;
   SCOPE_TRACE(1, "%s\n", ast_channel_name(chan));

   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 bridge_channel reference held by
    * bridge_channel_depart_thread().
    */

   ast_bridge_channel_leave_bridge(bridge_channel,
      BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);

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

ast_bridge_destroy()

int ast_bridge_destroy	(	struct ast_bridge *	bridge,
		int	cause
	)

Destroy a bridge.

Parameters

bridge	Bridge to destroy
cause	Cause of bridge being destroyed. (If cause <= 0 then use AST_CAUSE_NORMAL_CLEARING)

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_destroy(bridge, AST_CAUSE_NORMAL_CLEARING);

This destroys a bridge that was previously created.

Note

While this function will kick all channels out of the bridge, channels that were added to the bridge using ast_bridge_impart() with the flag AST_BRIDGE_IMPART_CHAN_DEPARTABLE set must have ast_bridge_depart() called on them.

Definition at line 970 of file bridge.c.

References ao2_ref, ast_bridge_lock, ast_bridge_unlock, ast_debug, bridge_dissolve(), and ast_bridge::uniqueid.

Referenced by action_bridge(), agent_connect_caller(), agent_logout(), agent_pvt_destructor(), agent_request_exec(), agent_run(), ast_bridge_call_with_flags(), attended_transfer_properties_shutdown(), bridge_create_common(), bridge_exec(), bridge_register(), caller_abort_agent(), destroy_conference_bridge(), fail_enter(), handle_bridge_destroy_specific(), manager_bridge_destroy(), parked_call_app_exec(), parking_lot_destructor(), safe_bridge_destroy(), stasis_app_bridge_destroy(), stasis_app_control_shutdown(), unload_module(), wait_bridge_wrapper_alloc(), and wait_bridge_wrapper_destructor().

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

   ao2_ref(bridge, -1);

   return 0;
}

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

Attach a DTMF hook to a bridge features structure.

Parameters

features	Bridge features structure
dtmf	DTMF string to be activated upon
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_dtmf_hook(&features, "#", pound_callback, NULL, NULL, 0);

This makes the bridging core call pound_callback if a channel that has this feature structure inputs the DTMF string '#'. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3245 of file bridge.c.

References ao2_link, ao2_ref, AST_BRIDGE_HOOK_TYPE_DTMF, ast_copy_string(), bridge_hook_generic(), ast_bridge_hook_dtmf_parms::code, ast_bridge_hook::destructor, ast_bridge_hook_dtmf::dtmf, ast_bridge_features::dtmf_hooks, ast_bridge_hook_dtmf::generic, NULL, and ast_bridge_hook::type.

Referenced by apply_menu_to_user(), ast_bridge_features_enable(), AST_TEST_DEFINE(), bridge_agent_hold_push(), bridge_personality_atxfer_push(), and dynamic_dtmf_hook_add().

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

ast_bridge_features_cleanup()

void ast_bridge_features_cleanup

(

struct ast_bridge_features *

features

)

Clean up the contents of a bridge features structure.

Parameters

features

Bridge features structure

Returns

Nothing

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_features_cleanup(&features);

This cleans up the feature structure 'features'.

Note

This MUST be called after the features structure is done being used or a memory leak may occur.

Definition at line 3720 of file bridge.c.

References ao2_cleanup, ao2_ref, ast_heap_destroy(), ast_heap_pop(), ast_bridge_features::dtmf_hooks, ast_bridge_features::interval_hooks, NULL, and ast_bridge_features::other_hooks.

Referenced by agent_request_exec(), agent_run(), ast_bridge_call_with_flags(), ast_bridge_features_destroy(), AST_TEST_DEFINE(), bridge_exec(), bridgeadd_exec(), bridgewait_exec(), channel_feature_hooks_set_full(), confbridge_exec(), park_and_announce_app_exec(), park_app_exec(), and parked_call_app_exec().

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

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

ast_bridge_features_destroy()

void ast_bridge_features_destroy

(

struct ast_bridge_features *

features

)

Destroy an allocated bridge features struct.

Since

12.0.0

Parameters

features

Bridge features structure

Example usage:

struct ast_bridge_features *features;
features = ast_bridge_features_new();
ast_bridge_features_destroy(features);

Returns

Nothing

Definition at line 3741 of file bridge.c.

References ast_bridge_features_cleanup(), and ast_free.

Referenced by ast_bridge_add_channel(), ast_bridge_call_with_flags(), ast_bridge_features_new(), ast_local_setup_bridge(), bridge_channel_depart_thread(), bridge_channel_ind_thread(), bridge_exec(), bridge_impart_internal(), conf_start_record(), control_dtor(), features_destroy(), and local_pvt_destructor().

{
   if (!features) {
      return;
   }
   ast_bridge_features_cleanup(features);
   ast_free(features);
}

ast_bridge_features_do()

int ast_bridge_features_do	(	enum ast_bridge_builtin_feature	feature,
		struct ast_bridge_channel *	bridge_channel,
		void *	hook_pvt
	)

Invoke a built in feature hook now.

Parameters

feature	The feature to invoke
bridge_channel	Channel executing the feature
hook_pvt	Private data passed in when the hook was created

Note

This API call is only meant to be used by bridge subclasses and hook callbacks to request a builtin feature hook to be executed.

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_features_do(AST_BRIDGE_BUILTIN_ATTENDED_TRANSFER, bridge_channel, hook_pvt);

Definition at line 3151 of file bridge.c.

References ARRAY_LEN, and builtin_features_handlers.

Referenced by agent_connect_caller().

{
   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_channel, hook_pvt);

   return 0;
}

ast_bridge_features_enable()

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
	)

Enable a built in feature on a bridge features structure.

Parameters

features	Bridge features structure
feature	Feature to enable
dtmf	Optionally the DTMF stream to trigger the feature, if not specified it will be the default
config	Configuration structure unique to the built in type
destructor	Optional destructor callback for config data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_features_enable(&features, AST_BRIDGE_BUILTIN_ATTENDEDTRANSFER, NULL, NULL, 0);

This enables the attended transfer DTMF option using the default DTMF string. An alternate string may be provided using the dtmf parameter. Internally this is simply setting up a hook to a built in feature callback function.

Definition at line 3428 of file bridge.c.

References ARRAY_LEN, ast_bridge_dtmf_hook(), ast_debug, ast_strlen_zero, builtin_features_dtmf, and builtin_features_handlers.

Referenced by builtin_features_helper().

{
   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 %u 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);
}

ast_bridge_features_init()

int ast_bridge_features_init

(

struct ast_bridge_features *

features

)

Initialize bridge features structure.

Parameters

features

Bridge featues structure

Return values

0	on success
-1	on failure

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);

This initializes the feature structure 'features' to have nothing enabled.

Note

This MUST be called before enabling features or flags. Failure to do so may result in a crash.

Definition at line 3687 of file bridge.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, ast_heap_create, bridge_dtmf_hook_sort(), ast_bridge_features::dtmf_hooks, ast_bridge_features::dtmf_passthrough, interval_hook_time_cmp(), ast_bridge_features::interval_hooks, NULL, ast_bridge_features::other_hooks, ast_bridge_features::text_messaging, and timer.

Referenced by agent_request_exec(), agent_run(), ast_bridge_call_with_flags(), ast_bridge_features_new(), AST_TEST_DEFINE(), bridge_exec(), bridgeadd_exec(), bridgewait_exec(), channel_feature_hooks_set_full(), confbridge_exec(), park_and_announce_app_exec(), park_app_exec(), and parked_call_app_exec().

{
   /* 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;
   }

   features->dtmf_passthrough = 1;
   features->text_messaging = 1;

   return 0;
}

ast_bridge_features_limits_construct()

int ast_bridge_features_limits_construct

(

struct ast_bridge_features_limits *

limits

)

Constructor function for ast_bridge_features_limits.

Parameters

limits

pointer to a ast_bridge_features_limits struct that has been allocted, but not initialized

Return values

0	on success
-1	on failure

Definition at line 3459 of file bridge.c.

References ast_string_field_init.

Referenced by bridge_builtin_set_limits(), and pre_bridge_setup().

{
   memset(limits, 0, sizeof(*limits));

   if (ast_string_field_init(limits, 256)) {
      return -1;
   }

   return 0;
}

ast_bridge_features_limits_destroy()

void ast_bridge_features_limits_destroy

(

struct ast_bridge_features_limits *

limits

)

Destructor function for ast_bridge_features_limits.

Parameters

limits

pointer to an ast_bridge_features_limits struct that needs to be destroyed

This function does not free memory allocated to the ast_bridge_features_limits struct, it only frees elements within the struct. You must still call ast_free on the struct if you allocated it with malloc.

Definition at line 3470 of file bridge.c.

References ast_string_field_free_memory.

Referenced by bridge_features_limits_dtor(), and pre_bridge_setup().

{
   ast_string_field_free_memory(limits);
}

ast_bridge_features_merge()

void ast_bridge_features_merge	(	struct ast_bridge_features *	into,
		const struct ast_bridge_features *	from
	)

Merge one ast_bridge_features into another.

Parameters

into	The ast_bridge_features that will be merged into
from	The ast_bridge_features that will be merged from

Definition at line 3662 of file bridge.c.

References ao2_callback, ast_heap_peek(), ast_heap_unlock, ast_heap_wrlock, ast_bridge_features::dtmf_hooks, ast_bridge_features::dtmf_passthrough, ast_bridge_features::feature_flags, ast_flags::flags, ast_bridge_features::interval_hooks, merge_container_cb(), ast_bridge_features::mute, ast_bridge_features::other_hooks, ast_bridge_features::usable, and wrap_hook().

Referenced by bridge_channel_internal_join(), and channel_feature_hooks_set_full().

{
   struct ast_bridge_hook_timer *hook;
   int idx;

   /* Merge hook containers */
   ao2_callback(from->dtmf_hooks, 0, merge_container_cb, into->dtmf_hooks);
   ao2_callback(from->other_hooks, 0, merge_container_cb, into->other_hooks);

   /* Merge hook heaps */
   ast_heap_wrlock(from->interval_hooks);
   for (idx = 1; (hook = ast_heap_peek(from->interval_hooks, idx)); idx++) {
      wrap_hook(into, hook);
   }
   ast_heap_unlock(from->interval_hooks);

   /* Merge feature flags */
   into->feature_flags.flags |= from->feature_flags.flags;
   into->usable |= from->usable;

   into->mute |= from->mute;
   into->dtmf_passthrough |= from->dtmf_passthrough;
}

ast_bridge_features_new()

struct ast_bridge_features* ast_bridge_features_new

(

void

)

Allocate a new bridge features struct.

Since

12.0.0

Example usage:

struct ast_bridge_features *features;
features = ast_bridge_features_new();
ast_bridge_features_destroy(features);

Return values

features	New allocated features struct.
NULL	on error.

Definition at line 3750 of file bridge.c.

References ast_bridge_features_destroy(), ast_bridge_features_init(), ast_malloc, and NULL.

Referenced by ast_bridge_call_with_flags(), ast_unreal_channel_push_to_bridge(), bridge_exec(), bridge_impart_internal(), channel_feature_hooks_set_full(), conf_announce_channel_push(), conf_start_record(), and stasis_app_control_bridge_features_init().

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

ast_bridge_features_register()

int ast_bridge_features_register	(	enum ast_bridge_builtin_feature	feature,
		ast_bridge_hook_callback	callback,
		const char *	dtmf
	)

Register a handler for a built in feature.

Parameters

feature	The feature that the handler will be responsible for
callback	The callback function that will handle it
dtmf	Default DTMF string used to activate the feature

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_features_register(AST_BRIDGE_BUILTIN_ATTENDED_TRANSFER, bridge_builtin_attended_transfer, "*1");

This registers the function bridge_builtin_attended_transfer as the function responsible for the built in attended transfer feature.

Definition at line 3123 of file bridge.c.

References ARRAY_LEN, ast_copy_string(), ast_strlen_zero, builtin_features_dtmf, and builtin_features_handlers.

Referenced by ast_bridging_init_basic(), load_module(), and load_parking_bridge_features().

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

ast_bridge_features_remove()

void ast_bridge_features_remove	(	struct ast_bridge_features *	features,
		enum ast_bridge_hook_remove_flags	flags
	)

Remove marked bridge channel feature hooks.

Since

12.0.0

Parameters

features	Bridge features structure
flags	Determinator for whether hook is removed.

Returns

Nothing

Definition at line 3568 of file bridge.c.

References ast_bridge_features::dtmf_hooks, hooks_remove_container(), hooks_remove_heap(), ast_bridge_features::interval_hooks, and ast_bridge_features::other_hooks.

Referenced by bridge_base_pull(), bridge_channel_internal_join(), bridge_do_merge(), bridge_do_move(), and remove_hooks_on_personality_change().

{
   hooks_remove_container(features->dtmf_hooks, remove_flags);
   hooks_remove_container(features->other_hooks, remove_flags);
   hooks_remove_heap(features->interval_hooks, remove_flags);
}

ast_bridge_features_set_flag()

void ast_bridge_features_set_flag	(	struct ast_bridge_features *	features,
		unsigned int	flag
	)

Set a flag on a bridge channel features structure.

Parameters

features	Bridge channel features structure
flag	Flag to enable

Returns

Nothing

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_features_set_flag(&features, AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP);

This sets the AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP feature to be enabled on the features structure 'features'.

Definition at line 3490 of file bridge.c.

References ast_set_flag, ast_bridge_features::feature_flags, and ast_bridge_features::usable.

{
   ast_set_flag(&features->feature_flags, flag);
   features->usable = 1;
}

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

Limit the amount of time a channel may stay in the bridge and optionally play warning messages as time runs out.

Parameters

features	Bridge features structure
limits	Configured limits applicable to the channel
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure

Example usage:

struct ast_bridge_features features;
struct ast_bridge_features_limits limits;
ast_bridge_features_init(&features);
ast_bridge_features_limits_construct(&limits);
ast_bridge_features_set_limits(&features, &limits, 0);
ast_bridge_features_limits_destroy(&limits);

This sets the maximum time the channel can be in the bridge to 10 seconds and does not play any warnings.

Note

This API call can only be used on a features structure that will be used in association with a bridge channel.

The ast_bridge_features_limits structure must remain accessible for the lifetime of the features structure.

Definition at line 3475 of file bridge.c.

References AST_BRIDGE_BUILTIN_INTERVAL_LIMITS, ast_log, builtin_interval_handlers, and LOG_ERROR.

Referenced by pre_bridge_setup().

{
   if (builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS]) {
      ast_bridge_builtin_set_limits_fn callback;

      callback = builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_LIMITS];
      return 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;
}

ast_bridge_features_unregister()

int ast_bridge_features_unregister

(

enum ast_bridge_builtin_feature

feature

)

Unregister a handler for a built in feature.

Parameters

feature

The feature to unregister

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_features_unregister(AST_BRIDGE_BUILTIN_ATTENDED_TRANSFER);

This unregisters the function that is handling the built in attended transfer feature.

Definition at line 3139 of file bridge.c.

References ARRAY_LEN, builtin_features_handlers, and NULL.

Referenced by unload_module(), and unload_parking_bridge_features().

{
   if (ARRAY_LEN(builtin_features_handlers) <= feature
      || !builtin_features_handlers[feature]) {
      return -1;
   }

   builtin_features_handlers[feature] = NULL;

   return 0;
}

ast_bridge_find_by_id()

struct ast_bridge* ast_bridge_find_by_id

(

const char *

bridge_id

)

Find bridge by id.

Since

12.0.0

Parameters

bridge_id

Bridge identifier

Returns

NULL bridge not found

non-NULL reference to bridge

Definition at line 5070 of file bridge.c.

References ao2_find, and OBJ_SEARCH_KEY.

Referenced by ast_bridge_get_snapshot_by_uniqueid(), complete_bridge_participant(), handle_bridge_destroy_specific(), handle_bridge_kick_channel(), manager_bridge_destroy(), and manager_bridge_kick().

{
   return ao2_find(bridges, bridge_id, OBJ_SEARCH_KEY);
}

ast_bridge_hangup_hook()

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
	)

Attach a hangup hook to a bridge features structure.

Parameters

features	Bridge features structure
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_hangup_hook(&features, hangup_callback, NULL, NULL, 0);

This makes the bridging core call hangup_callback if a channel that has this hook hangs up. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3328 of file bridge.c.

References AST_BRIDGE_HOOK_TYPE_HANGUP, and bridge_other_hook().

Referenced by add_normal_hooks(), and bridge_personality_atxfer_push().

{
   return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
      AST_BRIDGE_HOOK_TYPE_HANGUP);
}

ast_bridge_impart()

int ast_bridge_impart	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan,
		struct ast_channel *	swap,
		struct ast_bridge_features *	features,
		enum ast_bridge_impart_flags	flags
	)

Impart a channel to a bridge (non-blocking)

Parameters

bridge	Bridge to impart on
chan	Channel to impart (The channel reference is stolen if impart successful.)
swap	Channel to swap out if swapping. NULL if not swapping.
features	Bridge features structure.
flags	defined by enum ast_bridge_impart_flags.

Note

The given bridge must be unlocked when calling this function.

The features parameter must be NULL or obtained by ast_bridge_features_new(). You must not dereference features after calling even if the call fails.

chan is locked by this function.

Return values

0	on success
-1	on failure (Caller still has ownership of chan)

Example usage:

ast_bridge_impart(bridge, chan, NULL, NULL, AST_BRIDGE_IMPART_CHAN_INDEPENDENT);

This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will return immediately and will not wait until the channel is no longer part of the bridge.

If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.

If channel specific features are enabled, a pointer to the features structure can be specified in the features parameter.

Note

If you impart a channel with AST_BRIDGE_IMPART_CHAN_DEPARTABLE you MUST ast_bridge_depart() the channel if this call succeeds. The bridge channel thread is created join-able. The implication is that the channel is special and will not behave like a normal channel.

If you impart a channel with AST_BRIDGE_IMPART_CHAN_INDEPENDENT you must not ast_bridge_depart() the channel. The bridge channel thread is created non-join-able. The channel must be treated as if it were placed into the bridge by ast_bridge_join(). Channels placed into a bridge by ast_bridge_join() are removed by a third party using ast_bridge_remove().

Any callbacks on the channel will be invoked on failure with the reason as AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED.

Definition at line 1924 of file bridge.c.

References AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED, ast_bridge_discard_after_callback(), ast_channel_name(), ast_cond_destroy, ast_cond_init, ast_mutex_destroy, ast_mutex_init, bridge_channel_impart_signal(), bridge_impart_internal(), bridge_channel_impart_cond::cond, bridge_channel_impart_cond::done, bridge_channel_impart_cond::lock, NULL, SCOPE_TRACE, and ast_bridge::uniqueid.

Referenced by add_to_dial_bridge(), ast_bridge_add_channel(), ast_bridge_call_with_flags(), AST_TEST_DEFINE(), ast_unreal_channel_push_to_bridge(), attended_transfer_bridge(), blind_transfer_bridge(), conf_announce_channel_push(), conf_start_record(), control_swap_channel_in_bridge(), feature_attended_transfer(), handle_invite_replaces(), local_call(), parking_blind_transfer_park(), recalling_exit(), refer_incoming_invite_request(), and retransfer_enter().

{
   struct bridge_channel_impart_cond cond = {
      .done = 0,
   };
   int res;
   SCOPE_TRACE(1, "%s Bridge: %s\n", ast_channel_name(chan), bridge->uniqueid);

   ast_mutex_init(&cond.lock);
   ast_cond_init(&cond.cond, NULL);

   res = bridge_impart_internal(bridge, chan, swap, features, flags, &cond);
   if (res) {
      /* Impart failed.  Signal any other waiting impart threads */
      ast_bridge_discard_after_callback(chan, AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED);
      bridge_channel_impart_signal(chan);
   }

   ast_cond_destroy(&cond.cond);
   ast_mutex_destroy(&cond.lock);

   return res;
}

ast_bridge_interval_hook()

int ast_bridge_interval_hook	(	struct ast_bridge_features *	features,
		enum ast_bridge_hook_timer_option	flags,
		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
	)

Attach an interval hook to a bridge features structure.

Parameters

features	Bridge features structure
flags	Interval timer callback option flags.
interval	The interval that the hook should execute at in milliseconds
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_interval_hook(&features, 1000, playback_callback, NULL, NULL, 0);

This makes the bridging core call playback_callback every second. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3382 of file bridge.c.

References ao2_ref, ast_atomic_fetchadd_int(), AST_BRIDGE_HOOK_TYPE_TIMER, ast_debug, ast_heap_push, ast_heap_unlock, ast_heap_wrlock, ast_samp2tv(), ast_tvadd(), ast_tvnow(), bridge_hook_generic(), ast_bridge_hook::destructor, ast_bridge_hook_timer_parms::flags, ast_bridge_hook_timer::generic, ast_bridge_hook_timer_parms::interval, ast_bridge_features::interval_hooks, ast_bridge_features::interval_sequence, NULL, ast_bridge_hook_timer_parms::seqno, ast_bridge_hook_timer::timer, ast_bridge_hook_timer_parms::trip_time, and ast_bridge_hook::type.

Referenced by agent_request_exec(), apply_option_timeout(), AST_TEST_DEFINE(), bridge_agent_hold_push(), bridge_builtin_set_limits(), confbridge_exec(), parking_set_duration(), set_interval_hook(), and wrap_hook().

{
   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(interval, 1000));
   hook->timer.seqno = ast_atomic_fetchadd_int((int *) &features->interval_sequence, +1);
   hook->timer.flags = flags;

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

ast_bridge_interval_register()

int ast_bridge_interval_register	(	enum ast_bridge_builtin_interval	interval,
		ast_bridge_builtin_set_limits_fn	callback
	)

Register a handler for a built in interval feature.

Parameters

interval	The interval feature that the handler will be responsible for
callback	the Callback function that will handle it

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_interval_register(AST_BRIDGE_BUILTIN_INTERVAL_LIMITS, bridge_builtin_set_limits);

This registers the function bridge_builtin_set_limits as the function responsible for the built in duration limit feature.

Definition at line 3168 of file bridge.c.

References ARRAY_LEN, and builtin_interval_handlers.

Referenced by load_module().

{
   if (ARRAY_LEN(builtin_interval_handlers) <= interval
      || builtin_interval_handlers[interval]) {
      return -1;
   }

   builtin_interval_handlers[interval] = callback;

   return 0;
}

ast_bridge_interval_unregister()

int ast_bridge_interval_unregister

(

enum ast_bridge_builtin_interval

interval

)

Definition at line 3180 of file bridge.c.

References ARRAY_LEN, builtin_interval_handlers, and NULL.

Referenced by unload_module().

{
   if (ARRAY_LEN(builtin_interval_handlers) <= interval
      || !builtin_interval_handlers[interval]) {
      return -1;
   }

   builtin_interval_handlers[interval] = NULL;

   return 0;

}

ast_bridge_is_video_src()

int ast_bridge_is_video_src	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Determine if a channel is a video src for the bridge.

Return values

0	Not a current video source of the bridge.
None	0, is a video source of the bridge, The number returned represents the priority this video stream has on the bridge where 1 is the highest priority.

Definition at line 3958 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_NONE, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, ast_bridge_video_talker_src_data::chan_old_vsrc, ast_bridge_video_single_src_data::chan_vsrc, ast_bridge_video_talker_src_data::chan_vsrc, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_mode::single_src_data, ast_bridge::softmix, ast_bridge_video_mode::talker_src_data, and ast_bridge_softmix::video_mode.

Referenced by handle_video_on_exit(), handle_video_on_join(), softmix_bridge_write_video(), and softmix_pass_video_top_priority().

{
   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;
      }
   case AST_BRIDGE_VIDEO_MODE_SFU:
      break;
   }
   ast_bridge_unlock(bridge);
   return res;
}

ast_bridge_join()

int 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,
		enum ast_bridge_join_flags	flags
	)

Join a channel to a bridge (blocking)

Parameters

bridge	Bridge to join
chan	Channel to join
swap	Channel to swap out if swapping (A channel reference is stolen.)
features	Bridge features structure
tech_args	Optional Bridging tech optimization parameters for this channel.
flags	defined by enum ast_bridge_join_flags.

Note

The passed in swap channel is always unreffed on return. It is not a good idea to access the swap channel on return or for the caller to keep a reference to it.

Absolutely NO locks should be held before calling this function since it blocks.

Return values

0	if the channel successfully joined the bridge before it exited.
-1	if the channel failed to join the bridge

Example usage:

ast_bridge_join(bridge, chan, NULL, NULL, NULL, AST_BRIDGE_JOIN_PASS_REFERENCE);

This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will not return until the channel has been removed from the bridge, swapped out for another channel, or has hung up.

If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.

If channel specific features are enabled a pointer to the features structure can be specified in the features parameter.

Definition at line 1667 of file bridge.c.

References ao2_lock, ao2_ref, ao2_t_cleanup, ao2_unlock, ast_assert, AST_BRIDGE_JOIN_INHIBIT_JOIN_COLP, AST_BRIDGE_JOIN_PASS_REFERENCE, ast_bridge_lock, ast_bridge_run_after_callback(), ast_bridge_setup_after_goto(), ast_bridge_unlock, ast_channel_flags(), ast_channel_internal_bridge_channel_set(), ast_channel_lock, ast_channel_name(), ast_channel_softhangup_internal_flag(), ast_channel_unlock, AST_FLAG_ZOMBIE, AST_SOFTHANGUP_ASYNCGOTO, ast_softhangup_nolock(), ast_test_flag, bridge_channel_impart_signal(), bridge_channel_internal_alloc(), bridge_channel_internal_join(), bridge_find_channel(), ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_channel::inhibit_colp, NULL, ast_bridge_methods::push_peek, SCOPE_TRACE, ast_bridge_channel::swap, ast_bridge_channel::tech_args, ast_bridge_channel::thread, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by agent_request_exec(), agent_run(), ast_bridge_call_with_flags(), bridge_exec(), bridgeadd_exec(), bridgewait_exec(), confbridge_exec(), park_and_announce_app_exec(), park_app_exec(), and parked_call_app_exec().

{
   struct ast_bridge_channel *bridge_channel;
   int res = 0;
   SCOPE_TRACE(1, "%s Bridge: %s\n", ast_channel_name(chan), bridge->uniqueid);

   bridge_channel = bridge_channel_internal_alloc(bridge);
   if (flags & AST_BRIDGE_JOIN_PASS_REFERENCE) {
      ao2_ref(bridge, -1);
   }
   if (!bridge_channel) {
      ao2_t_cleanup(swap, "Error exit: bridge_channel alloc failed");
      res = -1;
      goto join_exit;
   }
/* XXX ASTERISK-21271 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);
      ao2_t_cleanup(swap, "Error exit: features is NULL");
      res = -1;
      goto join_exit;
   }
   if (tech_args) {
      bridge_channel->tech_args = *tech_args;
   }

   ast_channel_lock(chan);
   if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
      res = -1;
   } else {
      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->inhibit_colp = !!(flags & AST_BRIDGE_JOIN_INHIBIT_JOIN_COLP);

   /* allow subclass to peek at upcoming push operation */
   if (bridge->v_table->push_peek && !res) {
      struct ast_bridge_channel *bcswap = NULL;

      ast_bridge_lock(bridge);
      if (bridge_channel->swap) {
         bcswap = bridge_find_channel(bridge, bridge_channel->swap);
      }
      res = bridge->v_table->push_peek(bridge, bridge_channel, bcswap);
      ast_bridge_unlock(bridge);
   }

   if (!res) {
      res = bridge_channel_internal_join(bridge_channel);
   }

   /* 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);
   /* Due to a race condition, we lock the bridge channel here for ast_bridge_channel_get_chan */
   ao2_lock(bridge_channel);
   bridge_channel->chan = NULL;
   ao2_unlock(bridge_channel);
   /* If bridge_channel->swap is not NULL then the join failed. */
   ao2_t_cleanup(bridge_channel->swap, "Bridge complete: join failed");
   bridge_channel->swap = NULL;
   bridge_channel->features = NULL;

   ao2_ref(bridge_channel, -1);

join_exit:
   ast_bridge_run_after_callback(chan);
   bridge_channel_impart_signal(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 res;
}

ast_bridge_join_hook()

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
	)

Unregisters a handler for a built in interval feature.

Parameters

interval

the interval feature to unregister

Return values

0	on success
-1	on failure

Example usage:

   ast_bridge_interval_unregister(AST_BRIDGE_BULTIN_INTERVAL_LIMITS)
   /endcode
  
   This unregisters the function that is handling the built in duration limit feature.
  /
int ast_bridge_interval_unregister(enum ast_bridge_builtin_interval interval);

/*!
 * \brief Attach a bridge channel join 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.
  
 * \retval 0 on success
 * \retval -1 on failure (The caller must cleanup any hook_pvt resources.)
  
 * Example usage:
  
 * \code
 * struct ast_bridge_features features;
 * ast_bridge_features_init(&features);
 * ast_bridge_join_hook(&features, join_callback, NULL, NULL, 0);
 * 

This makes the bridging core call join_callback when a channel successfully joins the bridging system. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3338 of file bridge.c.

References AST_BRIDGE_HOOK_TYPE_JOIN, and bridge_other_hook().

Referenced by agent_request_exec(), and confbridge_exec().

{
   return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
      AST_BRIDGE_HOOK_TYPE_JOIN);
}

ast_bridge_kick()

int ast_bridge_kick	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Kick a channel from a bridge.

Parameters

bridge	Bridge that the channel is to be kicked from
chan	Channel to kick

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_kick(bridge, chan);

This kicks the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and requests that it be hung up. Control over the channel will NOT be given to the calling thread.

Note

The functional difference between ast_bridge_kick() and ast_bridge_remove() is that the bridge may dissolve as a result of the channel being kicked.

This API call can be used on channels that were added to the bridge using both ast_bridge_join and ast_bridge_impart.

Definition at line 2025 of file bridge.c.

References ast_bridge_channel_queue_callback(), ast_bridge_lock, ast_bridge_unlock, bridge_find_channel(), kick_it(), and NULL.

Referenced by handle_bridge_kick_channel(), and manager_bridge_kick().

{
   struct ast_bridge_channel *bridge_channel;
   int res;

   ast_bridge_lock(bridge);

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

   res = ast_bridge_channel_queue_callback(bridge_channel, 0, kick_it, NULL, 0);

   ast_bridge_unlock(bridge);

   return res;
}

ast_bridge_leave_hook()

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
	)

Attach a bridge channel leave hook to a bridge features structure.

Parameters

features	Bridge features structure
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_leave_hook(&features, leave_callback, NULL, NULL, 0);

This makes the bridging core call leave_callback when a channel successfully leaves the bridging system. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3348 of file bridge.c.

References AST_BRIDGE_HOOK_TYPE_LEAVE, and bridge_other_hook().

Referenced by confbridge_exec().

{
   return bridge_other_hook(features, callback, hook_pvt, destructor, remove_flags,
      AST_BRIDGE_HOOK_TYPE_LEAVE);
}

ast_bridge_merge()

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
	)

Merge two bridges together.

Parameters

dst_bridge	Destination bridge of merge.
src_bridge	Source bridge of merge.
merge_best_direction	TRUE if don't care about which bridge merges into the other.
kick_me	Array of channels to kick from the bridges.
num_kick	Number of channels in the kick_me array.

Note

Absolutely NO bridge or channel locks should be held before calling this function.

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_merge(dst_bridge, src_bridge, 0, NULL, 0);

This moves the channels in src_bridge into the bridge pointed to by dst_bridge.

Definition at line 2348 of file bridge.c.

References ast_assert, ast_bridge_lock_both, ast_bridge_unlock, and bridge_merge_locked().

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

ast_bridge_merge_inhibit()

void ast_bridge_merge_inhibit	(	struct ast_bridge *	bridge,
		int	request
	)

Adjust the bridge merge inhibit request count.

Since

12.0.0

Parameters

bridge	What to operate on.
request	Inhibit request increment. (Positive to add requests. Negative to remove requests.)

Returns

Nothing

Definition at line 3061 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, and bridge_merge_inhibit_nolock().

Referenced by attended_transfer_properties_shutdown(), consulting_exit(), and feature_attended_transfer().

{
   ast_bridge_lock(bridge);
   bridge_merge_inhibit_nolock(bridge, request);
   ast_bridge_unlock(bridge);
}

ast_bridge_move()

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
	)

Move a channel from one bridge to another.

Since

12.0.0

Parameters

dst_bridge	Destination bridge of bridge channel move.
src_bridge	Source bridge of bridge channel move.
chan	Channel to move.
swap	Channel to replace in dst_bridge.
attempt_recovery	TRUE if failure attempts to push channel back into original bridge.

Note

Absolutely NO bridge or channel locks should be held before calling this function.

Return values

0	on success.
-1	on failure.

Definition at line 2508 of file bridge.c.

References ast_bridge_lock_both, ast_bridge_unlock, and bridge_move_locked().

Referenced by agent_connect_caller(), parked_call_app_exec(), and parking_park_bridge_channel().

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

ast_bridge_move_hook()

int ast_bridge_move_hook	(	struct ast_bridge_features *	features,
		ast_bridge_move_indicate_callback	callback,
		void *	hook_pvt,
		ast_bridge_hook_pvt_destructor	destructor,
		enum ast_bridge_hook_remove_flags	remove_flags
	)

Attach a bridge channel move detection hook to a bridge features structure.

Parameters

features	Bridge features structure
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_move_hook(&features, move_callback, NULL, NULL, 0);

This makes the bridging core call callback when a channel is moved from one bridge to another. A pointer to useful data may be provided to the hook_pvt parameter.

Definition at line 3370 of file bridge.c.

References AST_BRIDGE_HOOK_TYPE_MOVE, bridge_other_hook(), and hook_cb().

Referenced by bridge_stasis_pull().

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

ast_bridge_notify_masquerade()

void ast_bridge_notify_masquerade

(

struct ast_channel *

chan

)

Notify bridging that this channel was just masqueraded.

Since

12.0.0

Parameters

chan	Channel just involved in a masquerade

Returns

Nothing

Definition at line 1482 of file bridge.c.

References ao2_ref, ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_unlock, ast_bridge_channel::bridge, bridge_manager_request::bridge, bridge_find_channel(), bridge_reconfigured(), ast_bridge_methods::notify_masquerade, and ast_bridge::v_table.

Referenced by channel_do_masquerade().

{
   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)) {
/*
 * XXX ASTERISK-22366 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);
}

ast_bridge_number_video_src()

int ast_bridge_number_video_src

(

struct ast_bridge *

bridge

)

Returns the number of video sources currently active in the bridge.

Definition at line 3931 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_NONE, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, ast_bridge_video_talker_src_data::chan_old_vsrc, ast_bridge_video_single_src_data::chan_vsrc, ast_bridge_video_talker_src_data::chan_vsrc, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_mode::single_src_data, ast_bridge::softmix, ast_bridge_video_mode::talker_src_data, and ast_bridge_softmix::video_mode.

Referenced by softmix_bridge_write_video().

{
   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++;
      }
   case AST_BRIDGE_VIDEO_MODE_SFU:
      break;
   }
   ast_bridge_unlock(bridge);
   return res;
}

ast_bridge_peer()

struct ast_channel* ast_bridge_peer	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Get the channel's bridge peer only if the bridge is two-party.

Since

12.0.0

Parameters

bridge	The bridge
chan	Channel desiring the bridge peer channel.

Note

The returned peer channel is the current peer in the bridge when called.

Return values

NULL	Channel not in a bridge or the bridge is not two-party.
non-NULL	Reffed peer channel at time of calling.

Definition at line 4142 of file bridge.c.

References ast_bridge_lock, ast_bridge_peer_nolock(), and ast_bridge_unlock.

Referenced by ast_attended_transfer_message_create(), ast_bridge_transfer_blind(), ast_channel_bridge_peer(), and get_transfer_parties_transferer_bridge().

{
   struct ast_channel *peer;

   ast_bridge_lock(bridge);
   peer = ast_bridge_peer_nolock(bridge, chan);
   ast_bridge_unlock(bridge);

   return peer;
}

ast_bridge_peer_nolock()

struct ast_channel* ast_bridge_peer_nolock	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Get the channel's bridge peer only if the bridge is two-party.

Since

12.0.0

Parameters

bridge	The bridge which is already locked.
chan	Channel desiring the bridge peer channel.

Note

The returned peer channel is the current peer in the bridge when called.

Return values

NULL	Channel not in a bridge or the bridge is not two-party.
non-NULL	Reffed peer channel at time of calling.

Definition at line 4114 of file bridge.c.

References AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_NATIVE, ast_channel_ref, AST_LIST_TRAVERSE, ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_channel::in_bridge, NULL, ast_bridge::num_channels, and ast_bridge::technology.

Referenced by ast_bridge_peer(), feature_automixmonitor(), and feature_automonitor().

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

ast_bridge_peers()

struct ao2_container* ast_bridge_peers

(

struct ast_bridge *

bridge

)

Get a container of all channels in the bridge.

Since

12.0.0

Parameters

bridge

The bridge

Note

The returned container is a snapshot of channels in the bridge when called.

Return values

NULL	Failed to create container
non-NULL	Container of channels in the bridge

Definition at line 4103 of file bridge.c.

References ast_bridge_lock, ast_bridge_peers_nolock(), ast_bridge_unlock, and channels.

{
   struct ao2_container *channels;

   ast_bridge_lock(bridge);
   channels = ast_bridge_peers_nolock(bridge);
   ast_bridge_unlock(bridge);

   return channels;
}

ast_bridge_peers_nolock()

struct ao2_container* ast_bridge_peers_nolock

(

struct ast_bridge *

bridge

)

Get a container of all channels in the bridge.

Since

12.0.0

Parameters

bridge

The bridge which is already locked.

Return values

NULL	Failed to create container
non-NULL	Container of channels in the bridge

Definition at line 4085 of file bridge.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_container_alloc_hash, ao2_link, AST_LIST_TRAVERSE, ast_bridge_channel::chan, channel_cmp(), channel_hash(), channels, ast_bridge::channels, and NULL.

Referenced by ast_bridge_peers(), ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), and two_bridge_attended_transfer().

{
   struct ao2_container *channels;
   struct ast_bridge_channel *iter;

   channels = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_NOLOCK, 0,
      13, channel_hash, NULL, channel_cmp);
   if (!channels) {
      return NULL;
   }

   AST_LIST_TRAVERSE(&bridge->channels, iter, entry) {
      ao2_link(channels, iter->chan);
   }

   return channels;
}

ast_bridge_queue_action()

int ast_bridge_queue_action	(	struct ast_bridge *	bridge,
		struct ast_frame *	action
	)

Put an action onto the specified bridge.

Since

12.0.0

Parameters

bridge	What to queue the action on.
action	What to do.

Return values

0	on success.
-1	on error.

Note

This API call is meant for internal bridging operations.

Definition at line 307 of file bridge.c.

References ast_frdup, and bridge_queue_action_nodup().

Referenced by bridge_dissolve().

{
   struct ast_frame *dup;

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

ast_bridge_remove()

int ast_bridge_remove	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Remove a channel from a bridge.

Parameters

bridge	Bridge that the channel is to be removed from
chan	Channel to remove

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_remove(bridge, chan);

This removes the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and requests that it be hung up. Control over the channel will NOT be given to the calling thread.

Note

This API call can be used on channels that were added to the bridge using both ast_bridge_join and ast_bridge_impart.

Definition at line 1997 of file bridge.c.

References ast_bridge_channel_leave_bridge(), ast_bridge_lock, ast_bridge_unlock, AST_CAUSE_NORMAL_CLEARING, ast_channel_name(), ast_debug, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_find_channel(), and ast_bridge::uniqueid.

Referenced by action_kick_last(), ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), execute_menu_entry(), kick_conference_participant(), and leave_marked().

{
   struct ast_bridge_channel *bridge_channel;

   ast_debug(1, "Removing channel %s from bridge %s\n",
      ast_channel_name(chan), bridge->uniqueid);

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

   ast_bridge_unlock(bridge);

   return 0;
}

ast_bridge_remove_video_src()

void ast_bridge_remove_video_src	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

remove a channel as a source of video for the bridge.

Definition at line 3984 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_NONE, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, ast_channel_unref, ast_bridge_video_talker_src_data::average_talking_energy, ast_bridge_video_talker_src_data::chan_old_vsrc, ast_bridge_video_single_src_data::chan_vsrc, ast_bridge_video_talker_src_data::chan_vsrc, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, NULL, ast_bridge_video_mode::single_src_data, ast_bridge::softmix, ast_bridge_video_mode::talker_src_data, and ast_bridge_softmix::video_mode.

Referenced by bridge_channel_internal_join(), and handle_video_on_exit().

{
   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;
      }
   case AST_BRIDGE_VIDEO_MODE_SFU:
      break;
   }
   ast_bridge_unlock(bridge);
}

ast_bridge_set_binaural_active()

void ast_bridge_set_binaural_active	(	struct ast_bridge *	bridge,
		unsigned int	binaural_active
	)

Activates the use of binaural signals in a conference bridge.

Parameters

bridge	Channel to activate the binaural signals.
binaural_active	If true binaural signal processing will be active for the bridge.

Definition at line 3772 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_softmix::binaural_active, and ast_bridge::softmix.

Referenced by join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.binaural_active = binaural_active;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_internal_sample_rate()

void ast_bridge_set_internal_sample_rate	(	struct ast_bridge *	bridge,
		unsigned int	sample_rate
	)

Adjust the internal mixing sample rate of a bridge used during multimix mode.

Parameters

bridge	Channel to change the sample rate on.
sample_rate	the sample rate to change to. If a value of 0 is passed here, the bridge will be free to pick what ever sample rate it chooses.

Definition at line 3779 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_softmix::internal_sample_rate, and ast_bridge::softmix.

Referenced by join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.internal_sample_rate = sample_rate;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_maximum_sample_rate()

void ast_bridge_set_maximum_sample_rate	(	struct ast_bridge *	bridge,
		unsigned int	sample_rate
	)

Adjust the maximum mixing sample rate of a bridge used during multimix mode.

Since

13.31.0

16.8.0

17.2.0

Parameters

bridge	Channel to change the sample rate on.
sample_rate	the maximum sample rate to use. If a value of 0 is passed here, the bridge will be free to pick what ever sample rate it chooses.

Definition at line 3786 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_softmix::maximum_sample_rate, and ast_bridge::softmix.

Referenced by join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.maximum_sample_rate = sample_rate;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_mixing_interval()

void ast_bridge_set_mixing_interval	(	struct ast_bridge *	bridge,
		unsigned int	mixing_interval
	)

Adjust the internal mixing interval of a bridge used during multimix mode.

Parameters

bridge	Channel to change the sample rate on.
mixing_interval	the sample rate to change to. If 0 is set the bridge tech is free to choose any mixing interval it uses by default.

Definition at line 3765 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_softmix::internal_mixing_interval, and ast_bridge::softmix.

Referenced by join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.internal_mixing_interval = mixing_interval;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_remb_estimated_bitrate()

void ast_bridge_set_remb_estimated_bitrate	(	struct ast_bridge *	bridge,
		float	estimated_bitrate
	)

Force the REMB report estimated bitrate to a specific max value.

Parameters

bridge	Bridge to set the REMB behavior on
estimated_bitrate	The estimated bitrate in bits per second

Note

This can only be called when the bridge has been set to the SFU video mode.

Definition at line 3874 of file bridge.c.

References ast_assert, ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_SFU, ast_bridge_video_sfu_data::estimated_bitrate, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_mode::sfu_data, ast_bridge::softmix, and ast_bridge_softmix::video_mode.

Referenced by join_conference_bridge().

{
   ast_assert(bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_SFU);

   ast_bridge_lock(bridge);
   bridge->softmix.video_mode.mode_data.sfu_data.estimated_bitrate = estimated_bitrate;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_remb_send_interval()

void ast_bridge_set_remb_send_interval	(	struct ast_bridge *	bridge,
		unsigned int	remb_send_interval
	)

Set the interval at which a combined REMB frame will be sent to video sources.

Parameters

bridge	Bridge to set the REMB send interval on
remb_send_interval	The REMB send interval

Note

This can only be called when the bridge has been set to the SFU video mode.

Definition at line 3856 of file bridge.c.

References ast_assert, ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_SFU, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_sfu_data::remb_send_interval, ast_bridge_video_mode::sfu_data, ast_bridge::softmix, and ast_bridge_softmix::video_mode.

Referenced by join_conference_bridge().

{
   ast_assert(bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_SFU);

   ast_bridge_lock(bridge);
   bridge->softmix.video_mode.mode_data.sfu_data.remb_send_interval = remb_send_interval;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_send_sdp_label()

void ast_bridge_set_send_sdp_label	(	struct ast_bridge *	bridge,
		unsigned int	send_sdp_label
	)

Controls whether to send a "label" attribute in each stream in an SDP.

Since

16.1.0

Parameters

bridge	The bridge
send_sdp_label	Whether to send the labels or not

Note

The label will contain the uniqueid of the channel related to the stream. This is used to allow the recipient to correlate the stream to the participant information events sent by app_confbridge. The bridge will be locked in this function.

Definition at line 4033 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_softmix::send_sdp_label, and ast_bridge::softmix.

Referenced by join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.send_sdp_label = send_sdp_label;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_sfu_video_mode()

void ast_bridge_set_sfu_video_mode

(

struct ast_bridge *

bridge

)

Set the bridge to be a selective forwarding unit.

Definition at line 3841 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_SFU, cleanup_video_mode(), ast_bridge_video_mode::mode, ast_bridge::softmix, and ast_bridge_softmix::video_mode.

Referenced by bridge_stasis_new(), and join_conference_bridge().

{
   ast_bridge_lock(bridge);
   cleanup_video_mode(bridge);
   bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SFU;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_single_src_video_mode()

void ast_bridge_set_single_src_video_mode	(	struct ast_bridge *	bridge,
		struct ast_channel *	video_src_chan
	)

Set a bridge to feed a single video source to all participants.

Definition at line 3816 of file bridge.c.

References ast_bridge_lock, ast_bridge_publish_state(), ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, ast_channel_name(), ast_channel_ref, ast_channel_uniqueid(), AST_CONTROL_VIDUPDATE, ast_indicate(), ast_verb, ast_bridge_video_single_src_data::chan_vsrc, cleanup_video_mode(), ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge::name, ast_bridge_video_mode::single_src_data, ast_bridge::softmix, ast_bridge::uniqueid, and ast_bridge_softmix::video_mode.

Referenced by action_confbridgesetsinglevideosrc(), bridge_set_video_source_cb(), bridge_stasis_new(), execute_menu_entry(), handle_video_on_exit(), and handle_video_on_join().

{
   ast_bridge_lock(bridge);
   cleanup_video_mode(bridge);
   bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
   if (video_src_chan) {
      bridge->softmix.video_mode.mode_data.single_src_data.chan_vsrc = ast_channel_ref(video_src_chan);
      ast_verb(5, "Video source in bridge '%s' (%s) is now '%s' (%s)\n",
         bridge->name, bridge->uniqueid,
         ast_channel_name(video_src_chan),
         ast_channel_uniqueid(video_src_chan));
      ast_indicate(video_src_chan, AST_CONTROL_VIDUPDATE);
   }
   ast_bridge_publish_state(bridge);
   ast_bridge_unlock(bridge);
}

ast_bridge_set_talker_src_video_mode()

void ast_bridge_set_talker_src_video_mode

(

struct ast_bridge *

bridge

)

Set the bridge to pick the strongest talker supporting video as the single source video feed.

Definition at line 3833 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, cleanup_video_mode(), ast_bridge_video_mode::mode, ast_bridge::softmix, and ast_bridge_softmix::video_mode.

Referenced by ast_ari_bridges_clear_video_source(), bridge_stasis_new(), handle_video_on_exit(), and join_conference_bridge().

{
   ast_bridge_lock(bridge);
   cleanup_video_mode(bridge);
   bridge->softmix.video_mode.mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
   ast_bridge_unlock(bridge);
}

ast_bridge_set_transfer_variables()

void ast_bridge_set_transfer_variables	(	struct ast_channel *	chan,
		const char *	value,
		int	is_attended
	)

Set the relevant transfer variables for a single channel.

Sets either the ATTENDEDTRANSFER or BLINDTRANSFER variable for a channel while clearing the opposite.

Parameters

chan	Channel the variable is being set for
value	Value the variable is being set to
is_attended	false set BLINDTRANSFER and unset ATTENDEDTRANSFER true set ATTENDEDTRANSFER and unset BLINDTRANSFER

Definition at line 4404 of file bridge.c.

References ATTENDEDTRANSFER, BLINDTRANSFER, NULL, and pbx_builtin_setvar_helper().

Referenced by dial_transfer(), manager_park(), park_local_transfer(), parking_park_bridge_channel(), and set_transfer_variables_all().

{
   char *writevar;
   char *erasevar;

   if (attended) {
      writevar = ATTENDEDTRANSFER;
      erasevar = BLINDTRANSFER;
   } else {
      writevar = BLINDTRANSFER;
      erasevar = ATTENDEDTRANSFER;
   }

   pbx_builtin_setvar_helper(chan, writevar, value);
   pbx_builtin_setvar_helper(chan, erasevar, NULL);
}

ast_bridge_set_video_update_discard()

void ast_bridge_set_video_update_discard	(	struct ast_bridge *	bridge,
		unsigned int	video_update_discard
	)

Set the amount of time to discard subsequent video updates after a video update has been sent.

Parameters

bridge	Bridge to set the minimum video update wait time on
video_update_discard	Amount of time after sending a video update that others should be discarded

Definition at line 3849 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_bridge::softmix, ast_bridge_softmix::video_mode, and ast_bridge_video_mode::video_update_discard.

Referenced by bridge_stasis_new(), and join_conference_bridge().

{
   ast_bridge_lock(bridge);
   bridge->softmix.video_mode.video_update_discard = video_update_discard;
   ast_bridge_unlock(bridge);
}

ast_bridge_suspend()

int ast_bridge_suspend	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Suspend a channel temporarily from a bridge.

Parameters

bridge	Bridge to suspend the channel from
chan	Channel to suspend

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_suspend(bridge, chan);

This suspends the channel pointed to by chan from the bridge pointed to by bridge temporarily. Control of the channel is given to the calling thread. This differs from ast_bridge_depart as the channel will not be removed from the bridge.

Note

This API call can be used on channels that were added to the bridge using both ast_bridge_join and ast_bridge_impart.

Definition at line 3068 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, bridge_channel_internal_suspend_nolock(), and bridge_find_channel().

Referenced by conf_moh_start(), and conf_moh_stop().

{
   struct ast_bridge_channel *bridge_channel;
/* XXX ASTERISK-21271 the case of a disolved bridge while channel is suspended is not handled. */
/* XXX ASTERISK-21271 suspend/unsuspend needs to be rethought. The caller must block until it has successfully suspended the channel for temporary control. */
/* XXX ASTERISK-21271 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;
}

ast_bridge_talk_detector_hook()

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
	)

Attach a bridge channel talk detection hook to a bridge features structure.

Parameters

features	Bridge features structure
callback	Function to execute upon activation
hook_pvt	Unique data
destructor	Optional destructor callback for hook_pvt data
remove_flags	Dictates what situations the hook should be removed.

Return values

0	on success
-1	on failure (The caller must cleanup any hook_pvt resources.)

Example usage:

struct ast_bridge_features features;
ast_bridge_features_init(&features);
ast_bridge_talk_hook(&features, talk_callback, NULL, NULL, 0);

This makes the bridging technology call talk_callback when a channel is recognized as starting and stopping talking. A pointer to useful data may be provided to the hook_pvt parameter.

Note

This hook is currently only supported by softmix.

Definition at line 3358 of file bridge.c.

References AST_BRIDGE_HOOK_TYPE_TALK, bridge_other_hook(), and hook_cb().

Referenced by confbridge_exec().

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

ast_bridge_technology_suspend()

void ast_bridge_technology_suspend

(

struct ast_bridge_technology *

technology

)

Suspend a bridge technology from consideration.

Parameters

technology

The bridge technology to suspend

Example usage:

ast_bridge_technology_suspend(&simple_bridge_tech);

This suspends the bridge technology simple_bridge_tech from being considered when creating a new bridge. Existing bridges using the bridge technology are not affected.

Definition at line 3108 of file bridge.c.

References ast_bridge_technology::suspended.

Referenced by handle_bridge_technology_suspend(), and handle_manager_bridge_tech_suspend().

{
   technology->suspended = 1;
}

ast_bridge_technology_unregister()

int ast_bridge_technology_unregister

(

struct ast_bridge_technology *

technology

)

Unregister a bridge technology from use.

Parameters

technology

The bridge technology to unregister

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_technology_unregister(&simple_bridge_tech);

This unregisters a bridge technlogy declared as the structure simple_bridge_tech with the bridging core. It will no longer be considered when creating a new bridge.

Definition at line 265 of file bridge.c.

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, and ast_bridge_technology::name.

Referenced by dahdi_native_unload(), and unload_module().

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

ast_bridge_technology_unsuspend()

void ast_bridge_technology_unsuspend

(

struct ast_bridge_technology *

technology

)

Unsuspend a bridge technology.

Parameters

technology

The bridge technology to unsuspend

Example usage:

ast_bridge_technology_unsuspend(&simple_bridge_tech);

This makes the bridge technology simple_bridge_tech considered when creating a new bridge again.

Definition at line 3113 of file bridge.c.

References ast_bridge_technology::suspended.

Referenced by handle_bridge_technology_suspend(), and handle_manager_bridge_tech_suspend().

{
   /*
    * XXX We may want the act of unsuspending a bridge technology
    * to prod all existing bridges to see if they should start
    * using it.
    */
   technology->suspended = 0;
}

ast_bridge_transfer_acquire_bridge()

struct ast_bridge* ast_bridge_transfer_acquire_bridge

(

struct ast_channel *

chan

)

Acquire the channel's bridge for transfer purposes.

Since

13.21.0

Parameters

chan	Channel involved in a transfer.

Returns

The bridge the channel is in or NULL if it either isn't in a bridge or should not be considered to be in a bridge.

Definition at line 4460 of file bridge.c.

References ao2_ref, AST_BRIDGE_FLAG_INVISIBLE, AST_BRIDGE_FLAG_MASQUERADE_ONLY, ast_channel_get_bridge(), ast_channel_lock, ast_channel_unlock, ast_test_flag, bridge_manager_request::bridge, ast_bridge::feature_flags, and NULL.

Referenced by ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), handle_invite_replaces(), and invite_replaces().

{
   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 | AST_BRIDGE_FLAG_INVISIBLE))) {
      ao2_ref(bridge, -1);
      bridge = NULL;
   }

   return bridge;
}

ast_bridge_transfer_attended()

enum ast_transfer_result ast_bridge_transfer_attended	(	struct ast_channel *	to_transferee,
		struct ast_channel *	to_transfer_target
	)

Attended transfer.

The two channels are both transferer channels. The first is the channel that is bridged to the transferee (or if unbridged, the 'first' call of the transfer). The second is the channel that is bridged to the transfer target (or if unbridged, the 'second' call of the transfer).

Note

Absolutely NO channel locks should be held before calling this function.

Parameters

to_transferee	Transferer channel on initial call (presumably bridged to transferee)
to_transfer_target	Transferer channel on consultation call (presumably bridged to transfer target)

Returns

The success or failure of the attended transfer

Definition at line 4729 of file bridge.c.

References ao2_cleanup, ao2_container_count(), app, ast_attended_transfer_message_add_app(), ast_attended_transfer_message_create(), ast_bridge_channel_write_playfile(), ast_bridge_channel_write_unhold(), AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY, AST_BRIDGE_FLAG_TRANSFER_PROHIBITED, ast_bridge_lock, ast_bridge_lock_both, ast_bridge_peers_nolock(), ast_bridge_publish_attended_transfer(), ast_bridge_remove(), ast_bridge_transfer_acquire_bridge(), AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_INVALID, AST_BRIDGE_TRANSFER_NOT_PERMITTED, AST_BRIDGE_TRANSFER_SUCCESS, ast_bridge_unlock, ast_channel_appl(), ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_log, ast_softhangup(), AST_SOFTHANGUP_DEV, ast_strdupa, ast_strlen_zero, ast_test_flag, attended_transfer_bridge(), bridge_channel_internal_queue_attended_transfer(), channels, end, ast_bridge::feature_flags, get_transferee(), lock, LOG_ERROR, NULL, pbx_builtin_getvar_helper(), RAII_VAR, SCOPED_LOCK, set_transfer_variables_all(), and two_bridge_attended_transfer().

Referenced by analog_attempt_transfer(), AST_TEST_DEFINE(), attempt_transfer(), local_attended_transfer(), misdn_attempt_transfer(), refer_attended_task(), and skinny_transfer_attended().

{
   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);
   RAII_VAR(struct ast_attended_transfer_message *, transfer_msg, NULL, ao2_cleanup);
   struct ast_bridge *the_bridge = NULL;
   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;
   int hangup_target = 0;

   to_transferee_bridge = ast_bridge_transfer_acquire_bridge(to_transferee);
   to_target_bridge = ast_bridge_transfer_acquire_bridge(to_transfer_target);

   transfer_msg = ast_attended_transfer_message_create(1, to_transferee, to_transferee_bridge,
         to_transfer_target, to_target_bridge, NULL, NULL);
   if (!transfer_msg) {
      ast_log(LOG_ERROR, "Unable to create Stasis publication for attended transfer from %s\n",
            ast_channel_name(to_transferee));
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   /* 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. */
      if (ast_bridge_channel_write_unhold(to_transferee_bridge_channel)) {
         ast_log(LOG_ERROR, "Transferee channel disappeared during transfer!\n");
         res = AST_BRIDGE_TRANSFER_FAIL;
         goto end;
      }
   }

   if (to_target_bridge_channel) {
      const char *target_complete_sound;

      /* Take off hold if they are on hold. */
      if (ast_bridge_channel_write_unhold(to_target_bridge_channel)) {
         ast_log(LOG_ERROR, "Target channel disappeared during transfer!\n");
         res = AST_BRIDGE_TRANSFER_FAIL;
         goto end;
      }

      /* 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, transfer_msg);
      ast_bridge_unlock(to_transferee_bridge);
      ast_bridge_unlock(to_target_bridge);

      hangup_target = 1;
      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;

   /*
    * Race condition makes it possible for app to be NULL, so get the app prior to
    * transferring with a fallback of "unknown".
    */
   app = ast_strdupa(ast_channel_appl(chan_unbridged) ?: "unknown");

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

   set_transfer_variables_all(to_transferee, channels, 1);

   if (do_bridge_transfer) {
      /*
       * Hang up the target if it was bridged. Note, if it is not bridged
       * it is hung up during the masquerade.
       */
      hangup_target = chan_bridged == to_transfer_target;
      ast_bridge_lock(the_bridge);
      res = attended_transfer_bridge(chan_bridged, chan_unbridged, the_bridge, NULL, transfer_msg);
      ast_bridge_unlock(the_bridge);
      goto end;
   }

   transferee = get_transferee(channels, chan_bridged);
   if (!transferee) {
      res = AST_BRIDGE_TRANSFER_FAIL;
      goto end;
   }

   if (bridge_channel_internal_queue_attended_transfer(transferee, chan_unbridged)) {
      res = AST_BRIDGE_TRANSFER_FAIL;
      goto end;
   }

   ast_bridge_remove(the_bridge, chan_bridged);

   ast_attended_transfer_message_add_app(transfer_msg, app, NULL);
   res = AST_BRIDGE_TRANSFER_SUCCESS;

end:
   if ((res == AST_BRIDGE_TRANSFER_SUCCESS && hangup_target) || res == AST_BRIDGE_TRANSFER_FAIL) {
      ast_softhangup(to_transfer_target, AST_SOFTHANGUP_DEV);
   }

   transfer_msg->result = res;
   ast_bridge_publish_attended_transfer(transfer_msg);
   return res;
}

ast_bridge_transfer_blind()

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
	)

Blind transfer target to the extension and context provided.

The channel given is bridged to one or multiple channels. Depending on the bridge and the number of participants, the entire bridge could be transferred to the given destination, or a single channel may be redirected.

Callers may also provide a callback to be called on the channel that will be running dialplan. The user data passed into ast_bridge_transfer_blind will be given as the argument to the callback to be interpreted as desired. This callback is guaranteed to be called in the same thread as ast_bridge_transfer_blind() and before ast_bridge_transfer_blind() returns.

Note

Absolutely NO channel locks should be held before calling this function.

Parameters

is_external	Indicates that transfer was initiated externally
transferer	The channel performing the blind transfer
exten	The dialplan extension to send the call to
context	The dialplan context to send the call to
new_channel_cb	A callback to be called on the channel that will be executing dialplan
user_data	Argument for new_channel_cb

Returns

The success or failure result of the blind transfer

Definition at line 4477 of file bridge.c.

References ao2_alloc, ao2_cleanup, ao2_container_count(), ast_blind_transfer_message_create(), ast_bridge_channel_write_unhold(), AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY, AST_BRIDGE_FLAG_TRANSFER_PROHIBITED, ast_bridge_lock, ast_bridge_peer(), ast_bridge_peers_nolock(), ast_bridge_publish_blind_transfer(), ast_bridge_remove(), ast_bridge_snapshot_create(), ast_bridge_transfer_acquire_bridge(), AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_INVALID, AST_BRIDGE_TRANSFER_NOT_PERMITTED, AST_BRIDGE_TRANSFER_SUCCESS, ast_bridge_unlock, ast_channel_cleanup, ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_name(), ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_channel_unlock, ast_log, ast_test_flag, blind_transfer_bridge(), bridge_manager_request::bridge, bridge_channel_internal_queue_blind_transfer(), channels, ast_bridge::feature_flags, lock, LOG_ERROR, NULL, publish, RAII_VAR, SCOPED_LOCK, set_transfer_variables_all(), and try_parking().

Referenced by action_blind_transfer(), blind_transfer_exec(), console_transfer(), feature_blind_transfer(), handle_request_refer(), refer_incoming_attended_request(), refer_incoming_blind_request(), skinny_transfer_blind(), and socket_process_helper().

{
   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, ast_channel_cleanup);
   RAII_VAR(struct transfer_channel_data *, user_data_wrapper, NULL, ao2_cleanup);
   RAII_VAR(struct ast_blind_transfer_message *, transfer_message, NULL, ao2_cleanup);
   int do_bridge_transfer;
   int transfer_prohibited;
   enum ast_transfer_result transfer_result;

   transfer_message = ast_blind_transfer_message_create(is_external, transferer, exten, context);
   if (!transfer_message) {
      /* Out of memory. Not even possible to publish a Stasis message about the
       * failure
       */
      ast_log(LOG_ERROR, "Unable to allocate memory for blind transfer publication from %s\n",
            ast_channel_name(transferer));
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   bridge = ast_bridge_transfer_acquire_bridge(transferer);
   if (!bridge) {
      transfer_result = AST_BRIDGE_TRANSFER_INVALID;
      goto publish;
   }

   ast_bridge_lock(bridge);
   transfer_message->bridge = ast_bridge_snapshot_create(bridge);
   ast_bridge_unlock(bridge);
   if (!transfer_message->bridge) {
      transfer_result = AST_BRIDGE_TRANSFER_FAIL;
      goto publish;
   }

   transferee = ast_bridge_peer(bridge, transferer);
   if (transferee) {
      transfer_message->transferee = ast_channel_snapshot_get_latest(ast_channel_uniqueid(transferee));
      if (!transfer_message->transferee) {
         transfer_result = AST_BRIDGE_TRANSFER_FAIL;
         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;
   }

   user_data_wrapper = ao2_alloc(sizeof(*user_data_wrapper), NULL);
   if (!user_data_wrapper) {
      transfer_result = AST_BRIDGE_TRANSFER_FAIL;
      goto publish;
   }

   user_data_wrapper->data = user_data;

   /* Take off hold if they are on hold. */
   ast_bridge_channel_write_unhold(bridge_channel);

   transfer_result = try_parking(transferer, context, exten, new_channel_cb, user_data_wrapper);
   if (transfer_result == AST_BRIDGE_TRANSFER_SUCCESS) {
      goto publish;
   }

   /* Since parking didn't take control of the user_data_wrapper, we are just going to raise the completed flag now. */
   user_data_wrapper->completed = 1;

   {
      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_transfer_variables_all(transferer, channels, 0);

   if (do_bridge_transfer) {
      transfer_result = blind_transfer_bridge(is_external, transferer, bridge,
         exten, context, transferee, new_channel_cb, user_data_wrapper, transfer_message);
      goto publish;
   }

   /* Reaching this portion means that we're dealing with a two-party bridge */

   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_wrapper)) {
      transfer_result = AST_BRIDGE_TRANSFER_FAIL;
      goto publish;
   }

   ast_bridge_remove(bridge, transferer);
   transfer_result = AST_BRIDGE_TRANSFER_SUCCESS;

publish:
   transfer_message->result = transfer_result;
   ast_bridge_publish_blind_transfer(transfer_message);
   return transfer_result;
}

ast_bridge_unreal_optimize_out()

int ast_bridge_unreal_optimize_out	(	struct ast_channel *	chan,
		struct ast_channel *	peer,
		struct ast_unreal_pvt *	pvt
	)

Check and optimize out the unreal channels between bridges.

Since

12.0.0

Parameters

chan	Unreal channel writing a frame into the channel driver.
peer	Other unreal channel in the pair.
pvt	Private data provided by an implementation of the unreal driver that contains the callbacks that should be called when optimization begins/ends

Note

It is assumed that chan is already locked.

Return values

0	if unreal channels were not optimized out.
non-zero	if unreal channels were optimized out.

Definition at line 2968 of file bridge.c.

References ast_bridge_channel_unlock, ast_bridge_unlock, ast_channel_internal_bridge_channel(), ast_channel_unlock, optimize_lock_chan_stack(), optimize_lock_peer_stack(), try_merge_optimize_out(), and try_swap_optimize_out().

Referenced by got_optimized_out().

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

ast_bridge_unsuspend()

int ast_bridge_unsuspend	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Unsuspend a channel from a bridge.

Parameters

bridge	Bridge to unsuspend the channel from
chan	Channel to unsuspend

Return values

0	on success
-1	on failure

Example usage:

ast_bridge_unsuspend(bridge, chan);

This unsuspends the channel pointed to by chan from the bridge pointed to by bridge. The bridge will go back to handling the channel once this function returns.

Note

You must not mess with the channel once this function returns. Doing so may result in bad things happening.

Definition at line 3089 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, bridge_channel_internal_unsuspend_nolock(), and bridge_find_channel().

Referenced by conf_moh_start(), and conf_moh_stop().

{
   struct ast_bridge_channel *bridge_channel;
/* XXX ASTERISK-21271 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;
}

ast_bridge_update_talker_src_video_mode()

void ast_bridge_update_talker_src_video_mode	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan,
		int	talker_energy,
		int	is_keyframe
	)

Update information about talker energy for talker src video mode.

Definition at line 3883 of file bridge.c.

References ast_bridge_lock, ast_bridge_publish_state(), ast_bridge_unlock, ast_channel_name(), ast_channel_nativeformats(), ast_channel_ref, ast_channel_uniqueid(), ast_channel_unref, AST_CONTROL_VIDUPDATE, ast_format_cap_has_type(), ast_indicate(), AST_MEDIA_TYPE_VIDEO, ast_verb, ast_bridge_video_talker_src_data::average_talking_energy, ast_bridge_video_talker_src_data::chan_old_vsrc, ast_bridge_video_talker_src_data::chan_vsrc, ast_bridge_video_mode::mode_data, ast_bridge::name, ast_bridge::softmix, ast_bridge_video_mode::talker_src_data, ast_bridge::uniqueid, and ast_bridge_softmix::video_mode.

Referenced by softmix_bridge_write_video().

{
   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_MEDIA_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) {
         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_verb(5, "Video source in bridge '%s' (%s) is now '%s' (%s)\n",
         bridge->name, bridge->uniqueid,
         ast_channel_name(data->chan_vsrc),
         ast_channel_uniqueid(data->chan_vsrc));
      ast_bridge_publish_state(bridge);
      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_verb(5, "Video source in bridge '%s' (%s) is now '%s' (%s)\n",
         bridge->name, bridge->uniqueid,
         ast_channel_name(data->chan_vsrc),
         ast_channel_uniqueid(data->chan_vsrc));
      ast_bridge_publish_state(bridge);
      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);
}

ast_bridge_vars_set()

void ast_bridge_vars_set	(	struct ast_channel *	chan,
		const char *	name,
		const char *	pvtid
	)

Sets BRIDGECHANNEL and BRIDGEPVTCALLID for a channel.

Precondition

chan must be locked before calling

Parameters

name	channel name of the bridged peer
pvtid	Private CallID of the bridged peer

Returns

nothing

Definition at line 1242 of file bridge.c.

References ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), and pbx_builtin_setvar_helper().

Referenced by ast_bridge_channel_leave_bridge_nolock(), set_bridge_peer_vars_2party(), set_bridge_peer_vars_holding(), and set_bridge_peer_vars_multiparty().

{
   ast_channel_stage_snapshot(chan);
   pbx_builtin_setvar_helper(chan, "BRIDGEPEER", name);
   pbx_builtin_setvar_helper(chan, "BRIDGEPVTCALLID", pvtid);
   ast_channel_stage_snapshot_done(chan);
}

ast_bridge_video_mode_to_string()

const char* ast_bridge_video_mode_to_string

(

enum ast_bridge_video_mode_type

video_mode

)

Converts an enum representation of a bridge video mode to string.

Parameters

video_mode

The video mode

Return values

A	string representation of video_mode

Definition at line 4018 of file bridge.c.

References AST_BRIDGE_VIDEO_MODE_NONE, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, and AST_BRIDGE_VIDEO_MODE_TALKER_SRC.

Referenced by ast_bridge_snapshot_to_json(), ast_manager_build_bridge_state_string_prefix(), and handle_bridge_show_specific().

{
   switch (video_mode) {
   case AST_BRIDGE_VIDEO_MODE_TALKER_SRC:
      return "talker";
   case AST_BRIDGE_VIDEO_MODE_SINGLE_SRC:
      return "single";
   case AST_BRIDGE_VIDEO_MODE_SFU:
      return "sfu";
   case AST_BRIDGE_VIDEO_MODE_NONE:
   default:
      return "none";
   }
}

ast_bridges()

struct ao2_container* ast_bridges

(

void

)

Returns the global bridges container.

Since

17.0

Return values

a	pointer to the bridges container success
NULL	on failure

Note

You must use ao2_ref(<container>, -1) when done with it

Warning

You must not attempt to modify the container returned.

Definition at line 174 of file bridge.c.

References ao2_bump.

Referenced by ast_ari_bridges_list(), bridges_scrape_cb(), and manager_bridges_list().

{
   return ao2_bump(bridges);
}

ast_bridges_allow_optimization()

enum ast_bridge_optimization ast_bridges_allow_optimization	(	struct ast_bridge *	chan_bridge,
		struct ast_bridge *	peer_bridge
	)

Determine if bridges allow for optimization to occur betweem them.

Since

12.0.0

Parameters

chan_bridge	First bridge being tested
peer_bridge	Second bridge being tested

This determines if two bridges allow for unreal channel optimization to occur between them. The function does not require for unreal channels to already be in the bridges when called.

Note

It is assumed that both bridges are locked prior to calling this function

A return other than AST_BRIDGE_OPTIMIZE_PROHIBITED does not guarantee that an optimization attempt will succeed. However, a return of AST_BRIDGE_OPTIMIZE_PROHIBITED guarantees that an optimization attempt will never succeed.

Returns

Optimization allowability for the bridges

Definition at line 3008 of file bridge.c.

References AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE, AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE, AST_BRIDGE_OPTIMIZE_PROHIBITED, AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE, AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE, bridge_allows_optimization(), bridges_allow_merge_optimization(), bridges_allow_swap_optimization(), merge_direction::dest, MERGE_ALLOWED, SWAP_PROHIBITED, SWAP_TO_CHAN_BRIDGE, and SWAP_TO_PEER_BRIDGE.

Referenced by two_bridge_attended_transfer().

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

ast_bridging_init()

int ast_bridging_init

(

void

)

Initialize the bridging system.

Since

12.0.0

Return values

0	on success.
-1	on error.

Definition at line 5605 of file bridge.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, ao2_container_alloc_rbtree, ao2_container_register(), ARRAY_LEN, ast_bridging_init_basic(), ast_cli_register_multiple, ast_manager_register_xml_core, ast_register_cleanup(), ast_stasis_bridging_init(), bridge_cleanup(), bridge_manager_create(), bridge_prnt_obj(), bridge_sort_cmp(), manager_bridge_tech_list(), manager_bridge_tech_suspend(), manager_bridge_tech_unsuspend(), and NULL.

Referenced by asterisk_daemon().

{
   ast_register_cleanup(bridge_cleanup);

   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;
   }
   ao2_container_register("bridges", bridges, bridge_prnt_obj);

   ast_bridging_init_basic();

   ast_cli_register_multiple(bridge_cli, ARRAY_LEN(bridge_cli));

   ast_manager_register_xml_core("BridgeTechnologyList", 0, manager_bridge_tech_list);
   ast_manager_register_xml_core("BridgeTechnologySuspend", 0, manager_bridge_tech_suspend);
   ast_manager_register_xml_core("BridgeTechnologyUnsuspend", 0, manager_bridge_tech_unsuspend);

   return 0;
}

ast_brige_set_remb_behavior()

void ast_brige_set_remb_behavior	(	struct ast_bridge *	bridge,
		enum ast_bridge_video_sfu_remb_behavior	behavior
	)

Set the REMB report generation behavior on a bridge.

Parameters

bridge	Bridge to set the REMB behavior on
behavior	How REMB reports are generated

Note

This can only be called when the bridge has been set to the SFU video mode.

Definition at line 3865 of file bridge.c.

References ast_assert, ast_bridge_lock, ast_bridge_unlock, AST_BRIDGE_VIDEO_MODE_SFU, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_sfu_data::remb_behavior, ast_bridge_video_mode::sfu_data, ast_bridge::softmix, and ast_bridge_softmix::video_mode.

Referenced by join_conference_bridge().

{
   ast_assert(bridge->softmix.video_mode.mode == AST_BRIDGE_VIDEO_MODE_SFU);

   ast_bridge_lock(bridge);
   bridge->softmix.video_mode.mode_data.sfu_data.remb_behavior = behavior;
   ast_bridge_unlock(bridge);
}

attended_transfer_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 ast_attended_transfer_message *  transfer_msg  )

static

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.

Parameters

chan1	Transferer channel. Guaranteed to be bridged.
chan2	Other transferer channel. May or may not be bridged.
bridge1	Bridge that chan1 is in. Guaranteed to be non-NULL.
bridge2	Bridge that chan2 is in. If NULL, then chan2 is not bridged.
publication	Data to publish for a stasis attended transfer message.

Return values

AST_BRIDGE_TRANSFER_FAIL	Internal error occurred
AST_BRIDGE_TRANSFER_SUCCESS	Succesfully transferred the bridge

Definition at line 4280 of file bridge.c.

References ao2_cleanup, ao2_ref, app, ast_attended_transfer_message_add_app(), ast_attended_transfer_message_add_link(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_SUCCESS, ast_bridge_unlock, ast_call(), ast_channel_appl(), ast_channel_lock_both, ast_channel_name(), ast_channel_nativeformats(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_REPLACEMENT, ast_channel_unlock, ast_hangup(), ast_local_lock_all(), ast_local_setup_bridge(), ast_local_setup_masquerade(), ast_local_unlock_all(), ast_log, ast_request(), ast_strdupa, ATTENDEDTRANSFER, BRIDGE_LOCK_ONE_OR_BOTH, locals, LOG_ERROR, NULL, pbx_builtin_setvar_helper(), SWAP, and ast_channel::tech.

Referenced by ast_bridge_transfer_attended(), and two_bridge_attended_transfer().

{
#define BRIDGE_LOCK_ONE_OR_BOTH(b1, b2) \
   do { \
      if (b2) { \
         ast_bridge_lock_both(b1, b2); \
      } else { \
         ast_bridge_lock(b1); \
      } \
   } while (0)

   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), NULL, chan1,
         dest, &cause);
   if (!local_chan) {
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   ast_channel_lock_both(local_chan, chan1);
   ast_channel_req_accountcodes(local_chan, chan1, AST_CHANNEL_REQUESTOR_REPLACEMENT);
   pbx_builtin_setvar_helper(local_chan, ATTENDEDTRANSFER, ast_channel_name(chan1));
   ast_channel_unlock(local_chan);
   ast_channel_unlock(chan1);

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

   /*
    * Since bridges need to be unlocked before entering ast_bridge_impart and
    * core_local may call into it then the bridges need to be unlocked here.
    */
   ast_bridge_unlock(bridge1);
   if (bridge2) {
      ast_bridge_unlock(bridge2);
   }

   if (ast_call(local_chan, dest, 0)) {
      ast_hangup(local_chan);
      BRIDGE_LOCK_ONE_OR_BOTH(bridge1, bridge2);
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   /* Get a ref for use later since this one is being stolen */
   ao2_ref(local_chan, +1);
   if (ast_bridge_impart(bridge1, local_chan, chan1, NULL,
      AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
      ast_hangup(local_chan);
      ao2_cleanup(local_chan);
      BRIDGE_LOCK_ONE_OR_BOTH(bridge1, bridge2);
      return AST_BRIDGE_TRANSFER_FAIL;
   }
   BRIDGE_LOCK_ONE_OR_BOTH(bridge1, bridge2);

   if (bridge2) {
      void *tech;
      struct ast_channel *locals[2];

      /* Have to lock everything just in case a hangup comes in early */
      ast_local_lock_all(local_chan, &tech, &locals[0], &locals[1]);
      if (!locals[0] || !locals[1]) {
         ast_log(LOG_ERROR, "Transfer failed probably due to an early hangup - "
            "missing other half of '%s'\n", ast_channel_name(local_chan));
         ast_local_unlock_all(tech, locals[0], locals[1]);
         ao2_cleanup(local_chan);
         return AST_BRIDGE_TRANSFER_FAIL;
      }

      /* Make sure the peer is properly set */
      if (local_chan != locals[0]) {
         SWAP(locals[0], locals[1]);
      }

      ast_attended_transfer_message_add_link(transfer_msg, locals);
      ast_local_unlock_all(tech, locals[0], locals[1]);
   } else {
      ast_attended_transfer_message_add_app(transfer_msg, app, local_chan);
   }

   ao2_cleanup(local_chan);
   return AST_BRIDGE_TRANSFER_SUCCESS;
}

blind_transfer_bridge()

static enum ast_transfer_result blind_transfer_bridge ( int  is_external, struct ast_channel *  transferer, struct ast_bridge *  bridge, const char *  exten, const char *  context, struct ast_channel *  transferee, transfer_channel_cb  new_channel_cb, struct transfer_channel_data *  user_data_wrapper, struct ast_blind_transfer_message *  transfer_message  )

static

Definition at line 4178 of file bridge.c.

References ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_MULTI_PARTY, AST_BRIDGE_TRANSFER_SUCCESS, ast_call(), ast_channel_lock_both, ast_channel_name(), ast_channel_nativeformats(), ast_channel_req_accountcodes(), AST_CHANNEL_REQUESTOR_REPLACEMENT, ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_channel_unlock, ast_hangup(), AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_request(), BLINDTRANSFER, NULL, pbx_builtin_setvar_helper(), and ast_blind_transfer_message::replace_channel.

Referenced by ast_bridge_transfer_blind().

{
   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), NULL, transferer,
         chan_name, &cause);
   if (!local) {
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   ast_channel_lock_both(local, transferer);
   ast_channel_req_accountcodes(local, transferer, AST_CHANNEL_REQUESTOR_REPLACEMENT);

   transfer_message->replace_channel = ast_channel_snapshot_get_latest(ast_channel_uniqueid(local));
   if (!transfer_message->replace_channel) {
      ast_hangup(local);
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   pbx_builtin_setvar_helper(local, BLINDTRANSFER, ast_channel_name(transferer));
   ast_channel_unlock(local);
   ast_channel_unlock(transferer);

   if (new_channel_cb) {
      new_channel_cb(local, user_data_wrapper, 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,
      AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
      ast_hangup(local);
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   return AST_BRIDGE_TRANSFER_SUCCESS;
}

bridge_action_bridge()

static void bridge_action_bridge ( struct ast_bridge *  bridge, struct ast_frame *  action  )

static

Definition at line 604 of file bridge.c.

References ao2_ref, ast_assert, ast_bridge_lock, ast_bridge_unlock, BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING, BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY, bridge_tech_deferred_destroy(), ast_bridge_methods::dissolving, ast_frame_subclass::integer, ast_frame::subclass, and ast_bridge::v_table.

Referenced by bridge_handle_actions().

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

bridge_alloc()

struct ast_bridge* bridge_alloc	(	size_t	size,
		const struct ast_bridge_methods *	v_table
	)

Definition at line 724 of file bridge.c.

References ao2_alloc, ao2_cleanup, ast_assert, ast_log, AST_MEDIA_TYPE_END, ast_string_field_init, AST_VECTOR_INIT, bridge_manager_request::bridge, ast_bridge_methods::destroy, destroy_bridge(), ast_bridge_methods::dissolving, ast_bridge_methods::get_merge_priority, LOG_ERROR, ast_bridge::media_types, ast_bridge_methods::name, ast_bridge_methods::notify_masquerade, NULL, ast_bridge_methods::pull, ast_bridge_methods::push, and ast_bridge::v_table.

Referenced by ast_bridge_base_new(), ast_bridge_basic_new(), bridge_agent_hold_new(), bridge_parking_new(), and bridge_stasis_new().

{
   struct ast_bridge *bridge;

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

   bridge = ao2_alloc(size, destroy_bridge);
   if (!bridge) {
      return NULL;
   }

   if (ast_string_field_init(bridge, 80)) {
      ao2_cleanup(bridge);
      return NULL;
   }

   bridge->v_table = v_table;

   AST_VECTOR_INIT(&bridge->media_types, AST_MEDIA_TYPE_END);

   return bridge;
}

bridge_allows_optimization()

static int bridge_allows_optimization ( struct ast_bridge *  bridge )

static

Definition at line 2608 of file bridge.c.

References AST_BRIDGE_FLAG_MASQUERADE_ONLY, ast_test_flag, ast_bridge::dissolved, ast_bridge::feature_flags, and ast_bridge::inhibit_merge.

Referenced by ast_bridges_allow_optimization(), optimize_lock_chan_stack(), and optimize_lock_peer_stack().

{
   return !(bridge->inhibit_merge
      || bridge->dissolved
      || ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_MASQUERADE_ONLY));
}

bridge_base_destroy()

static void bridge_base_destroy ( struct ast_bridge *  self )

static

Definition at line 841 of file bridge.c.

{
}

bridge_base_dissolving()

static void bridge_base_dissolving ( struct ast_bridge *  self )

static

Definition at line 854 of file bridge.c.

References ao2_unlink.

{
   ao2_unlink(bridges, self);
}

bridge_base_get_merge_priority()

static int bridge_base_get_merge_priority ( struct ast_bridge *  self )

static

Definition at line 924 of file bridge.c.

{
   return 0;
}

bridge_base_init()

struct ast_bridge* bridge_base_init	(	struct ast_bridge *	self,
		uint32_t	capabilities,
		unsigned int	flags,
		const char *	creator,
		const char *	name,
		const char *	id
	)

Initialize the base class of the bridge.

Parameters

self	Bridge to operate upon. (Tolerates a NULL pointer)
capabilities	The capabilities that we require to be used on the bridge
flags	Flags that will alter the behavior of the bridge
creator	Entity that created the bridge (optional)
name	Name given to the bridge by its creator (optional, requires named creator)
id	Unique ID given to the bridge by its creator (optional)

Return values

self	on success
NULL	on failure, self is already destroyed

Example usage:

struct ast_bridge *bridge;
bridge = bridge_alloc(sizeof(*bridge), &ast_bridge_base_v_table);
bridge = bridge_base_init(bridge, AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_FLAG_DISSOLVE_HANGUP, NULL, NULL, NULL);

This creates a no frills two party bridge that will be destroyed once one of the channels hangs up.

Definition at line 760 of file bridge.c.

References ao2_ref, AST_BRIDGE_FLAG_INVISIBLE, ast_bridge_topic(), ast_debug, ast_log, ast_set_flag, ast_string_field_set, ast_strlen_zero, ast_tvnow(), ast_uuid_generate_str(), AST_UUID_STR_LEN, bridge_topics_init(), find_best_technology(), LOG_WARNING, NULL, and ast_bridge::uniqueid.

Referenced by ast_bridge_base_new(), ast_bridge_basic_new(), bridge_agent_hold_new(), bridge_parking_new(), and bridge_stasis_new().

{
   char uuid_hold[AST_UUID_STR_LEN];

   if (!self) {
      return NULL;
   }

   if (!ast_strlen_zero(id)) {
      ast_string_field_set(self, uniqueid, id);
   } else {
      ast_uuid_generate_str(uuid_hold, AST_UUID_STR_LEN);
      ast_string_field_set(self, uniqueid, uuid_hold);
   }
   ast_string_field_set(self, creator, creator);
   if (!ast_strlen_zero(creator)) {
      ast_string_field_set(self, name, name);
   }

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

   if (!(flags & AST_BRIDGE_FLAG_INVISIBLE)) {
      if (bridge_topics_init(self) != 0) {
         ast_log(LOG_WARNING, "Bridge %s: Could not initialize topics\n",
            self->uniqueid);
         ao2_ref(self, -1);
         return NULL;
      }
   }

   /* 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 (!(flags & AST_BRIDGE_FLAG_INVISIBLE)) {
      if (!ast_bridge_topic(self)) {
         ao2_ref(self, -1);
         return NULL;
      }
   }

   self->creationtime = ast_tvnow();

   return self;
}

bridge_base_notify_masquerade()

static void bridge_base_notify_masquerade ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 908 of file bridge.c.

{
   self->reconfigured = 1;
}

bridge_base_pull()

static void bridge_base_pull ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 891 of file bridge.c.

References ast_bridge_features_remove(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, and ast_bridge_channel::features.

{
   ast_bridge_features_remove(bridge_channel->features, AST_BRIDGE_HOOK_REMOVE_ON_PULL);
}

bridge_base_push()

static int bridge_base_push ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel, struct ast_bridge_channel *  swap  )

static

Definition at line 874 of file bridge.c.

{
   return 0;
}

bridge_base_push_peek()

static int bridge_base_push_peek ( struct ast_bridge *  self, struct ast_bridge_channel *  bridge_channel, struct ast_bridge_channel *  swap  )

static

Definition at line 944 of file bridge.c.

{
   return 0;
}

bridge_channel_change_bridge()

static void bridge_channel_change_bridge ( struct ast_bridge_channel *  bridge_channel, struct ast_bridge *  new_bridge  )

static

Definition at line 2055 of file bridge.c.

References ao2_ref, ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_internal_bridge_set(), ast_channel_lock, ast_channel_unlock, ast_bridge_channel::bridge, and ast_bridge_channel::chan.

Referenced by bridge_do_merge(), and bridge_do_move().

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

bridge_channel_complete_join()

static void bridge_channel_complete_join ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 443 of file bridge.c.

References ast_bridge_channel_leave_bridge(), ast_bridge_channel_stream_map(), ast_channel_name(), ast_debug, ast_bridge_channel::bridge, BRIDGE_CHANNEL_STATE_END, ast_bridge_channel::chan, ast_bridge_technology::join, ast_bridge_channel::just_joined, ast_bridge_technology::name, ast_bridge_technology::stream_topology_changed, ast_bridge::technology, and ast_bridge::uniqueid.

Referenced by bridge_complete_join(), and smart_bridge_operation().

{
   /* 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)) {
      /* We cannot leave the channel partially in the bridge so we must kick it out */
      ast_debug(1, "Bridge %s: %p(%s) failed to join %s technology (Kicking it out)\n",
         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
         bridge->technology->name);
      bridge_channel->just_joined = 1;
      ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, 0);
      return;
   }

   bridge_channel->just_joined = 0;

   /*
    * When a channel joins the bridge its streams need to be mapped to the bridge's
    * media types vector. This way all streams map to the same media type index for
    * a given channel.
    */
   if (bridge_channel->bridge->technology->stream_topology_changed) {
      bridge_channel->bridge->technology->stream_topology_changed(
         bridge_channel->bridge, bridge_channel);
   } else {
      ast_bridge_channel_stream_map(bridge_channel);
   }
}

bridge_channel_depart_thread()

static void* bridge_channel_depart_thread ( void *  data )

static

Thread responsible for imparted bridged channels to be departed.

Definition at line 1757 of file bridge.c.

References ao2_t_cleanup, AST_BRIDGE_AFTER_CB_REASON_DEPART, AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED, ast_bridge_discard_after_callback(), ast_bridge_discard_after_goto(), ast_bridge_features_destroy(), ast_callid_threadassoc_add(), bridge_channel_impart_signal(), bridge_channel_internal_join(), ast_bridge_channel::callid, ast_bridge_channel::chan, ast_bridge_channel::features, NULL, and ast_bridge_channel::swap.

Referenced by bridge_impart_internal().

{
   struct ast_bridge_channel *bridge_channel = data;
   int res = 0;

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

   res = bridge_channel_internal_join(bridge_channel);

   /*
    * cleanup
    *
    * If bridge_channel->swap is not NULL then the join failed.
    */
   ao2_t_cleanup(bridge_channel->swap, "Bridge complete: Departable impart join failed");
   bridge_channel->swap = NULL;
   ast_bridge_features_destroy(bridge_channel->features);
   bridge_channel->features = NULL;

   ast_bridge_discard_after_callback(bridge_channel->chan,
      res ? AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED : AST_BRIDGE_AFTER_CB_REASON_DEPART);
   /* If join failed there will be impart threads waiting. */
   bridge_channel_impart_signal(bridge_channel->chan);
   ast_bridge_discard_after_goto(bridge_channel->chan);

   return NULL;
}

bridge_channel_impart_add()

static int bridge_channel_impart_add ( struct ast_channel *  chan, struct bridge_channel_impart_cond *  cond  )

static

Definition at line 1593 of file bridge.c.

References ast_assert, ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), AST_LIST_INSERT_TAIL, ast_datastore::data, and NULL.

Referenced by bridge_impart_internal().

{
   struct ast_datastore *datastore;
   struct bridge_channel_impart_ds_head *ds_head;

   ast_channel_lock(chan);

   datastore = ast_channel_datastore_find(chan, &bridge_channel_impart_ds_info, NULL);
   if (!datastore) {
      datastore = ast_datastore_alloc(&bridge_channel_impart_ds_info, NULL);
      if (!datastore) {
         ast_channel_unlock(chan);
         return -1;
      }
      ds_head = ast_calloc(1, sizeof(*ds_head));
      if (!ds_head) {
         ast_channel_unlock(chan);
         ast_datastore_free(datastore);
         return -1;
      }
      datastore->data = ds_head;
      ast_channel_datastore_add(chan, datastore);
   } else {
      ds_head = datastore->data;
      ast_assert(ds_head != NULL);
   }

   AST_LIST_INSERT_TAIL(ds_head, cond, node);

   ast_channel_unlock(chan);
   return 0;
}

bridge_channel_impart_ds_head_dtor()

static void bridge_channel_impart_ds_head_dtor ( void *  doomed )

static

Definition at line 1550 of file bridge.c.

References ast_free, and bridge_channel_impart_ds_head_signal().

{
   bridge_channel_impart_ds_head_signal(doomed);
   ast_free(doomed);
}

bridge_channel_impart_ds_head_fixup()

static void bridge_channel_impart_ds_head_fixup ( void *  data, struct ast_channel *  old_chan, struct ast_channel *  new_chan  )

static

Definition at line 1567 of file bridge.c.

References bridge_channel_impart_ds_head_signal().

{
   /*
    * Signal any waiting impart threads.  The masquerade is going to kill
    * old_chan and we don't need to be waiting on new_chan.
    */
   bridge_channel_impart_ds_head_signal(data);
}

bridge_channel_impart_ds_head_signal()

static void bridge_channel_impart_ds_head_signal ( struct bridge_channel_impart_ds_head *  ds_head )

static

Definition at line 1536 of file bridge.c.

References ast_cond_signal, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, cond, bridge_channel_impart_cond::cond, bridge_channel_impart_cond::done, and bridge_channel_impart_cond::lock.

Referenced by bridge_channel_impart_ds_head_dtor(), bridge_channel_impart_ds_head_fixup(), and bridge_channel_impart_signal().

{
   if (ds_head) {
      struct bridge_channel_impart_cond *cond;

      while ((cond = AST_LIST_REMOVE_HEAD(ds_head, node))) {
         ast_mutex_lock(&cond->lock);
         cond->done = 1;
         ast_cond_signal(&cond->cond);
         ast_mutex_unlock(&cond->lock);
      }
   }
}

bridge_channel_impart_signal()

void bridge_channel_impart_signal

(

struct ast_channel *

chan

)

Signal imparting threads to wake up.

Since

13.9.0

Parameters

chan	Channel imparted that we need to signal.

Returns

Nothing

Definition at line 1626 of file bridge.c.

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, bridge_channel_impart_ds_head_signal(), ast_datastore::data, and NULL.

Referenced by ast_bridge_impart(), ast_bridge_join(), bridge_channel_depart_thread(), bridge_channel_ind_thread(), and bridge_channel_internal_join().

{
   struct ast_datastore *datastore;

   ast_channel_lock(chan);
   datastore = ast_channel_datastore_find(chan, &bridge_channel_impart_ds_info, NULL);
   if (datastore) {
      bridge_channel_impart_ds_head_signal(datastore->data);
   }
   ast_channel_unlock(chan);
}

bridge_channel_impart_wait()

static void bridge_channel_impart_wait ( struct bridge_channel_impart_cond *  cond )

static

Definition at line 1647 of file bridge.c.

References ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, bridge_channel_impart_cond::cond, bridge_channel_impart_cond::done, and bridge_channel_impart_cond::lock.

Referenced by bridge_impart_internal().

{
   ast_mutex_lock(&cond->lock);
   while (!cond->done) {
      ast_cond_wait(&cond->cond, &cond->lock);
   }
   ast_mutex_unlock(&cond->lock);
}

bridge_channel_ind_thread()

static void* bridge_channel_ind_thread ( void *  data )

static

Thread responsible for independent imparted bridged channels.

Definition at line 1788 of file bridge.c.

References ao2_lock, ao2_ref, ao2_t_cleanup, ao2_unlock, ast_bridge_features_destroy(), ast_bridge_run_after_callback(), ast_bridge_run_after_goto(), ast_callid_threadassoc_add(), ast_channel_internal_bridge_channel_set(), ast_channel_lock, ast_channel_unlock, bridge_channel_impart_signal(), bridge_channel_internal_join(), ast_bridge_channel::callid, ast_bridge_channel::chan, ast_bridge_channel::features, NULL, and ast_bridge_channel::swap.

Referenced by bridge_impart_internal().

{
   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);
   /* Lock here for ast_bridge_channel_get_chan */
   ao2_lock(bridge_channel);
   bridge_channel->chan = NULL;
   ao2_unlock(bridge_channel);
   /* If bridge_channel->swap is not NULL then the join failed. */
   ao2_t_cleanup(bridge_channel->swap, "Bridge complete: Independent impart join failed");
   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);
   /* If join failed there will be impart threads waiting. */
   bridge_channel_impart_signal(chan);
   ast_bridge_run_after_goto(chan);
   return NULL;
}

bridge_channel_moving()

static void bridge_channel_moving ( struct ast_bridge_channel *  bridge_channel, struct ast_bridge *  src, struct ast_bridge *  dst  )

static

Definition at line 2070 of file bridge.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ao2_unlink, AST_BRIDGE_HOOK_TYPE_MOVE, ast_channel_name(), ast_debug, ast_bridge_hook::callback, ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_hook::hook_pvt, ast_bridge_features::other_hooks, and ast_bridge_hook::type.

Referenced by bridge_do_merge(), and bridge_do_move().

{
   struct ast_bridge_features *features = bridge_channel->features;
   struct ast_bridge_hook *hook;
   struct ao2_iterator iter;

   /* Run any moving hooks. */
   iter = ao2_iterator_init(features->other_hooks, 0);
   for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
      int remove_me;
      ast_bridge_move_indicate_callback move_cb;

      if (hook->type != AST_BRIDGE_HOOK_TYPE_MOVE) {
         continue;
      }
      move_cb = (ast_bridge_move_indicate_callback) hook->callback;
      remove_me = move_cb(bridge_channel, hook->hook_pvt, src, dst);
      if (remove_me) {
         ast_debug(1, "Move detection hook %p is being removed from %p(%s)\n",
            hook, bridge_channel, ast_channel_name(bridge_channel->chan));
         ao2_unlink(features->other_hooks, hook);
      }
   }
   ao2_iterator_destroy(&iter);
}

bridge_cleanup()

static void bridge_cleanup ( void  )

static

Definition at line 5591 of file bridge.c.

References ao2_cleanup, ao2_container_unregister(), ARRAY_LEN, ast_cli_unregister_multiple(), ast_manager_unregister(), and NULL.

Referenced by ast_bridging_init().

{
   ast_manager_unregister("BridgeTechnologyList");
   ast_manager_unregister("BridgeTechnologySuspend");
   ast_manager_unregister("BridgeTechnologyUnsuspend");
   ast_cli_unregister_multiple(bridge_cli, ARRAY_LEN(bridge_cli));
   ao2_container_unregister("bridges");

   ao2_cleanup(bridges);
   bridges = NULL;
   ao2_cleanup(bridge_manager);
   bridge_manager = NULL;
}

bridge_complete_join()

static void bridge_complete_join ( struct ast_bridge *  bridge )

static

Definition at line 486 of file bridge.c.

References AST_LIST_TRAVERSE, bridge_channel_complete_join(), bridge_channel_queue_deferred_frames(), ast_bridge::channels, ast_bridge::dissolved, and ast_bridge_channel::just_joined.

Referenced by bridge_reconfigured().

{
   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) {
      bridge_channel_queue_deferred_frames(bridge_channel);
      if (!bridge_channel->just_joined) {
         continue;
      }
      bridge_channel_complete_join(bridge, bridge_channel);
   }
}

bridge_dissolve()

void bridge_dissolve	(	struct ast_bridge *	bridge,
		int	cause
	)

Definition at line 319 of file bridge.c.

References ast_bridge_channel_leave_bridge(), ast_bridge_queue_action(), ast_cause2str(), AST_CAUSE_NORMAL_CLEARING, ast_debug, AST_FRAME_BRIDGE_ACTION, AST_LIST_TRAVERSE, BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, ast_bridge::cause, ast_bridge::channels, ast_bridge::dissolved, ast_frame::frametype, and ast_bridge::uniqueid.

Referenced by ast_bridge_destroy(), bridge_channel_dissolve_check(), bridge_dissolve_check_stolen(), and bridge_reconfigured().

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

   if (cause <= 0) {
      cause = AST_CAUSE_NORMAL_CLEARING;
   }
   bridge->cause = cause;

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

   AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
      ast_bridge_channel_leave_bridge(bridge_channel,
         BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, cause);
   }

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

bridge_dissolve_check_stolen()

static void bridge_dissolve_check_stolen ( struct ast_bridge *  bridge, struct ast_bridge_channel *  bridge_channel  )

static

Definition at line 361 of file bridge.c.

References AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP, AST_BRIDGE_FLAG_DISSOLVE_HANGUP, ast_test_flag, bridge_dissolve(), ast_bridge::dissolved, ast_bridge_features::feature_flags, ast_bridge::feature_flags, ast_bridge_channel::features, ast_bridge::num_channels, and ast_bridge_features::usable.

Referenced by ast_bridge_add_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, 0);
      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, 0);
      return;
   }
}

bridge_do_merge()

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
	)

Definition at line 2096 of file bridge.c.

References AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE, ast_bridge_channel_leave_bridge(), ast_bridge_channel_leave_bridge_nolock(), ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_bridge_features_remove(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_bridge_publish_merge(), AST_CAUSE_NORMAL_CLEARING, ast_debug, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_test_flag, ast_bridge_channel::bridge, bridge_channel_change_bridge(), bridge_channel_internal_pull(), bridge_channel_internal_push(), bridge_channel_moving(), BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_CHANNEL_STATE_WAIT, bridge_reconfigured(), ast_bridge::cause, ast_bridge::channels, ast_bridge_features::feature_flags, ast_bridge_channel::features, ast_bridge_channel::state, and ast_bridge::uniqueid.

Referenced by bridge_merge(), bridge_merge_locked(), try_merge_optimize_out(), and two_bridge_attended_transfer().

{
   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, AST_CAUSE_NORMAL_CLEARING);
               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;
      }

      bridge_channel_moving(bridge_channel, bridge_channel->bridge, dst_bridge);

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

      if (bridge_channel_internal_push(bridge_channel)) {
         ast_bridge_features_remove(bridge_channel->features,
            AST_BRIDGE_HOOK_REMOVE_ON_PULL);
         ast_bridge_channel_leave_bridge(bridge_channel,
            BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
      }
   }
   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, AST_CAUSE_NORMAL_CLEARING);
            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);
}

bridge_do_move()

int bridge_do_move	(	struct ast_bridge *	dst_bridge,
		struct ast_bridge_channel *	bridge_channel,
		int	attempt_recovery,
		unsigned int	optimized
	)

Definition at line 2362 of file bridge.c.

References ao2_ref, ast_bridge_channel_leave_bridge(), ast_bridge_features_remove(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_channel_name(), ast_debug, ast_bridge_channel::bridge, bridge_channel_change_bridge(), bridge_channel_internal_pull(), bridge_channel_internal_push(), bridge_channel_internal_push_full(), bridge_channel_moving(), bridge_channel_settle_owed_events(), BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_CHANNEL_STATE_WAIT, bridge_reconfigured(), ast_bridge::cause, ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_channel::in_bridge, NULL, ast_bridge_channel::state, ast_bridge_channel::swap, and ast_bridge::uniqueid.

Referenced by bridge_move(), bridge_move_locked(), bridge_swap_attended_transfer(), and try_swap_optimize_out().

{
   struct ast_bridge *orig_bridge;
   int was_in_bridge;
   int res = 0;

   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.
       *
       * Clear out the swap channel pointer.  A ref is not held
       * by bridge_channel->swap at this point.
       */
      bridge_channel->swap = NULL;
      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);

   bridge_channel_moving(bridge_channel, orig_bridge, dst_bridge);

   if (bridge_channel_internal_push_full(bridge_channel, optimized)) {
      /* Try to put the channel back into the original bridge. */
      ast_bridge_features_remove(bridge_channel->features,
         AST_BRIDGE_HOOK_REMOVE_ON_PULL);
      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_features_remove(bridge_channel->features,
               AST_BRIDGE_HOOK_REMOVE_ON_PULL);
            ast_bridge_channel_leave_bridge(bridge_channel,
               BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
         }
      } else {
         ast_bridge_channel_leave_bridge(bridge_channel,
            BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_channel->bridge->cause);
         bridge_channel_settle_owed_events(orig_bridge, bridge_channel);
      }
      res = -1;
   } else if (!optimized) {
      bridge_channel_settle_owed_events(orig_bridge, bridge_channel);
   }

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

bridge_dtmf_hook_sort()

static int bridge_dtmf_hook_sort ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 3606 of file bridge.c.

References ast_bridge_hook_dtmf_parms::code, ast_bridge_hook_dtmf::dtmf, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by ast_bridge_features_init().

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

bridge_find_channel()

struct ast_bridge_channel* bridge_find_channel	(	struct ast_bridge *	bridge,
		struct ast_channel *	chan
	)

Definition at line 1469 of file bridge.c.

References AST_LIST_TRAVERSE, ast_bridge_channel::chan, and ast_bridge::channels.

Referenced by ast_bridge_add_channel(), ast_bridge_join(), ast_bridge_kick(), ast_bridge_notify_masquerade(), ast_bridge_remove(), ast_bridge_suspend(), ast_bridge_unsuspend(), bridge_channel_internal_push_full(), bridge_impart_internal(), bridge_merge(), bridge_merge_locked(), bridge_move_locked(), and play_uri().

{
   struct ast_bridge_channel *bridge_channel;

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

   return bridge_channel;
}

bridge_handle_actions()

static void bridge_handle_actions ( struct ast_bridge *  bridge )

static

Definition at line 640 of file bridge.c.

References ast_bridge::action_queue, ast_assert, AST_FRAME_BRIDGE_ACTION, ast_frfree, AST_LIST_REMOVE_HEAD, bridge_action_bridge(), and ast_frame::frametype.

Referenced by bridge_manager_service(), and destroy_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);
   }
}

bridge_hook_destroy()

static void bridge_hook_destroy ( void *  vhook )

static

Definition at line 3202 of file bridge.c.

References ast_bridge_hook::destructor, and ast_bridge_hook::hook_pvt.

Referenced by bridge_hook_generic().

{
   struct ast_bridge_hook *hook = vhook;

   if (hook->destructor) {
      hook->destructor(hook->hook_pvt);
   }
}

bridge_hook_generic()

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  )

static

Definition at line 3225 of file bridge.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_set_flag, bridge_hook_destroy(), ast_bridge_hook::callback, ast_bridge_hook::destructor, ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by ast_bridge_dtmf_hook(), ast_bridge_interval_hook(), and bridge_other_hook().

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

bridge_impart_internal()

static int bridge_impart_internal ( struct ast_bridge *  bridge, struct ast_channel *  chan, struct ast_channel *  swap, struct ast_bridge_features *  features, enum ast_bridge_impart_flags  flags, struct bridge_channel_impart_cond *  cond  )

static

Definition at line 1823 of file bridge.c.

References ao2_lock, ao2_ref, ao2_t_bump, ao2_t_cleanup, ao2_unlock, ast_bridge_features_destroy(), ast_bridge_features_new(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_BRIDGE_IMPART_CHAN_INDEPENDENT, AST_BRIDGE_IMPART_CHAN_MASK, AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP, ast_bridge_lock, ast_bridge_unlock, ast_channel_flags(), ast_channel_internal_bridge_channel_set(), ast_channel_lock, ast_channel_name(), ast_channel_pbx(), ast_channel_unlock, AST_FLAG_ZOMBIE, ast_log, AST_LOG_NOTICE, AST_LOG_WARNING, ast_pthread_create, ast_pthread_create_detached, ast_read_threadstorage_callid(), ast_test_flag, bridge_channel_depart_thread(), bridge_channel_impart_add(), bridge_channel_impart_wait(), bridge_channel_ind_thread(), bridge_channel_internal_alloc(), bridge_find_channel(), ast_bridge_channel::callid, ast_bridge_channel::chan, ast_bridge_channel::depart_wait, ast_bridge_channel::features, ast_bridge_channel::inhibit_colp, NULL, ast_bridge_methods::push_peek, ast_bridge_channel::swap, ast_bridge_channel::thread, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by ast_bridge_impart().

{
   int res = 0;
   struct ast_bridge_channel *bridge_channel;

   /* Imparted channels cannot have a PBX. */
   if (ast_channel_pbx(chan)) {
      ast_log(AST_LOG_WARNING, "Channel %s has a PBX thread and cannot be imparted into bridge %s\n",
         ast_channel_name(chan), bridge->uniqueid);
      ast_bridge_features_destroy(features);
      return -1;
   }

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

   ast_channel_lock(chan);
   if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
      ast_log(AST_LOG_NOTICE, "Channel %s is a zombie and cannot be imparted into bridge %s\n",
         ast_channel_name(chan), bridge->uniqueid);
      res = -1;
   } else {
      ast_channel_internal_bridge_channel_set(chan, bridge_channel);
   }
   ast_channel_unlock(chan);
   bridge_channel->chan = chan;
   bridge_channel->swap = ao2_t_bump(swap, "Setting up bridge impart");
   bridge_channel->features = features;
   bridge_channel->inhibit_colp = !!(flags & AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP);
   bridge_channel->depart_wait =
      (flags & AST_BRIDGE_IMPART_CHAN_MASK) == AST_BRIDGE_IMPART_CHAN_DEPARTABLE;
   bridge_channel->callid = ast_read_threadstorage_callid();

   /* allow subclass to peek at swap channel before it can hangup */
   if (bridge->v_table->push_peek && !res) {
      struct ast_bridge_channel *bcswap = NULL;

      ast_bridge_lock(bridge);
      if (bridge_channel->swap) {
         bcswap = bridge_find_channel(bridge, bridge_channel->swap);
      }
      res = bridge->v_table->push_peek(bridge, bridge_channel, bcswap);
      ast_bridge_unlock(bridge);
   }

   /* Actually create the thread that will handle the channel */
   if (!res) {
      res = bridge_channel_impart_add(chan, cond);
   }
   if (!res) {
      if ((flags & AST_BRIDGE_IMPART_CHAN_MASK) == AST_BRIDGE_IMPART_CHAN_INDEPENDENT) {
         res = ast_pthread_create_detached(&bridge_channel->thread, NULL,
            bridge_channel_ind_thread, bridge_channel);
      } else {
         res = ast_pthread_create(&bridge_channel->thread, NULL,
            bridge_channel_depart_thread, bridge_channel);
      }

      if (!res) {
         bridge_channel_impart_wait(cond);
      }
   }

   if (res) {
      /* cleanup */
      ast_channel_lock(chan);
      ast_channel_internal_bridge_channel_set(chan, NULL);
      ast_channel_unlock(chan);
      /* Lock here for ast_bridge_channel_get_chan */
      ao2_lock(bridge_channel);
      bridge_channel->chan = NULL;
      ao2_unlock(bridge_channel);
      ao2_t_cleanup(bridge_channel->swap, "Bridge complete: Impart failed");
      bridge_channel->swap = NULL;
      ast_bridge_features_destroy(bridge_channel->features);
      bridge_channel->features = NULL;

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

   return 0;
}

bridge_manager_create()

static struct bridge_manager_controller* bridge_manager_create ( void  )

static

Definition at line 5009 of file bridge.c.

References ao2_alloc, ao2_ref, ast_cond_init, AST_LIST_HEAD_INIT_NOLOCK, ast_pthread_create, AST_PTHREADT_NULL, bridge_manager_destroy(), bridge_manager_thread(), bridge_manager_controller::cond, NULL, bridge_manager_controller::service_requests, and bridge_manager_controller::thread.

Referenced by ast_bridging_init().

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

bridge_manager_destroy()

static void bridge_manager_destroy ( void *  obj )

static

Definition at line 4977 of file bridge.c.

References ao2_lock, ao2_ref, ao2_unlock, ast_cond_destroy, ast_cond_signal, ast_debug, ast_free, AST_LIST_REMOVE_HEAD, AST_PTHREADT_NULL, bridge_manager_request::bridge, bridge_manager_controller::cond, NULL, request(), bridge_manager_controller::service_requests, bridge_manager_controller::stop, and bridge_manager_controller::thread.

Referenced by bridge_manager_create().

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

bridge_manager_service()

static void bridge_manager_service ( struct ast_bridge *  bridge )

static

Definition at line 4923 of file bridge.c.

References ast_bridge_lock, ast_bridge_unlock, ast_callid_threadassoc_change(), bridge_handle_actions(), and ast_bridge::callid.

Referenced by bridge_manager_thread().

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

bridge_manager_service_req()

static void bridge_manager_service_req ( struct ast_bridge *  bridge )

static

Definition at line 188 of file bridge.c.

References ao2_lock, ao2_ref, ao2_unlock, ast_calloc, ast_cond_signal, AST_LIST_INSERT_TAIL, bridge_manager_request::bridge, bridge_manager_controller::cond, request(), bridge_manager_controller::service_requests, and bridge_manager_controller::stop.

Referenced by bridge_queue_action_nodup().

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

bridge_manager_thread()

static void* bridge_manager_thread ( void *  data )

static

Definition at line 4942 of file bridge.c.

References ao2_lock, ao2_object_get_lockaddr(), ao2_ref, ao2_unlock, ast_cond_wait, ast_free, AST_LIST_REMOVE_HEAD, bridge_manager_request::bridge, bridge_manager_service(), bridge_manager_controller::cond, NULL, request(), bridge_manager_controller::service_requests, and bridge_manager_controller::stop.

Referenced by bridge_manager_create().

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

bridge_merge_determine_direction()

static struct merge_direction bridge_merge_determine_direction ( struct ast_bridge *  bridge1, struct ast_bridge *  bridge2  )

static

Definition at line 2201 of file bridge.c.

References AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, ast_test_flag, merge_direction::dest, NULL, and merge_direction::src.

Referenced by bridge_merge_locked(), and bridges_allow_merge_optimization().

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

bridge_merge_inhibit_nolock()

void bridge_merge_inhibit_nolock	(	struct ast_bridge *	bridge,
		int	request
	)

Definition at line 3052 of file bridge.c.

References ast_assert, ast_bridge::inhibit_merge, and request().

Referenced by ast_bridge_channel_merge_inhibit(), and ast_bridge_merge_inhibit().

{
   int new_request;

   new_request = bridge->inhibit_merge + request;
   ast_assert(0 <= new_request);
   bridge->inhibit_merge = new_request;
}

bridge_merge_locked()

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  )

static

Definition at line 2264 of file bridge.c.

References ast_bridge::allowed_capabilities, ast_alloca, ast_assert, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_FLAG_MASQUERADE_ONLY, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SMART, ast_debug, ast_test_flag, bridge_do_merge(), bridge_find_channel(), bridge_merge_determine_direction(), ast_bridge_technology::capabilities, merge_direction::dest, ast_bridge::dissolved, ast_bridge::feature_flags, ast_bridge::inhibit_merge, NULL, ast_bridge::num_channels, merge_direction::src, ast_bridge::technology, and ast_bridge::uniqueid.

Referenced by ast_bridge_merge().

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

bridge_move_locked()

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  )

static

Definition at line 2447 of file bridge.c.

References AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE, AST_BRIDGE_FLAG_MASQUERADE_ONLY, ast_channel_name(), ast_debug, ast_test_flag, BRIDGE_CHANNEL_STATE_WAIT, bridge_do_move(), bridge_find_channel(), ast_bridge::dissolved, ast_bridge_features::feature_flags, ast_bridge::feature_flags, ast_bridge_channel::features, ast_bridge::inhibit_merge, ast_bridge_channel::state, ast_bridge_channel::swap, and ast_bridge::uniqueid.

Referenced by ast_bridge_add_channel(), and ast_bridge_move().

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

bridge_other_hook()

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  )

static

Definition at line 3294 of file bridge.c.

References ao2_link, ao2_ref, bridge_hook_generic(), ast_bridge_hook::destructor, NULL, ast_bridge_features::other_hooks, type, and ast_bridge_hook::type.

Referenced by ast_bridge_hangup_hook(), ast_bridge_join_hook(), ast_bridge_leave_hook(), ast_bridge_move_hook(), and ast_bridge_talk_detector_hook().

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

bridge_prnt_obj()

static void bridge_prnt_obj ( void *  v_obj, void *  where, ao2_prnt_fn *  prnt  )

static

Definition at line 5573 of file bridge.c.

References bridge_manager_request::bridge, ast_bridge_methods::name, ast_bridge::num_channels, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by ast_bridging_init().

{
   struct ast_bridge *bridge = v_obj;

   if (!bridge) {
      return;
   }
   prnt(where, "%s %s chans:%u",
      bridge->uniqueid, bridge->v_table->name, bridge->num_channels);
}

bridge_queue_action_nodup()

static void bridge_queue_action_nodup ( struct ast_bridge *  bridge, struct ast_frame *  action  )

static

Definition at line 296 of file bridge.c.

References ast_bridge::action_queue, ast_bridge_lock, ast_bridge_unlock, ast_debug, AST_LIST_INSERT_TAIL, bridge_manager_service_req(), ast_frame::frametype, ast_frame_subclass::integer, ast_frame::subclass, and ast_bridge::uniqueid.

Referenced by ast_bridge_queue_action(), and smart_bridge_operation().

{
   ast_debug(1, "Bridge %s: queueing action type:%u 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);
}

bridge_reconfigured()

void bridge_reconfigured	(	struct ast_bridge *	bridge,
		unsigned int	colp_update
	)

Definition at line 1443 of file bridge.c.

References AST_BRIDGE_FLAG_SMART, ast_bridge_publish_state(), ast_test_flag, bridge_complete_join(), bridge_dissolve(), bridge_reconfigured_connected_line_update(), check_bridge_play_sounds(), ast_bridge::dissolved, ast_bridge::feature_flags, ast_bridge::reconfigured, set_bridge_peer_vars(), and smart_bridge_operation().

Referenced by ast_bridge_notify_masquerade(), bridge_channel_handle_control(), bridge_channel_internal_join(), bridge_channel_wait(), bridge_do_merge(), and bridge_do_move().

{
   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, 0);
      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);
   }
}

bridge_reconfigured_connected_line_update()

static void bridge_reconfigured_connected_line_update ( struct ast_bridge *  bridge )

static

Definition at line 393 of file bridge.c.

References AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_NATIVE, ast_bridge_channel_peer(), ast_bridge_channel_queue_control_data(), ast_channel_caller(), ast_channel_flags(), ast_channel_lock, ast_channel_unlock, ast_check_hangup_locked(), ast_connected_line_build_data(), ast_connected_line_copy_from_caller(), AST_CONTROL_CONNECTED_LINE, AST_FLAG_ZOMBIE, AST_LIST_FIRST, ast_party_connected_line_free(), ast_party_connected_line_init(), ast_test_flag, ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, NULL, and ast_bridge::technology.

Referenced by bridge_reconfigured().

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

bridge_register()

struct ast_bridge* bridge_register

(

struct ast_bridge *

bridge

)

Register the new bridge with the system.

Since

12.0.0

Parameters

bridge

What to register. (Tolerates a NULL pointer)

struct ast_bridge *ast_bridge_basic_new(uint32_t capabilities, int flags, uint32 dtmf_features)
{
    void *bridge;

    bridge = bridge_alloc(sizeof(struct ast_bridge_basic), &ast_bridge_basic_v_table);
    bridge = bridge_base_init(bridge, capabilities, flags);
    bridge = ast_bridge_basic_init(bridge, dtmf_features);
    bridge = bridge_register(bridge);
    return bridge;
}

Note

This must be done after a bridge constructor has completed setting up the new bridge but before it returns.

After a bridge is registered, ast_bridge_destroy() must eventually be called to get rid of the bridge.

Return values

bridge	on success.
NULL	on error.

Definition at line 709 of file bridge.c.

References ao2_link, ast_bridge_destroy(), ast_bridge_lock, ast_bridge_publish_state(), ast_bridge_unlock, bridge_manager_request::bridge, ast_bridge::construction_completed, and NULL.

Referenced by ast_bridge_base_new(), ast_bridge_basic_new(), bridge_agent_hold_new(), bridge_parking_new(), and bridge_stasis_new().

{
   if (bridge) {
      bridge->construction_completed = 1;
      ast_bridge_lock(bridge);
      ast_bridge_publish_state(bridge);
      ast_bridge_unlock(bridge);
      if (!ao2_link(bridges, bridge)) {
         ast_bridge_destroy(bridge, 0);
         bridge = NULL;
      }
   }
   return bridge;
}

bridge_show_specific_print_channel()

static int bridge_show_specific_print_channel ( void *  obj, void *  arg, int  flags  )

static

Internal callback function for sending channels in a bridge to the CLI.

Definition at line 5140 of file bridge.c.

References a, ao2_ref, ast_channel_snapshot_get_latest(), ast_cli(), ast_channel_snapshot::base, ast_cli_args::fd, ast_channel_snapshot_base::name, and ast_bridge_snapshot::uniqueid.

Referenced by handle_bridge_show_specific().

{
   const char *uniqueid = obj;
   struct ast_cli_args *a = arg;
   struct ast_channel_snapshot *snapshot;

   snapshot = ast_channel_snapshot_get_latest(uniqueid);
   if (!snapshot) {
      return 0;
   }

   ast_cli(a->fd, "Channel: %s\n", snapshot->base->name);
   ao2_ref(snapshot, -1);

   return 0;
}

bridge_sort_cmp()

static int bridge_sort_cmp ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 5048 of file bridge.c.

References OBJ_KEY, OBJ_PARTIAL_KEY, OBJ_POINTER, and ast_bridge::uniqueid.

Referenced by ast_bridging_init().

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

bridge_swap_attended_transfer()

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  )

static

Definition at line 4620 of file bridge.c.

References AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE, ast_bridge_channel_leave_bridge(), ast_bridge_channel_peer(), AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_INVALID, AST_BRIDGE_TRANSFER_SUCCESS, AST_CAUSE_NORMAL_CLEARING, ast_test_flag, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_CHANNEL_STATE_WAIT, bridge_do_move(), ast_bridge_features::feature_flags, ast_bridge_channel::features, ast_bridge_channel::state, and ast_bridge_channel::swap.

Referenced by two_bridge_attended_transfer().

{
   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, AST_CAUSE_NORMAL_CLEARING);
      return AST_BRIDGE_TRANSFER_SUCCESS;
   } else {
      return AST_BRIDGE_TRANSFER_INVALID;
   }
}

bridge_tech_deferred_destroy()

static void bridge_tech_deferred_destroy ( struct ast_bridge *  bridge, struct ast_frame *  action  )

static

Definition at line 574 of file bridge.c.

References ast_debug, ast_module_unref, ast_bridge::creator, ast_frame::data, ast_bridge_technology::destroy, ast_bridge_technology::mod, ast_bridge_technology::name, ast_bridge::name, ast_frame::ptr, tech_deferred_destroy::tech, tech_deferred_destroy::tech_pvt, ast_bridge::technology, and ast_bridge::uniqueid.

Referenced by bridge_action_bridge().

{
   struct tech_deferred_destroy *deferred = action->data.ptr;
   struct ast_bridge dummy_bridge = {
      .technology = deferred->tech,
      .tech_pvt = deferred->tech_pvt,
      .creator = bridge->creator,
      .name = bridge->name,
      .uniqueid = 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);
}

bridges_allow_merge_optimization()

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  )

static

Definition at line 2883 of file bridge.c.

References ast_bridge::allowed_capabilities, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_FLAG_SMART, ast_test_flag, bridge_merge_determine_direction(), ast_bridge_technology::capabilities, merge_direction::dest, ast_bridge::feature_flags, MERGE_ALLOWED, MERGE_NO_MULTIMIX, MERGE_NOT_ENOUGH_CHANNELS, MERGE_PROHIBITED, ast_bridge::num_channels, merge_direction::src, and ast_bridge::technology.

Referenced by ast_bridges_allow_optimization(), and try_merge_optimize_out().

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

bridges_allow_swap_optimization()

static enum bridge_allow_swap bridges_allow_swap_optimization ( struct ast_bridge *  chan_bridge, struct ast_bridge *  peer_bridge  )

static

Definition at line 2737 of file bridge.c.

References AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO, AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY, ast_test_flag, ast_bridge::feature_flags, ast_bridge_methods::get_merge_priority, ast_bridge::num_channels, SWAP_PROHIBITED, SWAP_TO_CHAN_BRIDGE, SWAP_TO_PEER_BRIDGE, and ast_bridge::v_table.

Referenced by ast_bridges_allow_optimization(), and try_swap_optimize_out().

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

channel_cmp()

static int channel_cmp ( void *  obj, void *  arg, int  flags  )

static

Definition at line 4063 of file bridge.c.

References ast_channel_name(), CMP_MATCH, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by ast_bridge_peers_nolock().

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

channel_hash()

static int channel_hash ( const void *  obj, int  flags  )

static

Definition at line 4040 of file bridge.c.

References ast_assert, ast_channel_name(), ast_str_hash(), name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by ast_bridge_peers_nolock().

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

check_bridge_play_sound()

static void check_bridge_play_sound ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 1203 of file bridge.c.

References ast_bridge_channel_queue_playfile(), ast_channel_lock, ast_channel_unlock, ast_strdupa, ast_strlen_zero, ast_bridge_channel::chan, NULL, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), and play_file().

Referenced by check_bridge_play_sounds().

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

check_bridge_play_sounds()

static void check_bridge_play_sounds ( struct ast_bridge *  bridge )

static

Definition at line 1233 of file bridge.c.

References AST_LIST_TRAVERSE, ast_bridge::channels, and check_bridge_play_sound().

Referenced by bridge_reconfigured().

{
   struct ast_bridge_channel *bridge_channel;

   AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
      check_bridge_play_sound(bridge_channel);
   }
}

cleanup_video_mode()

static void cleanup_video_mode ( struct ast_bridge *  bridge )

static

Definition at line 3793 of file bridge.c.

References AST_BRIDGE_VIDEO_MODE_NONE, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, ast_channel_unref, ast_bridge_video_talker_src_data::chan_old_vsrc, ast_bridge_video_single_src_data::chan_vsrc, ast_bridge_video_talker_src_data::chan_vsrc, ast_bridge_video_mode::mode, ast_bridge_video_mode::mode_data, ast_bridge_video_mode::single_src_data, ast_bridge::softmix, ast_bridge_video_mode::talker_src_data, and ast_bridge_softmix::video_mode.

Referenced by ast_bridge_set_sfu_video_mode(), ast_bridge_set_single_src_video_mode(), ast_bridge_set_talker_src_video_mode(), and destroy_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);
      }
   case AST_BRIDGE_VIDEO_MODE_SFU:
      break;
   }
   memset(&bridge->softmix.video_mode, 0, sizeof(bridge->softmix.video_mode));
}

complete_bridge_live()

static char* complete_bridge_live ( const char *  word )

static

Definition at line 5086 of file bridge.c.

References ao2_callback, ast_strlen_zero, complete_bridge_live_search(), NULL, and OBJ_PARTIAL_KEY.

Referenced by handle_bridge_destroy_specific(), handle_bridge_kick_channel(), and handle_bridge_show_specific().

{
   ao2_callback(bridges, ast_strlen_zero(word) ? 0 : OBJ_PARTIAL_KEY,
      complete_bridge_live_search, (char *) word);

   return NULL;
}

complete_bridge_live_search()

static int complete_bridge_live_search ( void *  obj, void *  arg, int  flags  )

static

Definition at line 5075 of file bridge.c.

References ast_cli_completion_add(), ast_strdup, bridge_manager_request::bridge, CMP_STOP, and ast_bridge::uniqueid.

Referenced by complete_bridge_live().

{
   struct ast_bridge *bridge = obj;

   if (ast_cli_completion_add(ast_strdup(bridge->uniqueid))) {
      return CMP_STOP;
   }

   return 0;
}

complete_bridge_participant()

static char* complete_bridge_participant ( const char *  bridge_name, const char *  word  )

static

Definition at line 5241 of file bridge.c.

References ao2_ref, ast_bridge_find_by_id(), ast_bridge_lock, ast_bridge_unlock, ast_channel_name(), ast_cli_completion_add(), AST_LIST_TRAVERSE, ast_strdup, bridge_manager_request::bridge, ast_bridge_channel::chan, ast_bridge::channels, and NULL.

Referenced by handle_bridge_kick_channel().

{
   struct ast_bridge *bridge;
   struct ast_bridge_channel *bridge_channel;
   int wordlen;

   bridge = ast_bridge_find_by_id(bridge_name);
   if (!bridge) {
      return NULL;
   }

   wordlen = strlen(word);

   ast_bridge_lock(bridge);
   AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
      if (!strncasecmp(ast_channel_name(bridge_channel->chan), word, wordlen)) {
         if (ast_cli_completion_add(ast_strdup(ast_channel_name(bridge_channel->chan)))) {
            break;
         }
      }
   }
   ast_bridge_unlock(bridge);

   ao2_ref(bridge, -1);

   return NULL;
}

complete_bridge_technology()

static char* complete_bridge_technology ( const char *  word )

static

Definition at line 5390 of file bridge.c.

References ast_cli_completion_add(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_bridge_technology::name, and NULL.

Referenced by handle_bridge_technology_suspend().

{
   struct ast_bridge_technology *cur;
   int wordlen;

   wordlen = strlen(word);
   AST_RWLIST_RDLOCK(&bridge_technologies);
   AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
      if (!strncasecmp(cur->name, word, wordlen)) {
         if (ast_cli_completion_add(ast_strdup(cur->name))) {
            break;
         }
      }
   }
   AST_RWLIST_UNLOCK(&bridge_technologies);

   return NULL;
}

destroy_bridge()

static void destroy_bridge ( void *  obj )

static

Definition at line 658 of file bridge.c.

References ao2_cleanup, ast_assert, ast_bridge_lock, ast_bridge_unlock, ast_debug, AST_LIST_EMPTY, ast_module_unref, ast_string_field_free_memory, AST_VECTOR_FREE, bridge_manager_request::bridge, bridge_handle_actions(), bridge_topics_destroy(), ast_bridge::callid, ast_bridge::channels, cleanup_video_mode(), ast_bridge::construction_completed, ast_bridge::current_snapshot, ast_bridge_technology::destroy, ast_bridge_methods::destroy, ast_bridge::media_types, ast_bridge_technology::mod, ast_bridge_technology::name, ast_bridge_methods::name, NULL, ast_bridge_technology::stop, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by bridge_alloc().

{
   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) {
      bridge_topics_destroy(bridge);
   }

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

   AST_VECTOR_FREE(&bridge->media_types);

   bridge->callid = 0;

   cleanup_video_mode(bridge);

   ast_string_field_free_memory(bridge);
   ao2_cleanup(bridge->current_snapshot);
}

fill_bridgepeer_buf()

static void fill_bridgepeer_buf ( char *  buf, unsigned int  cur_idx, const char *  names[], unsigned int  num_names  )

static

Definition at line 1303 of file bridge.c.

References buf.

Referenced by set_bridge_peer_vars_multiparty().

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

find_best_technology()

static struct ast_bridge_technology* find_best_technology ( uint32_t  capabilities, struct ast_bridge *  bridge  )

static

Helper function used to find the "best" bridge technology given specified capabilities.

Definition at line 511 of file bridge.c.

References ast_debug, ast_module_running_ref, ast_module_unref, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_bridge_technology::capabilities, ast_bridge_technology::compatible, ast_bridge_technology::mod, ast_bridge_technology::name, NULL, ast_bridge_technology::preference, and ast_bridge_technology::suspended.

Referenced by bridge_base_init(), and smart_bridge_operation().

{
   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 (%u <= %u). 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;
      }
      if (!ast_module_running_ref(current->mod)) {
         ast_debug(1, "Bridge technology %s is not running, skipping.\n", current->name);
         continue;
      }
      if (best) {
         ast_module_unref(best->mod);
      }
      best = current;
   }

   if (best) {
      ast_debug(1, "Chose bridge technology %s\n", best->name);
   }

   AST_RWLIST_UNLOCK(&bridge_technologies);

   return best;
}

get_transferee()

static struct ast_channel* get_transferee ( struct ao2_container *  channels, struct ast_channel *  transferer  )

static

Definition at line 4241 of file bridge.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), and ao2_iterator_next.

Referenced by ast_bridge_transfer_attended().

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

handle_bridge_destroy_specific()

static char* handle_bridge_destroy_specific ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5206 of file bridge.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_bridge_destroy(), ast_bridge_find_by_id(), ast_cli(), bridge_manager_request::bridge, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_bridge_live(), ast_cli_args::fd, NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   struct ast_bridge *bridge;

   switch (cmd) {
   case CLI_INIT:
      e->command = "bridge destroy";
      e->usage =
         "Usage: bridge destroy <bridge-id>\n"
         "       Destroy the <bridge-id> bridge\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos == 2) {
         return complete_bridge_live(a->word);
      }
      return NULL;
   }

   if (a->argc != 3) {
      return CLI_SHOWUSAGE;
   }

   bridge = ast_bridge_find_by_id(a->argv[2]);
   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, 0);

   return CLI_SUCCESS;
}

handle_bridge_kick_channel()

static char* handle_bridge_kick_channel ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5269 of file bridge.c.

References ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_bridge_channel_queue_callback(), ast_bridge_find_by_id(), ast_bridge_kick(), ast_bridge_lock, ast_bridge_unlock, ast_channel_get_by_name_prefix(), ast_channel_name(), ast_channel_unref, ast_cli(), ast_cli_complete(), AST_LIST_TRAVERSE, bridge_manager_request::bridge, ast_bridge::channels, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_bridge_live(), complete_bridge_participant(), ast_cli_args::fd, kick_it(), NULL, ast_cli_args::pos, ast_cli_entry::usage, and ast_cli_args::word.

{
   static const char * const completions[] = { "all", NULL };
   struct ast_bridge *bridge;

   switch (cmd) {
   case CLI_INIT:
      e->command = "bridge kick";
      e->usage =
         "Usage: bridge kick <bridge-id> <channel-name | all>\n"
         "       Kick the <channel-name> channel out of the <bridge-id> bridge\n"
         "       If all is specified as the channel name then all channels will be\n"
         "       kicked out of the bridge.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos == 2) {
         return complete_bridge_live(a->word);
      }
      if (a->pos == 3) {
         ast_cli_complete(a->word, completions, -1);
         return complete_bridge_participant(a->argv[2], a->word);
      }
      return NULL;
   }

   if (a->argc != 4) {
      return CLI_SHOWUSAGE;
   }

   bridge = ast_bridge_find_by_id(a->argv[2]);
   if (!bridge) {
      ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]);
      return CLI_SUCCESS;
   }

   if (!strcasecmp(a->argv[3], "all")) {
      struct ast_bridge_channel *bridge_channel;

      ast_cli(a->fd, "Kicking all channels from bridge '%s'\n", a->argv[2]);

      ast_bridge_lock(bridge);
      AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
         ast_bridge_channel_queue_callback(bridge_channel, 0, kick_it, NULL, 0);
      }
      ast_bridge_unlock(bridge);
   } else {
      struct ast_channel *chan;

      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]);
         ao2_ref(bridge, -1);
         return CLI_SUCCESS;
      }

      ast_cli(a->fd, "Kicking channel '%s' from bridge '%s'\n",
         ast_channel_name(chan), a->argv[2]);
      ast_bridge_kick(bridge, chan);
      ast_channel_unref(chan);
   }

   ao2_ref(bridge, -1);
   return CLI_SUCCESS;
}

handle_bridge_show_all()

static char* handle_bridge_show_all ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5094 of file bridge.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_bridge_get_snapshot(), ast_cli(), ast_format_duration_hh_mm_ss(), ast_tvnow(), bridge_manager_request::bridge, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_bridge_snapshot::creationtime, ast_cli_args::fd, FORMAT_HDR, FORMAT_ROW, NULL, ast_bridge_snapshot::num_channels, S_OR, ast_bridge_snapshot::subclass, ast_bridge_snapshot::technology, ast_bridge_snapshot::uniqueid, and ast_cli_entry::usage.

{
#define FORMAT_HDR "%-36s %5s %-15s %-15s %s\n"
#define FORMAT_ROW "%-36s %5u %-15s %-15s %s\n"

   struct ao2_iterator iter;
   struct ast_bridge *bridge;

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

   ast_cli(a->fd, FORMAT_HDR, "Bridge-ID", "Chans", "Type", "Technology", "Duration");

   iter = ao2_iterator_init(bridges, 0);
   for (; (bridge = ao2_iterator_next(&iter)); ao2_ref(bridge, -1)) {
      struct ast_bridge_snapshot *snapshot = ast_bridge_get_snapshot(bridge);
      char print_time[32];

      if (snapshot) {
         ast_format_duration_hh_mm_ss(ast_tvnow().tv_sec - snapshot->creationtime.tv_sec, print_time, sizeof(print_time));
         ast_cli(a->fd, FORMAT_ROW,
            snapshot->uniqueid,
            snapshot->num_channels,
            S_OR(snapshot->subclass, "<unknown>"),
            S_OR(snapshot->technology, "<unknown>"),
            print_time);
         ao2_ref(snapshot, -1);
      }
   }
   ao2_iterator_destroy(&iter);

   return CLI_SUCCESS;

#undef FORMAT_HDR
#undef FORMAT_ROW
}

handle_bridge_show_specific()

static char* handle_bridge_show_specific ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5157 of file bridge.c.

References ao2_callback, ao2_ref, ast_cli_args::argc, ast_cli_args::argv, ast_bridge_get_snapshot_by_uniqueid(), ast_bridge_video_mode_to_string(), ast_cli(), ast_format_duration_hh_mm_ss(), ast_tvnow(), bridge_show_specific_print_channel(), ast_bridge_snapshot::channels, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_bridge_live(), ast_bridge_snapshot::creationtime, ast_bridge_snapshot::creator, ast_cli_args::fd, ast_bridge_snapshot::name, NULL, ast_bridge_snapshot::num_active, ast_bridge_snapshot::num_channels, OBJ_NODATA, ast_cli_args::pos, S_OR, ast_bridge_snapshot::subclass, ast_bridge_snapshot::technology, ast_bridge_snapshot::uniqueid, ast_cli_entry::usage, ast_bridge_snapshot::video_mode, ast_bridge_snapshot::video_source_id, and ast_cli_args::word.

{
   struct ast_bridge_snapshot *snapshot;
   char print_time[32];

   switch (cmd) {
   case CLI_INIT:
      e->command = "bridge show";
      e->usage =
         "Usage: bridge show <bridge-id>\n"
         "       Show information about the <bridge-id> bridge\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos == 2) {
         return complete_bridge_live(a->word);
      }
      return NULL;
   }

   if (a->argc != 3) {
      return CLI_SHOWUSAGE;
   }

   snapshot = ast_bridge_get_snapshot_by_uniqueid(a->argv[2]);
   if (!snapshot) {
      ast_cli(a->fd, "Bridge '%s' not found\n", a->argv[2]);
      return CLI_SUCCESS;
   }

   ast_format_duration_hh_mm_ss(ast_tvnow().tv_sec - snapshot->creationtime.tv_sec, print_time, sizeof(print_time));

   ast_cli(a->fd, "Id: %s\n", snapshot->uniqueid);
   ast_cli(a->fd, "Type: %s\n", S_OR(snapshot->subclass, "<unknown>"));
   ast_cli(a->fd, "Technology: %s\n", S_OR(snapshot->technology, "<unknown>"));
   ast_cli(a->fd, "Subclass: %s\n", snapshot->subclass);
   ast_cli(a->fd, "Creator: %s\n", snapshot->creator);
   ast_cli(a->fd, "Name: %s\n", snapshot->name);
   ast_cli(a->fd, "Video-Mode: %s\n", ast_bridge_video_mode_to_string(snapshot->video_mode));
   ast_cli(a->fd, "Video-Source-Id: %s\n", snapshot->video_source_id);
   ast_cli(a->fd, "Num-Channels: %u\n", snapshot->num_channels);
   ast_cli(a->fd, "Num-Active: %u\n", snapshot->num_active);
   ast_cli(a->fd, "Duration: %s\n", print_time);
   ao2_callback(snapshot->channels, OBJ_NODATA, bridge_show_specific_print_channel, a);
   ao2_ref(snapshot, -1);

   return CLI_SUCCESS;
}

handle_bridge_technology_show()

static char* handle_bridge_technology_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5355 of file bridge.c.

References ast_cli(), AST_CLI_YESNO, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_bridge_technology::capabilities, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, FORMAT_HDR, FORMAT_ROW, ast_bridge_technology::name, NULL, ast_bridge_technology::preference, ast_bridge_technology::suspended, tech_capability2str(), type, and ast_cli_entry::usage.

{
#define FORMAT_HDR "%-20s %-20s %8s %s\n"
#define FORMAT_ROW "%-20s %-20s %8u %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
}

handle_bridge_technology_suspend()

static char* handle_bridge_technology_suspend ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 5409 of file bridge.c.

References ast_cli_args::argc, ast_cli_args::argv, ast_bridge_technology_suspend(), ast_bridge_technology_unsuspend(), ast_cli(), AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_bridge_technology(), ast_cli_args::fd, ast_bridge_technology::name, NULL, ast_cli_args::pos, suspend(), ast_cli_entry::usage, and ast_cli_args::word.

{
   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} <technology-name>\n"
         "       Suspend or unsuspend a bridge technology.\n";
      return NULL;
   case CLI_GENERATE:
      if (a->pos == 3) {
         return complete_bridge_technology(a->word);
      }
      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;
}

handle_manager_bridge_tech_suspend()

static int handle_manager_bridge_tech_suspend ( struct mansession *  s, const struct message *  m, int  suspend  )

static

Definition at line 5474 of file bridge.c.

References ast_bridge_technology_suspend(), ast_bridge_technology_unsuspend(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero, astman_get_header(), astman_send_ack(), astman_send_error(), ast_bridge_technology::name, and name.

Referenced by manager_bridge_tech_suspend(), and manager_bridge_tech_unsuspend().

{
   const char *name = astman_get_header(m, "BridgeTechnology");
   struct ast_bridge_technology *cur;
   int successful = 0;

   if (ast_strlen_zero(name)) {
      astman_send_error(s, m, "BridgeTechnology must be provided");
      return 0;
   }

   AST_RWLIST_RDLOCK(&bridge_technologies);
   AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {

      if (!strcasecmp(cur->name, name)) {
         successful = 1;
         if (suspend) {
            ast_bridge_technology_suspend(cur);
         } else {
            ast_bridge_technology_unsuspend(cur);
         }
         break;
      }
   }
   AST_RWLIST_UNLOCK(&bridge_technologies);
   if (!successful) {
      astman_send_error(s, m, "BridgeTechnology not found");
      return 0;
   }

   astman_send_ack(s, m, (suspend ? "Suspended bridge technology" : "Unsuspended bridge technology"));
   return 0;
}

hook_remove_match()

static int hook_remove_match ( void *  obj, void *  arg, int  flags  )

static

Definition at line 3508 of file bridge.c.

References ast_test_flag, CMP_MATCH, and ast_bridge_hook::remove_flags.

Referenced by hooks_remove_container().

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

hooks_remove_container()

static void hooks_remove_container ( struct ao2_container *  hooks, enum ast_bridge_hook_remove_flags  remove_flags  )

static

Definition at line 3530 of file bridge.c.

References ao2_callback, hook_remove_match(), OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

Referenced by ast_bridge_features_remove().

{
   ao2_callback(hooks, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE,
      hook_remove_match, &remove_flags);
}

hooks_remove_heap()

static void hooks_remove_heap ( struct ast_heap *  hooks, enum ast_bridge_hook_remove_flags  remove_flags  )

static

Definition at line 3546 of file bridge.c.

References ao2_ref, ast_heap_peek(), ast_heap_remove(), ast_heap_size(), ast_heap_unlock, ast_heap_wrlock, ast_test_flag, and ast_bridge_hook::remove_flags.

Referenced by ast_bridge_features_remove().

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

interval_hook_time_cmp()

static int interval_hook_time_cmp ( void *  a, void *  b  )

static

Definition at line 3575 of file bridge.c.

References a, ast_tvcmp(), b, ast_bridge_hook_timer_parms::seqno, ast_bridge_hook_timer::timer, and ast_bridge_hook_timer_parms::trip_time.

Referenced by ast_bridge_features_init().

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

interval_wrapper_cb()

static int interval_wrapper_cb ( struct ast_bridge_channel *  bridge_channel, void *  obj  )

static

Wrapper for interval hooks that calls into the wrapped hook.

Definition at line 3636 of file bridge.c.

References ast_bridge_hook::callback, ast_bridge_hook_timer::generic, and ast_bridge_hook::hook_pvt.

Referenced by wrap_hook().

{
   struct ast_bridge_hook_timer *hook = obj;

   return hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
}

interval_wrapper_pvt_dtor()

static void interval_wrapper_pvt_dtor ( void *  obj )

static

Destructor for the hook wrapper.

Definition at line 3644 of file bridge.c.

References ao2_cleanup.

Referenced by wrap_hook().

{
   ao2_cleanup(obj);
}

kick_it()

static void kick_it ( struct ast_bridge_channel *  bridge_channel, const void *  payload, size_t  payload_size  )

static

Definition at line 2020 of file bridge.c.

References ast_bridge_channel_kick(), and AST_CAUSE_NORMAL_CLEARING.

Referenced by ast_bridge_kick(), and handle_bridge_kick_channel().

{
   ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
}

manager_bridge_tech_list()

static int manager_bridge_tech_list ( struct mansession *  s, const struct message *  m  )

static

Definition at line 5518 of file bridge.c.

References ast_free, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_str_buffer(), ast_str_create, ast_str_set(), ast_strlen_zero, AST_YESNO, astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), ast_bridge_technology::capabilities, ast_bridge_technology::name, ast_bridge_technology::preference, RAII_VAR, ast_bridge_technology::suspended, tech_capability2str(), and type.

Referenced by ast_bridging_init().

{
   const char *id = astman_get_header(m, "ActionID");
   RAII_VAR(struct ast_str *, id_text, ast_str_create(128), ast_free);
   struct ast_bridge_technology *cur;
   int num_items = 0;

   if (!id_text) {
      astman_send_error(s, m, "Internal error");
      return -1;
   }

   if (!ast_strlen_zero(id)) {
      ast_str_set(&id_text, 0, "ActionID: %s\r\n", id);
   }

   astman_send_listack(s, m, "Bridge technology listing will follow", "start");

   AST_RWLIST_RDLOCK(&bridge_technologies);
   AST_RWLIST_TRAVERSE(&bridge_technologies, cur, entry) {
      const char *type;

      type = tech_capability2str(cur->capabilities);

      astman_append(s,
         "Event: BridgeTechnologyListItem\r\n"
         "BridgeTechnology: %s\r\n"
         "BridgeType: %s\r\n"
         "BridgePriority: %u\r\n"
         "BridgeSuspended: %s\r\n"
         "%s"
         "\r\n",
         cur->name, type, cur->preference, AST_YESNO(cur->suspended),
         ast_str_buffer(id_text));
      ++num_items;
   }
   AST_RWLIST_UNLOCK(&bridge_technologies);

   astman_send_list_complete_start(s, m, "BridgeTechnologyListComplete", num_items);
   astman_send_list_complete_end(s);

   return 0;
}

manager_bridge_tech_suspend()

static int manager_bridge_tech_suspend ( struct mansession *  s, const struct message *  m  )

static

Definition at line 5508 of file bridge.c.

References handle_manager_bridge_tech_suspend().

Referenced by ast_bridging_init().

{
   return handle_manager_bridge_tech_suspend(s, m, 1);
}

manager_bridge_tech_unsuspend()

static int manager_bridge_tech_unsuspend ( struct mansession *  s, const struct message *  m  )

static

Definition at line 5513 of file bridge.c.

References handle_manager_bridge_tech_suspend().

Referenced by ast_bridging_init().

{
   return handle_manager_bridge_tech_suspend(s, m, 0);
}

merge_container_cb()

static int merge_container_cb ( void *  obj, void *  data, int  flags  )

static

Callback for merging hook ao2_containers.

Definition at line 3629 of file bridge.c.

References ao2_link.

Referenced by ast_bridge_features_merge().

{
   ao2_link(data, obj);
   return 0;
}

optimize_lock_chan_stack()

static struct ast_bridge* optimize_lock_chan_stack ( struct ast_channel *  chan )

static

Definition at line 2627 of file bridge.c.

References ast_bridge_channel::activity, ast_bridge_channel_trylock, ast_bridge_channel_unlock, ast_bridge_trylock, ast_bridge_unlock, ast_channel_flags(), ast_channel_has_audio_frame_or_monitor(), ast_channel_internal_bridge_channel(), ast_channel_readq(), AST_FLAG_EMULATE_DTMF, AST_LIST_EMPTY, ast_test_flag, ast_bridge_channel::bridge, bridge_manager_request::bridge, bridge_allows_optimization(), bridge_channel_internal_allows_optimization(), BRIDGE_CHANNEL_STATE_WAIT, BRIDGE_CHANNEL_THREAD_SIMPLE, NULL, and ast_bridge_channel::state.

Referenced by ast_bridge_unreal_optimize_out().

{
   struct ast_bridge *bridge;
   struct ast_bridge_channel *bridge_channel;

   if (!AST_LIST_EMPTY(ast_channel_readq(chan))) {
      return NULL;
   }
   if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_EMULATE_DTMF)) {
      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;
}

optimize_lock_peer_stack()

static struct ast_bridge* optimize_lock_peer_stack ( struct ast_channel *  peer )

static

Definition at line 2672 of file bridge.c.

References ast_bridge_channel::activity, ast_bridge_channel_trylock, ast_bridge_channel_unlock, ast_bridge_trylock, ast_bridge_unlock, ast_channel_flags(), ast_channel_has_audio_frame_or_monitor(), ast_channel_internal_bridge_channel(), ast_channel_readq(), ast_channel_trylock, ast_channel_unlock, AST_FLAG_EMULATE_DTMF, AST_LIST_EMPTY, ast_test_flag, ast_bridge_channel::bridge, bridge_manager_request::bridge, bridge_allows_optimization(), bridge_channel_internal_allows_optimization(), BRIDGE_CHANNEL_STATE_WAIT, BRIDGE_CHANNEL_THREAD_IDLE, NULL, and ast_bridge_channel::state.

Referenced by ast_bridge_unreal_optimize_out().

{
   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_test_flag(ast_channel_flags(peer), AST_FLAG_EMULATE_DTMF)) {
      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;
}

set_bridge_peer_vars()

static void set_bridge_peer_vars ( struct ast_bridge *  bridge )

static

Definition at line 1426 of file bridge.c.

References AST_BRIDGE_CAPABILITY_HOLDING, AST_LIST_FIRST, AST_LIST_LAST, ast_bridge_technology::capabilities, ast_bridge::channels, ast_bridge::num_channels, set_bridge_peer_vars_2party(), set_bridge_peer_vars_holding(), set_bridge_peer_vars_multiparty(), and ast_bridge::technology.

Referenced by bridge_reconfigured().

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

set_bridge_peer_vars_2party()

static void set_bridge_peer_vars_2party ( struct ast_channel *  c0, struct ast_channel *  c1  )

static

Definition at line 1263 of file bridge.c.

References ast_bridge_vars_set(), ast_channel_lock, ast_channel_unlock, NULL, and UPDATE_BRIDGE_VARS_GET.

Referenced by set_bridge_peer_vars().

{
   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);
   ast_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);
   ast_bridge_vars_set(c1, c0_name, c0_pvtid);
   ast_channel_unlock(c1);
}

set_bridge_peer_vars_holding()

static void set_bridge_peer_vars_holding ( struct ast_bridge *  bridge )

static

Definition at line 1404 of file bridge.c.

References ast_bridge_vars_set(), ast_channel_lock, ast_channel_unlock, AST_LIST_TRAVERSE, ast_bridge_channel::chan, ast_bridge::channels, and NULL.

Referenced by set_bridge_peer_vars().

{
   struct ast_bridge_channel *bridge_channel;

   AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
      ast_channel_lock(bridge_channel->chan);
      ast_bridge_vars_set(bridge_channel->chan, NULL, NULL);
      ast_channel_unlock(bridge_channel->chan);
   }
}

set_bridge_peer_vars_multiparty()

static void set_bridge_peer_vars_multiparty ( struct ast_bridge *  bridge )

static

Definition at line 1342 of file bridge.c.

References ast_alloca, ast_bridge_vars_set(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, AST_LIST_TRAVERSE, ast_strdupa, buf, ast_bridge_channel::chan, ast_bridge::channels, fill_bridgepeer_buf(), len(), MAX_BRIDGEPEER_CHANS, MIN, NULL, and ast_bridge::num_channels.

Referenced by set_bridge_peer_vars().

{
/*
 * 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);
      ast_bridge_vars_set(bridge_channel->chan, buf, NULL);
      ast_channel_unlock(bridge_channel->chan);
   }
}

set_transfer_variables_all()

static void set_transfer_variables_all ( struct ast_channel *  transferer, struct ao2_container *  channels, int  is_attended  )

static

Definition at line 4435 of file bridge.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ast_bridge_set_transfer_variables(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_strdupa, pbx_builtin_getvar_helper(), and S_OR.

Referenced by ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), and two_bridge_attended_transfer().

{
   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) {
         ast_bridge_set_transfer_variables(chan, transferer_bridgepeer, is_attended);
      } else {
         ast_bridge_set_transfer_variables(chan, transferer_name, is_attended);
      }
   }

   ao2_iterator_destroy(&iter);
}

smart_bridge_operation()

static int smart_bridge_operation ( struct ast_bridge *  bridge )

static

Definition at line 998 of file bridge.c.

References ast_bridge::allowed_capabilities, AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_CAPABILITY_NATIVE, AST_BRIDGE_CHANNEL_FLAG_LONELY, ast_channel_name(), ast_debug, AST_FRAME_BRIDGE_ACTION, ast_frdup, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, ast_module_unref, ast_test_flag, ast_verb, BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY, bridge_channel_complete_join(), bridge_queue_action_nodup(), ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_technology::compatible, ast_bridge_technology::create, ast_bridge::creator, deferred_action(), ast_bridge_technology::destroy, ast_bridge::dissolved, ast_bridge_features::feature_flags, ast_bridge_channel::features, find_best_technology(), ast_frame::frametype, ast_bridge_channel::just_joined, ast_bridge_technology::leave, LOG_WARNING, ast_bridge_technology::mod, ast_bridge_technology::name, ast_bridge::name, NULL, ast_bridge::num_active, ast_bridge::num_channels, ast_bridge::num_lonely, ast_bridge_technology::start, ast_bridge_technology::stop, ast_bridge_channel::suspended, tech_deferred_destroy::tech, ast_bridge::tech_pvt, ast_bridge::technology, and ast_bridge::uniqueid.

Referenced by bridge_reconfigured().

{
   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,
      .creator = bridge->creator,
      .name = bridge->name,
      .uniqueid = bridge->uniqueid,
   };

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

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

   /* To ensure that things are sane for the old technology move the channels it
    * expects to the dummy bridge
    */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&bridge->channels, bridge_channel, entry) {
      if (bridge_channel->just_joined) {
         continue;
      }
      ast_debug(1, "Bridge %s: moving %p(%s) to dummy bridge temporarily\n",
         bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
      AST_LIST_REMOVE_CURRENT(entry);
      AST_LIST_INSERT_TAIL(&dummy_bridge.channels, bridge_channel, entry);
      dummy_bridge.num_channels++;
      if (ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
         dummy_bridge.num_lonely++;
      }
      if (!bridge_channel->suspended) {
         dummy_bridge.num_active++;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

   /* Take all the channels out of the old technology */
   AST_LIST_TRAVERSE_SAFE_BEGIN(&dummy_bridge.channels, bridge_channel, entry) {
      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);
      }
      AST_LIST_REMOVE_CURRENT(entry);
      AST_LIST_INSERT_TAIL(&bridge->channels, bridge_channel, entry);
      dummy_bridge.num_channels--;
      if (ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
         dummy_bridge.num_lonely--;
      }
      if (!bridge_channel->suspended) {
         dummy_bridge.num_active--;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;

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

   /* Add any new channels or re-add existing channels to the bridge. */
   AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
      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;
}

tech_capability2str()

static const char* tech_capability2str ( uint32_t  capabilities )

static

Bridge technology capabilities to string.

Definition at line 5335 of file bridge.c.

References AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_EARLY, AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_CAPABILITY_NATIVE, and type.

Referenced by handle_bridge_technology_show(), and manager_bridge_tech_list().

{
   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 = "<Unknown>";
   }
   return type;
}

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

static

Definition at line 2917 of file bridge.c.

References ARRAY_LEN, ast_atomic_fetchadd_int(), ast_channel_internal_bridge(), ast_channel_name(), ast_debug, ast_set_flag, ast_test_flag, AST_UNREAL_CHAN, AST_UNREAL_OPTIMIZE_BEGUN, AST_UNREAL_OWNER, ast_verb, bridge_do_merge(), bridges_allow_merge_optimization(), ast_unreal_pvt::callbacks, ast_bridge_channel::chan, merge_direction::dest, id, MERGE_ALLOWED, MERGE_NO_MULTIMIX, MERGE_NOT_ENOUGH_CHANNELS, MERGE_PROHIBITED, NULL, ast_unreal_pvt_callbacks::optimization_finished, optimization_id, ast_unreal_pvt_callbacks::optimization_started, ast_unreal_pvt::owner, merge_direction::src, and ast_bridge::uniqueid.

Referenced by ast_bridge_unreal_optimize_out().

{
   struct merge_direction merge;
   struct ast_bridge_channel *kick_me[] = {
      chan_bridge_channel,
      peer_bridge_channel,
   };
   unsigned int id;

   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(4, "Merge optimizing %s -- %s out.\n",
      ast_channel_name(chan_bridge_channel->chan),
      ast_channel_name(peer_bridge_channel->chan));

   id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);

   if (pvt && !ast_test_flag(pvt, AST_UNREAL_OPTIMIZE_BEGUN) && pvt->callbacks
         && pvt->callbacks->optimization_started) {
      pvt->callbacks->optimization_started(pvt, NULL,
            merge.dest == ast_channel_internal_bridge(pvt->owner) ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
            id);
      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, 1, id);
   }

   return -1;
}

try_parking()

static enum ast_transfer_result try_parking ( struct ast_channel *  transferer, const char *  context, const char *  exten, transfer_channel_cb  new_channel_cb, struct transfer_channel_data *  user_data_wrapper  )

static

Definition at line 4378 of file bridge.c.

References ao2_cleanup, AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_unlock, ast_parking_blind_transfer_park(), ast_parking_provider_registered(), NULL, and RAII_VAR.

Referenced by ast_bridge_transfer_blind().

{
   RAII_VAR(struct ast_bridge_channel *, transferer_bridge_channel, NULL, ao2_cleanup);

   if (!ast_parking_provider_registered()) {
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   ast_channel_lock(transferer);
   transferer_bridge_channel = ast_channel_get_bridge_channel(transferer);
   ast_channel_unlock(transferer);

   if (!transferer_bridge_channel) {
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   if (ast_parking_blind_transfer_park(transferer_bridge_channel,
      context, exten, new_channel_cb, user_data_wrapper)) {
      return AST_BRIDGE_TRANSFER_FAIL;
   }

   return AST_BRIDGE_TRANSFER_SUCCESS;
}

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

static

Definition at line 2793 of file bridge.c.

References ast_atomic_fetchadd_int(), ast_bridge_channel_leave_bridge(), ast_bridge_channel_peer(), AST_CAUSE_NORMAL_CLEARING, ast_channel_name(), ast_channel_trylock, ast_channel_unlock, ast_set_flag, ast_test_flag, AST_UNREAL_CHAN, AST_UNREAL_OPTIMIZE_BEGUN, AST_UNREAL_OWNER, ast_verb, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_CHANNEL_STATE_WAIT, bridge_do_move(), bridges_allow_swap_optimization(), ast_unreal_pvt::callbacks, ast_bridge_channel::chan, id, ast_unreal_pvt_callbacks::optimization_finished, optimization_id, ast_unreal_pvt_callbacks::optimization_started, ast_unreal_pvt::owner, ast_bridge_channel::state, ast_bridge_channel::swap, SWAP_PROHIBITED, SWAP_TO_CHAN_BRIDGE, and SWAP_TO_PEER_BRIDGE.

Referenced by ast_bridge_unreal_optimize_out().

{
   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) {
      unsigned int id;

      if (ast_channel_trylock(other->chan)) {
         return 1;
      }

      id = ast_atomic_fetchadd_int((int *) &optimization_id, +1);

      ast_verb(4, "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, other->chan,
               dst_bridge_channel->chan == pvt->owner ? AST_UNREAL_OWNER : AST_UNREAL_CHAN,
               id);
         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, AST_CAUSE_NORMAL_CLEARING);
         res = -1;
      }
      if (pvt && pvt->callbacks && pvt->callbacks->optimization_finished) {
         pvt->callbacks->optimization_finished(pvt, res == 1, id);
      }
      ast_channel_unlock(other->chan);
   }
   return res;
}

two_bridge_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 ast_attended_transfer_message *  transfer_msg  )

static

Definition at line 4663 of file bridge.c.

References ao2_cleanup, ARRAY_LEN, ast_attended_transfer_message_add_merge(), AST_BRIDGE_OPTIMIZE_MERGE_TO_CHAN_BRIDGE, AST_BRIDGE_OPTIMIZE_MERGE_TO_PEER_BRIDGE, AST_BRIDGE_OPTIMIZE_PROHIBITED, AST_BRIDGE_OPTIMIZE_SWAP_TO_CHAN_BRIDGE, AST_BRIDGE_OPTIMIZE_SWAP_TO_PEER_BRIDGE, ast_bridge_peers_nolock(), AST_BRIDGE_TRANSFER_FAIL, AST_BRIDGE_TRANSFER_INVALID, AST_BRIDGE_TRANSFER_SUCCESS, ast_bridges_allow_optimization(), attended_transfer_bridge(), bridge_do_merge(), bridge_swap_attended_transfer(), channels, ast_bridge::dissolved, end, ast_bridge::inhibit_merge, NULL, RAII_VAR, and set_transfer_variables_all().

Referenced by ast_bridge_transfer_attended().

{
   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;
   RAII_VAR(struct ao2_container *, channels, NULL, ao2_cleanup);

   channels = ast_bridge_peers_nolock(to_transferee_bridge);

   if (!channels) {
      res = AST_BRIDGE_TRANSFER_FAIL;
      goto end;
   }

   set_transfer_variables_all(to_transferee, channels, 1);

   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) {
         return AST_BRIDGE_TRANSFER_INVALID;
      }

      return attended_transfer_bridge(to_transferee, to_transfer_target,
         to_transferee_bridge, to_target_bridge, transfer_msg);
   }

end:
   if (res == AST_BRIDGE_TRANSFER_SUCCESS) {
      ast_attended_transfer_message_add_merge(transfer_msg, final_bridge);
   }

   return res;
}

wrap_hook()

static void wrap_hook ( struct ast_bridge_features *  features, struct ast_bridge_hook_timer *  hook  )

static

Wrap the provided interval hook and add it to features.

Definition at line 3650 of file bridge.c.

References ao2_bump, ast_bridge_interval_hook(), ast_bridge_hook::callback, ast_flags::flags, ast_bridge_hook_timer_parms::flags, ast_bridge_hook_timer::generic, ast_bridge_hook::hook_pvt, ast_bridge_hook_timer_parms::interval, interval_wrapper_cb(), interval_wrapper_pvt_dtor(), ast_bridge_hook::remove_flags, and ast_bridge_hook_timer::timer.

Referenced by ast_bridge_features_merge().

{
   /* Break out of the current wrapper if it exists to avoid multiple layers */
   if (hook->generic.callback == interval_wrapper_cb) {
      hook = hook->generic.hook_pvt;
   }

   ast_bridge_interval_hook(features, hook->timer.flags, hook->timer.interval,
      interval_wrapper_cb, ao2_bump(hook), interval_wrapper_pvt_dtor,
      hook->generic.remove_flags.flags);
}

Variable Documentation

ast_bridge_base_v_table

struct ast_bridge_methods ast_bridge_base_v_table

Bridge base class virtual method table.

Definition at line 949 of file bridge.c.

Referenced by ast_bridging_init_basic(), bridge_agent_hold_dissolving(), bridge_agent_hold_pull(), bridge_agent_hold_push(), bridge_basic_destroy(), bridge_basic_pull(), bridge_basic_push(), bridge_init_agent_hold(), bridge_parking_destroy(), bridge_parking_dissolving(), bridge_parking_get_merge_priority(), bridge_parking_notify_masquerade(), bridge_parking_pull(), bridge_parking_push(), bridge_stasis_init(), bridge_stasis_pull(), bridge_stasis_push(), and bridge_stasis_push_peek().

bridge_channel_impart_ds_info

const struct ast_datastore_info bridge_channel_impart_ds_info

static

Initial value:

= {
   .type = "bridge-impart-ds",
   .destroy = bridge_channel_impart_ds_head_dtor,
   .chan_fixup = bridge_channel_impart_ds_head_fixup,
}

Definition at line 1576 of file bridge.c.

bridge_cli

struct ast_cli_entry bridge_cli[]

static

Definition at line 5462 of file bridge.c.

bridge_manager

struct bridge_manager_controller* bridge_manager

static

Bridge manager controller.

Definition at line 172 of file bridge.c.

bridge_technologies

struct bridge_technologies bridge_technologies = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

bridges

struct ao2_container* bridges

static

All bridges container.

Definition at line 123 of file bridge.c.

Referenced by app_to_json(), ast_ari_bridges_list(), bridges_scrape_cb(), manager_bridges_list(), and stasis_app_to_cli().

builtin_features_dtmf

char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING]

static

Default DTMF keys for built in features

Definition at line 144 of file bridge.c.

Referenced by ast_bridge_features_enable(), and ast_bridge_features_register().

builtin_features_handlers

ast_bridge_hook_callback builtin_features_handlers[AST_BRIDGE_BUILTIN_END]

static

Function handlers for the built in features

Definition at line 147 of file bridge.c.

Referenced by ast_bridge_features_do(), ast_bridge_features_enable(), ast_bridge_features_register(), and ast_bridge_features_unregister().

builtin_interval_handlers

ast_bridge_builtin_set_limits_fn builtin_interval_handlers[AST_BRIDGE_BUILTIN_INTERVAL_END]

static

Function handlers for built in interval features

Definition at line 150 of file bridge.c.

Referenced by ast_bridge_features_set_limits(), ast_bridge_interval_register(), and ast_bridge_interval_unregister().

optimization_id

unsigned int optimization_id

static

Definition at line 127 of file bridge.c.

Referenced by try_merge_optimize_out(), and try_swap_optimize_out().