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 %-36s %5s %-15s %-15s %s\n"
#define	FORMAT_HDR   "%-20s %-20s %8s %s\n"
#define	FORMAT_ROW   "%-36s %-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)
	Unregisters a handler for a built in interval feature. More...
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)
	Attach a bridge channel join hook to a bridge features structure. 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)
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_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 ast_mutex_t	bridge_init_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
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 150 of file bridge.c.

BLINDTRANSFER

#define BLINDTRANSFER   "BLINDTRANSFER"

Definition at line 147 of file bridge.c.

BRIDGE_ARRAY_GROW

#define BRIDGE_ARRAY_GROW   32

Definition at line 144 of file bridge.c.

BRIDGE_ARRAY_START

#define BRIDGE_ARRAY_START   128

Definition at line 141 of file bridge.c.

BRIDGE_LOCK_ONE_OR_BOTH

#define BRIDGE_LOCK_ONE_OR_BOTH	(		b1,
			b2
	)

FORMAT_HDR [1/2]

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

FORMAT_HDR [2/2]

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

FORMAT_ROW [1/2]

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

FORMAT_ROW [2/2]

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

MAX_BRIDGEPEER_CHANS

#define MAX_BRIDGEPEER_CHANS   (10 + 1)

UPDATE_BRIDGE_VARS_GET

#define UPDATE_BRIDGE_VARS_GET	(		chan,
			name,
			pvtid
	)

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 2880 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 2741 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 223 of file bridge.c.

{
    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(5, "Registered bridge technology %s\n", technology->name);
 
    return 0;
}

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, current, LOG_WARNING, ast_bridge_technology::mod, ast_bridge_technology::name, ast_bridge_technology::preference, and ast_bridge_technology::write.

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 2540 of file bridge.c.

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

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(), ast_bridge_channel::bridge, bridge_dissolve_check_stolen(), bridge_find_channel(), bridge_move_locked(), ast_bridge_channel::chan, ast_bridge_channel::features, LOG_WARNING, NULL, and RAII_VAR.

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

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)

Returns

a pointer to a new bridge on success

Return values

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 999 of file bridge.c.

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

References ast_bridge_base_v_table, bridge_alloc(), bridge_base_init(), bridge_register(), ast_bridge::creator, and name.

Referenced by AST_TEST_DEFINE(), get_wait_bridge_wrapper(), and join_conference_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 1975 of file bridge.c.

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

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().

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 1009 of file bridge.c.

{
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": destroying.  current refcount: %d\n",
        BRIDGE_PRINTF_VARS(bridge), ao2_ref(bridge, 0));
    ast_bridge_lock(bridge);
    bridge_dissolve(bridge, cause);
    ast_bridge_unlock(bridge);
 
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": unreffing.  current refcount: %d\n",
        BRIDGE_PRINTF_VARS(bridge), ao2_ref(bridge, 0));
 
    ao2_ref(bridge, -1);
 
    return 0;
}

References ao2_ref, ast_bridge_lock, ast_bridge_unlock, ast_debug, bridge_dissolve(), BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, and ast_bridge::cause.

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_base_init(), bridge_create_common(), bridge_exec(), bridge_register(), caller_abort_agent(), destroy_conference_bridge(), fail_enter(), 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_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 3251 of file bridge.c.

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

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().

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

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 3722 of file bridge.c.

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

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().

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

Definition at line 3743 of file bridge.c.

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

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().

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 3159 of file bridge.c.

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

References ARRAY_LEN, and builtin_features_handlers.

Referenced by agent_connect_caller().

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 3434 of file bridge.c.

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

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

Referenced by builtin_features_helper().

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 3689 of file bridge.c.

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

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().

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 allocated, but not initialized

Return values

0	on success
-1	on failure

Definition at line 3465 of file bridge.c.

{
    memset(limits, 0, sizeof(*limits));
 
    if (ast_string_field_init(limits, 256)) {
        return -1;
    }
 
    return 0;
}

References ast_string_field_init.

Referenced by bridge_builtin_set_limits(), and pre_bridge_setup().

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 3476 of file bridge.c.

{
    ast_string_field_free_memory(limits);
}

References ast_string_field_free_memory.

Referenced by bridge_features_limits_dtor(), and pre_bridge_setup().

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 3664 of file bridge.c.

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

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().

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

Returns

features New allocated features struct.

Return values

NULL

on error.

Definition at line 3752 of file bridge.c.

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

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().

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 3131 of file bridge.c.

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

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().

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.

Definition at line 3570 of file bridge.c.

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

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

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

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

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 3496 of file bridge.c.

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

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

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 3481 of file bridge.c.

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

References AST_BRIDGE_BUILTIN_INTERVAL_LIMITS, ast_log, builtin_interval_handlers, and LOG_ERROR.

Referenced by pre_bridge_setup().

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 3147 of file bridge.c.

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

References ARRAY_LEN, builtin_features_handlers, and NULL.

Referenced by unload_module(), and unload_parking_bridge_features().

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 5081 of file bridge.c.

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

References ao2_find, bridges, and OBJ_SEARCH_KEY.

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

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 3334 of file bridge.c.

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

References AST_BRIDGE_HOOK_TYPE_HANGUP, bridge_other_hook(), ast_bridge_hook::callback, ast_bridge_hook::destructor, ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by add_normal_hooks(), and bridge_personality_atxfer_push().

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 1947 of file bridge.c.

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

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(), cond, 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(), local_call(), parking_blind_transfer_park(), recalling_exit(), refer_incoming_invite_request(), and retransfer_enter().

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 3388 of file bridge.c.

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

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().

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 3176 of file bridge.c.

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

References ARRAY_LEN, and builtin_interval_handlers.

Referenced by load_module().

ast_bridge_interval_unregister()

int ast_bridge_interval_unregister

(

enum ast_bridge_builtin_interval

interval

)

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)

This unregisters the function that is handling the built in duration limit feature.

Definition at line 3188 of file bridge.c.

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

References ARRAY_LEN, builtin_interval_handlers, and NULL.

Referenced by unload_module().

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.
non-zero	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 3960 of file bridge.c.

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

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().

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 1690 of file bridge.c.

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

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, ast_bridge_channel::bridge, 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().

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
	)

Attach a bridge channel join 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_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 3344 of file bridge.c.

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

References AST_BRIDGE_HOOK_TYPE_JOIN, bridge_other_hook(), ast_bridge_hook::callback, ast_bridge_hook::destructor, ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by agent_request_exec(), and confbridge_exec().

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 2048 of file bridge.c.

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

References ast_bridge_channel_queue_callback(), ast_bridge_lock, ast_bridge_unlock, ast_bridge_channel::bridge, bridge_find_channel(), ast_bridge_channel::chan, kick_it(), and NULL.

Referenced by handle_bridge_kick_channel(), and manager_bridge_kick().

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 3354 of file bridge.c.

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

References AST_BRIDGE_HOOK_TYPE_LEAVE, bridge_other_hook(), ast_bridge_hook::callback, ast_bridge_hook::destructor, ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by confbridge_exec().

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 2369 of file bridge.c.

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

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

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

Definition at line 3069 of file bridge.c.

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

References ast_bridge_lock, ast_bridge_unlock, bridge_merge_inhibit_nolock(), and request().

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

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 2529 of file bridge.c.

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

References ast_bridge_lock_both, ast_bridge_unlock, bridge_move_locked(), ast_bridge_channel::chan, and ast_bridge_channel::swap.

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

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 3376 of file bridge.c.

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

References AST_BRIDGE_HOOK_TYPE_MOVE, bridge_other_hook(), ast_bridge_hook::callback, ast_bridge_hook::destructor, hook_cb(), ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by bridge_stasis_pull().

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

Definition at line 1511 of file bridge.c.

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

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_find_channel(), bridge_reconfigured(), ast_bridge_methods::notify_masquerade, and ast_bridge::v_table.

Referenced by channel_do_masquerade().

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 3933 of file bridge.c.

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

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().

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 4144 of file bridge.c.

{
    struct ast_channel *peer;
 
    ast_bridge_lock(bridge);
    peer = ast_bridge_peer_nolock(bridge, chan);
    ast_bridge_unlock(bridge);
 
    return peer;
}

References ast_bridge_lock, ast_bridge_peer_nolock(), ast_bridge_unlock, and ast_channel::bridge.

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

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 4116 of file bridge.c.

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

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

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

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 4105 of file bridge.c.

{
    struct ao2_container *channels;
 
    ast_bridge_lock(bridge);
    channels = ast_bridge_peers_nolock(bridge);
    ast_bridge_unlock(bridge);
 
    return channels;
}

References ast_bridge_lock, ast_bridge_peers_nolock(), ast_bridge_unlock, and 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 4087 of file bridge.c.

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

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

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

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 314 of file bridge.c.

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

References ast_frdup, and bridge_queue_action_nodup().

Referenced by bridge_dissolve().

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 2020 of file bridge.c.

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

References ast_bridge_channel_leave_bridge(), ast_bridge_lock, ast_bridge_unlock, AST_CAUSE_NORMAL_CLEARING, ast_channel_name(), ast_debug, ast_bridge_channel::bridge, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_find_channel(), ast_bridge_channel::chan, 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().

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 3986 of file bridge.c.

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

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_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 3774 of file bridge.c.

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

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

Referenced by join_conference_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 3781 of file bridge.c.

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

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

Referenced by join_conference_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 3788 of file bridge.c.

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

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

Referenced by join_conference_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 3767 of file bridge.c.

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

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

Referenced by join_conference_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 3876 of file bridge.c.

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

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_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 3858 of file bridge.c.

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

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_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 4035 of file bridge.c.

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

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

Referenced by bridge_stasis_new(), and join_conference_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 3843 of file bridge.c.

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

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_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 3818 of file bridge.c.

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

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_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 3835 of file bridge.c.

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

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_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 4421 of file bridge.c.

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

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

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

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 3851 of file bridge.c.

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

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_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 3076 of file bridge.c.

{
    struct ast_bridge_channel *bridge_channel;
/* XXX ASTERISK-21271 the case of a dissolved 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;
}

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_channel::bridge, bridge_channel_internal_suspend_nolock(), bridge_find_channel(), and ast_bridge_channel::chan.

Referenced by conf_moh_start(), and conf_moh_stop().

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 3364 of file bridge.c.

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

References AST_BRIDGE_HOOK_TYPE_TALK, bridge_other_hook(), ast_bridge_hook::callback, ast_bridge_hook::destructor, hook_cb(), ast_bridge_hook::hook_pvt, and ast_bridge_hook::remove_flags.

Referenced by confbridge_exec().

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 3116 of file bridge.c.

{
    technology->suspended = 1;
}

References ast_bridge_technology::suspended.

Referenced by handle_bridge_technology_suspend(), and handle_manager_bridge_tech_suspend().

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 274 of file bridge.c.

{
    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(5, "Unregistered bridge technology %s\n", technology->name);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    AST_RWLIST_UNLOCK(&bridge_technologies);
 
    return current ? 0 : -1;
}

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

Referenced by dahdi_native_unload(), and unload_module().

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 3121 of file bridge.c.

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

References ast_bridge_technology::suspended.

Referenced by handle_bridge_technology_suspend(), and handle_manager_bridge_tech_suspend().

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 4477 of file bridge.c.

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

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, ast_bridge::feature_flags, and NULL.

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

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 4746 of file bridge.c.

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

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(), and refer_attended_task().

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 4494 of file bridge.c.

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

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_channel_internal_queue_blind_transfer(), channels, voicemailpwcheck::context, lock, LOG_ERROR, NULL, publish, RAII_VAR, SCOPED_LOCK, set_transfer_variables_all(), and try_parking().

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

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 2989 of file bridge.c.

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

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

Referenced by got_optimized_out().

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 3097 of file bridge.c.

{
    struct ast_bridge_channel *bridge_channel;
/* XXX ASTERISK-21271 the case of a dissolved 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;
}

References ast_bridge_lock, ast_bridge_unlock, ast_bridge_channel::bridge, bridge_channel_internal_unsuspend_nolock(), bridge_find_channel(), and ast_bridge_channel::chan.

Referenced by conf_moh_start(), and conf_moh_stop().

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 3885 of file bridge.c.

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

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().

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

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

Definition at line 1281 of file bridge.c.

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

References ast_channel_stage_snapshot(), ast_channel_stage_snapshot_done(), ast_bridge_channel::chan, name, 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_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

Returns

A string representation of video_mode

Definition at line 4020 of file bridge.c.

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

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().

ast_bridges()

struct ao2_container * ast_bridges

(

void

)

Returns the global bridges container.

Since

17.0

Returns

a pointer to the bridges container success

Return values

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 185 of file bridge.c.

{
    return ao2_bump(bridges);
}

References ao2_bump, and bridges.

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

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 3029 of file bridge.c.

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

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().

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 5613 of file bridge.c.

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

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_cli, bridge_manager, bridge_manager_create(), bridge_prnt_obj(), bridge_sort_cmp(), bridges, manager_bridge_tech_list(), manager_bridge_tech_suspend(), manager_bridge_tech_unsuspend(), and NULL.

Referenced by asterisk_daemon().

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 3867 of file bridge.c.

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

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().

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.
transfer_msg	Data to publish for a stasis attended transfer message.

Return values

AST_BRIDGE_TRANSFER_FAIL	Internal error occurred
AST_BRIDGE_TRANSFER_SUCCESS	Successfully transferred the bridge

Definition at line 4290 of file bridge.c.

{
#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;
    struct ast_format_cap *caps;
 
    ast_channel_lock(chan1);
    caps = ao2_bump(ast_channel_nativeformats(chan1));
    ast_channel_unlock(chan1);
 
    local_chan = ast_request("Local", caps, NULL, chan1, dest, &cause);
 
    ao2_cleanup(caps);
 
    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;
}

References ao2_bump, 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, 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().

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 4180 of file bridge.c.

{
    struct ast_channel *local;
    char chan_name[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
    int cause;
    struct ast_format_cap *caps;
 
    ast_channel_lock(transferer);
    caps = ao2_bump(ast_channel_nativeformats(transferer));
    ast_channel_unlock(transferer);
 
    snprintf(chan_name, sizeof(chan_name), "%s@%s", exten, context);
    local = ast_request("Local", caps, NULL, transferer,
            chan_name, &cause);
 
    ao2_cleanup(caps);
 
    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;
}

References ao2_bump, ao2_cleanup, 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, 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, voicemailpwcheck::context, NULL, pbx_builtin_setvar_helper(), and ast_blind_transfer_message::replace_channel.

Referenced by ast_bridge_transfer_blind().

bridge_action_bridge()

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

static

Definition at line 607 of file bridge.c.

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

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().

bridge_alloc()

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

Definition at line 747 of file bridge.c.

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

References ao2_alloc, ao2_cleanup, ast_assert, ast_log, AST_MEDIA_TYPE_END, ast_string_field_init, AST_VECTOR_INIT, 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().

bridge_allows_optimization()

static int bridge_allows_optimization ( struct ast_bridge *  bridge )

static

Definition at line 2629 of file bridge.c.

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

References AST_BRIDGE_FLAG_MASQUERADE_ONLY, ast_test_flag, ast_channel::bridge, 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().

bridge_base_destroy()

static void bridge_base_destroy ( struct ast_bridge *  self )

static

Definition at line 880 of file bridge.c.

{
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": destroying bridge (noop)\n",
        BRIDGE_PRINTF_VARS(self));
}

References ast_debug, BRIDGE_PRINTF_SPEC, and BRIDGE_PRINTF_VARS.

bridge_base_dissolving()

static void bridge_base_dissolving ( struct ast_bridge *  self )

static

Definition at line 893 of file bridge.c.

{
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": unlinking bridge.  Refcount: %d\n",
        BRIDGE_PRINTF_VARS(self), ao2_ref(self, 0));
    ao2_unlink(bridges, self);
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": unlinked bridge.  Refcount: %d\n",
        BRIDGE_PRINTF_VARS(self), ao2_ref(self, 0));
}

References ao2_ref, ao2_unlink, ast_debug, BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, and bridges.

bridge_base_get_merge_priority()

static int bridge_base_get_merge_priority ( struct ast_bridge *  self )

static

Definition at line 963 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)

Returns

self on success

Return values

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 783 of file bridge.c.

{
    char uuid_hold[AST_UUID_STR_LEN];
 
    if (!self) {
        return NULL;
    }
 
    {
        /*
         * We need to ensure that another bridge with the same uniqueid
         * doesn't get created before the previous bridge's destructor
         * has run and deleted the existing topic.
         */
        SCOPED_MUTEX(lock, &bridge_init_lock);
        if (!ast_strlen_zero(id)) {
            if (ast_bridge_topic_exists(id)) {
                ast_log(LOG_WARNING, "Bridge " BRIDGE_PRINTF_SPEC ": already registered\n",
                    BRIDGE_PRINTF_VARS(self));
                ast_bridge_destroy(self, 0);
                return NULL;
            }
            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);
        }
        if (!(flags & AST_BRIDGE_FLAG_INVISIBLE)) {
            if (bridge_topics_init(self) != 0) {
                ast_log(LOG_WARNING, "Bridge " BRIDGE_PRINTF_SPEC ": Could not initialize topics\n",
                    BRIDGE_PRINTF_VARS(self));
                ao2_ref(self, -1);
                return NULL;
            }
        }
    }
 
    ast_string_field_set(self, creator, creator);
    if (!ast_strlen_zero(creator)) {
        ast_string_field_set(self, name, name);
    }
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": base_init\n",
        BRIDGE_PRINTF_VARS(self));
 
    ast_set_flag(&self->feature_flags, flags);
    self->allowed_capabilities = capabilities;
 
    /* Use our helper function to find the "best" bridge technology. */
    self->technology = find_best_technology(capabilities, self);
    if (!self->technology) {
        ast_log(LOG_WARNING, "Bridge %s: Could not create class %s.  No technology to support it.\n",
            self->uniqueid, self->v_table->name);
        ao2_ref(self, -1);
        return NULL;
    }
 
    /* Pass off the bridge to the technology to manipulate if needed */
    ast_debug(1, "Bridge %s: calling %s technology constructor\n",
        self->uniqueid, self->technology->name);
    if (self->technology->create && self->technology->create(self)) {
        ast_log(LOG_WARNING, "Bridge %s: failed to setup bridge technology %s\n",
            self->uniqueid, self->technology->name);
        ao2_ref(self, -1);
        return NULL;
    }
    ast_debug(1, "Bridge %s: calling %s technology start\n",
        self->uniqueid, self->technology->name);
    if (self->technology->start && self->technology->start(self)) {
        ast_log(LOG_WARNING, "Bridge %s: failed to start bridge technology %s\n",
            self->uniqueid, self->technology->name);
        ao2_ref(self, -1);
        return NULL;
    }
 
    if (!(flags & AST_BRIDGE_FLAG_INVISIBLE)) {
        if (!ast_bridge_topic(self)) {
            ao2_ref(self, -1);
            return NULL;
        }
    }
 
    self->creationtime = ast_tvnow();
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": base_init complete\n",
        BRIDGE_PRINTF_VARS(self));
 
    return self;
}

References ast_bridge::allowed_capabilities, ao2_ref, ast_bridge_destroy(), AST_BRIDGE_FLAG_INVISIBLE, ast_bridge_topic(), ast_bridge_topic_exists(), 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_init_lock, BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, bridge_topics_init(), ast_bridge_technology::create, ast_bridge::creationtime, ast_bridge::creator, ast_bridge::feature_flags, find_best_technology(), lock, LOG_WARNING, name, ast_bridge_methods::name, ast_bridge_technology::name, NULL, SCOPED_MUTEX, ast_bridge_technology::start, ast_bridge::technology, ast_bridge::uniqueid, 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().

bridge_base_notify_masquerade()

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

static

Definition at line 947 of file bridge.c.

{
    self->reconfigured = 1;
}

References ast_bridge::reconfigured.

bridge_base_pull()

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

static

Definition at line 932 of file bridge.c.

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

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

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 917 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 983 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 2076 of file bridge.c.

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

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().

bridge_channel_complete_join()

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

static

Definition at line 452 of file bridge.c.

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

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().

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 1780 of file bridge.c.

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

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().

bridge_channel_impart_add()

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

static

Definition at line 1618 of file bridge.c.

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

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, bridge_channel_impart_ds_info, cond, ast_datastore::data, and NULL.

Referenced by bridge_impart_internal().

bridge_channel_impart_ds_head_dtor()

static void bridge_channel_impart_ds_head_dtor ( void *  doomed )

static

Definition at line 1577 of file bridge.c.

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

References ast_free, and bridge_channel_impart_ds_head_signal().

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 1592 of file bridge.c.

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

References bridge_channel_impart_ds_head_signal().

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 1563 of file bridge.c.

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

References ast_cond_signal, AST_LIST_REMOVE_HEAD, ast_mutex_lock, ast_mutex_unlock, and cond.

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

bridge_channel_impart_signal()

void bridge_channel_impart_signal

(

struct ast_channel *

chan

)

Definition at line 1651 of file bridge.c.

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

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, bridge_channel_impart_ds_head_signal(), bridge_channel_impart_ds_info, 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().

bridge_channel_impart_wait()

static void bridge_channel_impart_wait ( struct bridge_channel_impart_cond *  cond )

static

Definition at line 1670 of file bridge.c.

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

References ast_cond_wait, ast_mutex_lock, ast_mutex_unlock, and cond.

Referenced by bridge_impart_internal().

bridge_channel_ind_thread()

static void * bridge_channel_ind_thread ( void *  data )

static

Thread responsible for independent imparted bridged channels.

Definition at line 1811 of file bridge.c.

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

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, ast_channel::bridge_channel, 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().

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 2091 of file bridge.c.

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

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().

bridge_cleanup()

static void bridge_cleanup ( void  )

static

Definition at line 5599 of file bridge.c.

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

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

Referenced by ast_bridging_init().

bridge_complete_join()

static void bridge_complete_join ( struct ast_bridge *  bridge )

static

Definition at line 493 of file bridge.c.

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

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

Referenced by bridge_reconfigured().

bridge_dissolve()

void bridge_dissolve	(	struct ast_bridge *	bridge,
		int	cause
	)

Definition at line 326 of file bridge.c.

{
    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) {
        ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": already dissolved\n",
            BRIDGE_PRINTF_VARS(bridge));
        return;
    }
    bridge->dissolved = 1;
 
    if (cause <= 0) {
        cause = AST_CAUSE_NORMAL_CLEARING;
    }
    bridge->cause = cause;
 
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": dissolving with cause %d(%s)\n",
        BRIDGE_PRINTF_VARS(bridge), cause, ast_cause2str(cause));
 
    AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) {
        ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": kicking channel %s\n",
            BRIDGE_PRINTF_VARS(bridge),
            ast_channel_name(bridge_channel->chan));
        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);
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": DEFERRED_DISSOLVING queued.  current refcound: %d\n",
        BRIDGE_PRINTF_VARS(bridge), ao2_ref(bridge, 0));
 
}

References ao2_ref, ast_bridge_channel_leave_bridge(), ast_bridge_queue_action(), ast_cause2str(), AST_CAUSE_NORMAL_CLEARING, ast_channel_name(), ast_debug, AST_FRAME_BRIDGE_ACTION, AST_LIST_TRAVERSE, BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, ast_bridge::cause, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge::dissolved, and ast_frame::frametype.

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

bridge_dissolve_check_stolen()

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

static

Definition at line 374 of file bridge.c.

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

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

Referenced by ast_bridge_add_channel().

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 2117 of file bridge.c.

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

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_channel::entry, 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().

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 2383 of file bridge.c.

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

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().

bridge_dtmf_hook_sort()

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

static

Definition at line 3608 of file bridge.c.

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

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().

bridge_find_channel()

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

Definition at line 1498 of file bridge.c.

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

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

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().

bridge_handle_actions()

static void bridge_handle_actions ( struct ast_bridge *  bridge )

static

Definition at line 641 of file bridge.c.

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

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().

bridge_hook_destroy()

static void bridge_hook_destroy ( void *  vhook )

static

Definition at line 3208 of file bridge.c.

{
    struct ast_bridge_hook *hook = vhook;
 
    if (hook->destructor) {
        hook->destructor(hook->hook_pvt);
    }
}

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

Referenced by bridge_hook_generic().

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 3231 of file bridge.c.

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

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().

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 1846 of file bridge.c.

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

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, ast_bridge_channel::bridge, 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, cond, 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().

bridge_manager_create()

static struct bridge_manager_controller * bridge_manager_create ( void  )

static

Definition at line 5020 of file bridge.c.

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

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().

bridge_manager_destroy()

static void bridge_manager_destroy ( void *  obj )

static

Definition at line 4988 of file bridge.c.

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

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_controller::cond, NULL, request(), bridge_manager_controller::service_requests, bridge_manager_controller::stop, and bridge_manager_controller::thread.

Referenced by bridge_manager_create().

bridge_manager_service()

static void bridge_manager_service ( struct ast_bridge *  bridge )

static

Definition at line 4938 of file bridge.c.

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

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

Referenced by bridge_manager_thread().

bridge_manager_service_req()

static void bridge_manager_service_req ( struct ast_bridge *  bridge )

static

Definition at line 197 of file bridge.c.

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

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

Referenced by bridge_queue_action_nodup().

bridge_manager_thread()

static void * bridge_manager_thread ( void *  data )

static

Definition at line 4955 of file bridge.c.

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

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

Referenced by bridge_manager_create().

bridge_merge_determine_direction()

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

static

Definition at line 2222 of file bridge.c.

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

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().

bridge_merge_inhibit_nolock()

void bridge_merge_inhibit_nolock	(	struct ast_bridge *	bridge,
		int	request
	)

Definition at line 3060 of file bridge.c.

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

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

Referenced by ast_bridge_channel_merge_inhibit(), and ast_bridge_merge_inhibit().

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 2285 of file bridge.c.

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

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().

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 2468 of file bridge.c.

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

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_channel::chan, ast_bridge::dissolved, ast_bridge::feature_flags, ast_bridge_features::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().

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 3300 of file bridge.c.

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

References ao2_link, ao2_ref, bridge_hook_generic(), ast_bridge_hook::callback, ast_bridge_hook::destructor, ast_bridge_hook::hook_pvt, NULL, ast_bridge_features::other_hooks, ast_bridge_hook::remove_flags, 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().

bridge_prnt_obj()

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

static

Definition at line 5583 of file bridge.c.

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

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

Referenced by ast_bridging_init().

bridge_queue_action_nodup()

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

static

Definition at line 303 of file bridge.c.

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

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().

bridge_reconfigured()

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

Definition at line 1472 of file bridge.c.

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

References AST_BRIDGE_FLAG_SMART, ast_bridge_publish_state(), ast_test_flag, ast_bridge_channel::bridge, 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().

bridge_reconfigured_connected_line_update()

static void bridge_reconfigured_connected_line_update ( struct ast_bridge *  bridge )

static

Definition at line 404 of file bridge.c.

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

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_channel::bridge, ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, connected, NULL, and ast_bridge::technology.

Referenced by bridge_reconfigured().

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.

Returns

bridge on success.

Return values

NULL

on error.

Definition at line 713 of file bridge.c.

{
    if (bridge) {
        SCOPED_MUTEX(lock, &bridge_init_lock);
        /*
         * Although bridge_base_init() should have already checked for
         * an existing bridge with the same uniqueid, bridge_base_init()
         * and bridge_register() are two separate public APIs so we need
         * to check again here.
         */
        struct ast_bridge *existing = ast_bridge_find_by_id(bridge->uniqueid);
        if (existing) {
            ast_log(LOG_WARNING, "Bridge " BRIDGE_PRINTF_SPEC ": already registered\n",
                BRIDGE_PRINTF_VARS(bridge));
            ao2_ref(existing, -1);
            ast_bridge_destroy(bridge, 0);
            return NULL;
        }
        ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": registering\n",
            BRIDGE_PRINTF_VARS(bridge));
        bridge->construction_completed = 1;
        ast_bridge_lock(bridge);
        ast_bridge_publish_state(bridge);
        ast_bridge_unlock(bridge);
        if (!ao2_link(bridges, bridge)) {
            ast_log(LOG_WARNING, "Bridge " BRIDGE_PRINTF_SPEC ": failed to link\n",
                BRIDGE_PRINTF_VARS(bridge));
            ast_bridge_destroy(bridge, 0);
            bridge = NULL;
        }
    }
    return bridge;
}

References ao2_link, ao2_ref, ast_bridge_destroy(), ast_bridge_find_by_id(), ast_bridge_lock, ast_bridge_publish_state(), ast_bridge_unlock, ast_debug, ast_log, bridge_init_lock, BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, bridges, ast_bridge::construction_completed, lock, LOG_WARNING, NULL, SCOPED_MUTEX, 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().

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 5152 of file bridge.c.

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

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

Referenced by handle_bridge_show_specific().

bridge_sort_cmp()

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

static

Definition at line 5059 of file bridge.c.

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

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

Referenced by ast_bridging_init().

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 4637 of file bridge.c.

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

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().

bridge_tech_deferred_destroy()

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

static

Definition at line 579 of file bridge.c.

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

References ast_debug, ast_module_unref, ast_bridge::creator, ast_frame::data, ast_bridge_technology::destroy, ast_bridge_technology::mod, ast_bridge::name, ast_bridge_technology::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().

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 2904 of file bridge.c.

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

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().

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 2758 of file bridge.c.

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

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().

channel_cmp()

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

static

Definition at line 4065 of file bridge.c.

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

References ast_channel_name(), CMP_MATCH, ast_channel::flags, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by ast_bridge_peers_nolock().

channel_hash()

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

static

Definition at line 4042 of file bridge.c.

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

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

Referenced by ast_bridge_peers_nolock().

check_bridge_play_sound()

static void check_bridge_play_sound ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 1244 of file bridge.c.

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

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().

check_bridge_play_sounds()

static void check_bridge_play_sounds ( struct ast_bridge *  bridge )

static

Definition at line 1272 of file bridge.c.

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

References AST_LIST_TRAVERSE, ast_bridge_channel::bridge, ast_bridge::channels, check_bridge_play_sound(), and ast_bridge_channel::entry.

Referenced by bridge_reconfigured().

cleanup_video_mode()

static void cleanup_video_mode ( struct ast_bridge *  bridge )

static

Definition at line 3795 of file bridge.c.

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

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().

complete_bridge_live()

static char * complete_bridge_live ( const char *  word )

static

Definition at line 5097 of file bridge.c.

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

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

Referenced by handle_bridge_kick_channel(), and handle_bridge_show_specific().

complete_bridge_live_search()

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

static

Definition at line 5086 of file bridge.c.

{
    struct ast_bridge *bridge = obj;
 
    if (ast_cli_completion_add(ast_strdup(bridge->uniqueid))) {
        return CMP_STOP;
    }
 
    return 0;
}

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

Referenced by complete_bridge_live().

complete_bridge_participant()

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

static

Definition at line 5253 of file bridge.c.

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

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, ast_bridge_channel::bridge, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_channel::entry, and NULL.

Referenced by handle_bridge_kick_channel().

complete_bridge_technology()

static char * complete_bridge_technology ( const char *  word )

static

Definition at line 5402 of file bridge.c.

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

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().

destroy_bridge()

static void destroy_bridge ( void *  obj )

static

Definition at line 659 of file bridge.c.

{
    struct ast_bridge *bridge = obj;
 
    ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": actually destroying %s bridge, nobody wants it anymore\n",
        BRIDGE_PRINTF_VARS(bridge), 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_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": destroyed\n",
        BRIDGE_PRINTF_VARS(bridge));
    ast_string_field_free_memory(bridge);
    ao2_cleanup(bridge->current_snapshot);
    bridge->current_snapshot = NULL;
}

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_handle_actions(), BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, bridge_topics_destroy(), ast_bridge::callid, ast_bridge::channels, cleanup_video_mode(), ast_bridge::construction_completed, ast_bridge::current_snapshot, ast_bridge_methods::destroy, ast_bridge_technology::destroy, ast_bridge::media_types, ast_bridge_technology::mod, ast_bridge_methods::name, ast_bridge_technology::name, NULL, ast_bridge_technology::stop, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by bridge_alloc().

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 1338 of file bridge.c.

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

References buf.

Referenced by set_bridge_peer_vars_multiparty().

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 518 of file bridge.c.

{
    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(2, "Bridge technology %s is suspended. Skipping.\n",
                current->name);
            continue;
        }
        if (!(current->capabilities & capabilities)) {
            ast_debug(2, "Bridge technology %s does not have any capabilities we want.\n",
                current->name);
            continue;
        }
        if (best && current->preference <= best->preference) {
            ast_debug(2, "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(2, "Bridge technology %s is not compatible with properties of existing bridge.\n",
                current->name);
            continue;
        }
        if (!ast_module_running_ref(current->mod)) {
            ast_debug(2, "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;
}

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

Referenced by bridge_base_init(), and smart_bridge_operation().

get_transferee()

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

static

Definition at line 4251 of file bridge.c.

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

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

Referenced by ast_bridge_transfer_attended().

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 5281 of file bridge.c.

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

References a, ao2_ref, 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, ast_bridge_channel::bridge, ast_channel::bridge, ast_bridge::channels, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_bridge_live(), complete_bridge_participant(), ast_bridge_channel::entry, kick_it(), NULL, and ast_cli_entry::usage.

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 5105 of file bridge.c.

{
#define FORMAT_HDR "%-36s %-36s %5s %-15s %-15s %s\n"
#define FORMAT_ROW "%-36s %-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", "Name", "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,
                bridge->uniqueid,
                S_OR(bridge->name, "<unknown>"),
                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
}

References a, 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(), bridges, CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, ast_bridge_snapshot::creationtime, FORMAT_HDR, FORMAT_ROW, ast_bridge::name, NULL, ast_bridge_snapshot::num_channels, S_OR, ast_bridge_snapshot::subclass, ast_bridge_snapshot::technology, ast_bridge::uniqueid, and ast_cli_entry::usage.

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 5169 of file bridge.c.

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

References a, ao2_callback, ao2_ref, 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_bridge_snapshot::name, NULL, ast_bridge_snapshot::num_active, ast_bridge_snapshot::num_channels, OBJ_NODATA, S_OR, ast_bridge_snapshot::subclass, ast_bridge_snapshot::technology, ast_bridge_snapshot::uniqueid, ast_cli_entry::usage, ast_bridge_snapshot::video_mode, and ast_bridge_snapshot::video_source_id.

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 5367 of file bridge.c.

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

References a, 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, 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.

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 5421 of file bridge.c.

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

References a, 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_bridge_technology::name, NULL, suspend(), and ast_cli_entry::usage.

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 5486 of file bridge.c.

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

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(), name, ast_bridge_technology::name, and suspend().

Referenced by manager_bridge_tech_suspend(), and manager_bridge_tech_unsuspend().

hook_remove_match()

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

static

Definition at line 3514 of file bridge.c.

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

References ast_test_flag, CMP_MATCH, and ast_bridge_hook::remove_flags.

Referenced by hooks_remove_container().

hooks_remove_container()

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

static

Definition at line 3534 of file bridge.c.

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

References ao2_callback, hook_remove_match(), OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, and ast_bridge_hook::remove_flags.

Referenced by ast_bridge_features_remove().

hooks_remove_heap()

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

static

Definition at line 3548 of file bridge.c.

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

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().

interval_hook_time_cmp()

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

static

Definition at line 3577 of file bridge.c.

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

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().

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 3638 of file bridge.c.

{
    struct ast_bridge_hook_timer *hook = obj;
 
    return hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
}

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

Referenced by wrap_hook().

interval_wrapper_pvt_dtor()

static void interval_wrapper_pvt_dtor ( void *  obj )

static

Destructor for the hook wrapper.

Definition at line 3646 of file bridge.c.

{
    ao2_cleanup(obj);
}

References ao2_cleanup.

Referenced by wrap_hook().

kick_it()

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

static

Definition at line 2043 of file bridge.c.

{
    ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
}

References ast_bridge_channel_kick(), and AST_CAUSE_NORMAL_CLEARING.

Referenced by ast_bridge_kick(), and handle_bridge_kick_channel().

manager_bridge_tech_list()

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

static

Definition at line 5530 of file bridge.c.

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

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().

manager_bridge_tech_suspend()

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

static

Definition at line 5520 of file bridge.c.

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

References handle_manager_bridge_tech_suspend().

Referenced by ast_bridging_init().

manager_bridge_tech_unsuspend()

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

static

Definition at line 5525 of file bridge.c.

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

References handle_manager_bridge_tech_suspend().

Referenced by ast_bridging_init().

merge_container_cb()

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

static

Callback for merging hook ao2_containers.

Definition at line 3631 of file bridge.c.

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

References ao2_link.

Referenced by ast_bridge_features_merge().

optimize_lock_chan_stack()

static struct ast_bridge * optimize_lock_chan_stack ( struct ast_channel *  chan )

static

Definition at line 2648 of file bridge.c.

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

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_allows_optimization(), bridge_channel_internal_allows_optimization(), BRIDGE_CHANNEL_STATE_WAIT, BRIDGE_CHANNEL_THREAD_SIMPLE, ast_bridge_channel::chan, NULL, and ast_bridge_channel::state.

Referenced by ast_bridge_unreal_optimize_out().

optimize_lock_peer_stack()

static struct ast_bridge * optimize_lock_peer_stack ( struct ast_channel *  peer )

static

Definition at line 2693 of file bridge.c.

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

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_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().

set_bridge_peer_vars()

static void set_bridge_peer_vars ( struct ast_bridge *  bridge )

static

Definition at line 1455 of file bridge.c.

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

References AST_BRIDGE_CAPABILITY_HOLDING, AST_LIST_FIRST, AST_LIST_LAST, ast_bridge_channel::bridge, 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().

set_bridge_peer_vars_2party()

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

static

Definition at line 1300 of file bridge.c.

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

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

Referenced by set_bridge_peer_vars().

set_bridge_peer_vars_holding()

static void set_bridge_peer_vars_holding ( struct ast_bridge *  bridge )

static

Definition at line 1435 of file bridge.c.

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

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

Referenced by set_bridge_peer_vars().

set_bridge_peer_vars_multiparty()

static void set_bridge_peer_vars_multiparty ( struct ast_bridge *  bridge )

static

Definition at line 1375 of file bridge.c.

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

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

Referenced by set_bridge_peer_vars().

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 4452 of file bridge.c.

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

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, channels, pbx_builtin_getvar_helper(), and S_OR.

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

smart_bridge_operation()

static int smart_bridge_operation ( struct ast_bridge *  bridge )

static

Definition at line 1041 of file bridge.c.

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

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::name, ast_bridge_technology::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().

tech_capability2str()

static const char * tech_capability2str ( uint32_t  capabilities )

static

Bridge technology capabilities to string.

Definition at line 5347 of file bridge.c.

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

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().

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 2938 of file bridge.c.

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

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().

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 4395 of file bridge.c.

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

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(), voicemailpwcheck::context, ast_channel::exten, NULL, and RAII_VAR.

Referenced by ast_bridge_transfer_blind().

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 2814 of file bridge.c.

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

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().

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 4680 of file bridge.c.

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

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().

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 3652 of file bridge.c.

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

References ao2_bump, ast_bridge_interval_hook(), ast_bridge_hook::callback, ast_bridge_hook_timer_parms::flags, ast_flags::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().

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 988 of file bridge.c.

Referenced by ast_bridge_base_new(), 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 1601 of file bridge.c.

Referenced by bridge_channel_impart_add(), and bridge_channel_impart_signal().

bridge_cli

struct ast_cli_entry bridge_cli[]

static

Definition at line 5474 of file bridge.c.

Referenced by ast_bridging_init(), and bridge_cleanup().

bridge_init_lock

ast_mutex_t bridge_init_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 136 of file bridge.c.

Referenced by bridge_base_init(), and bridge_register().

bridge_manager

struct bridge_manager_controller* bridge_manager

static

Bridge manager controller.

Definition at line 183 of file bridge.c.

Referenced by ast_bridging_init(), bridge_cleanup(), and bridge_manager_service_req().

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 132 of file bridge.c.

Referenced by app_to_json(), ast_ari_bridges_list(), ast_bridge_find_by_id(), ast_bridges(), ast_bridging_init(), bridge_base_dissolving(), bridge_cleanup(), bridge_register(), bridges_scrape_cb(), complete_bridge_live(), handle_bridge_show_all(), 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 155 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 158 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 161 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 138 of file bridge.c.

Referenced by try_merge_optimize_out(), and try_swap_optimize_out().