bridge_channel.c File Reference

Bridging Channel API. More...

#include "asterisk.h"
#include <signal.h>
#include "asterisk/heap.h"
#include "asterisk/alertpipe.h"
#include "asterisk/astobj2.h"
#include "asterisk/stringfields.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"
#include "asterisk/channel.h"
#include "asterisk/timing.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_channel.h"
#include "asterisk/bridge_after.h"
#include "asterisk/bridge_channel_internal.h"
#include "asterisk/bridge_internal.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/musiconhold.h"
#include "asterisk/features_config.h"
#include "asterisk/parking.h"
#include "asterisk/causes.h"
#include "asterisk/test.h"
#include "asterisk/sem.h"
#include "asterisk/stream.h"
#include "asterisk/message.h"
#include "asterisk/core_local.h"

Include dependency graph for bridge_channel.c:

Go to the source code of this file.

Data Structures
struct	blind_transfer_data
	Data specifying where a blind transfer is going to. More...
struct	bridge_custom_callback
struct	bridge_park
struct	bridge_playfile
struct	bridge_run_app
struct	bridge_sync
	Synchronous bridge action object. More...
struct	sync_payload
	Frame payload for synchronous bridge actions. More...
struct	sync_structs
	List holding active synchronous action objects. More...

Macros
#define	PLAYBACK_TIMEOUT   (600 * 1000)
	Failsafe for synchronous bridge action waiting. More...

Typedefs
typedef int(*	ast_bridge_channel_post_action_data) (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
	Used to queue an action frame onto a bridge channel and write an action frame into a bridge. More...

Functions
static void	after_bridge_move_channel (struct ast_channel *chan_bridged, void *data)
static void	after_bridge_move_channel_fail (enum ast_bridge_after_cb_reason reason, void *data)
void	ast_bridge_channel_feature_digit (struct ast_bridge_channel *bridge_channel, int digit)
	Add a DTMF digit to the collected digits to match against DTMF features. More...
void	ast_bridge_channel_feature_digit_add (struct ast_bridge_channel *bridge_channel, int digit)
	Add a DTMF digit to the collected digits. More...
struct ast_channel *	ast_bridge_channel_get_chan (struct ast_bridge_channel *bridge_channel)
	Get a ref to the bridge_channel's ast_channel. More...
void	ast_bridge_channel_kick (struct ast_bridge_channel *bridge_channel, int cause)
	Kick the channel out of the bridge. More...
void	ast_bridge_channel_leave_bridge (struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
	Set bridge channel state to leave bridge (if not leaving already). More...
void	ast_bridge_channel_leave_bridge_nolock (struct ast_bridge_channel *bridge_channel, enum bridge_channel_state new_state, int cause)
	Set bridge channel state to leave bridge (if not leaving already). More...
void	ast_bridge_channel_lock_bridge (struct ast_bridge_channel *bridge_channel)
	Lock the bridge associated with the bridge channel. More...
struct ast_bridge *	ast_bridge_channel_merge_inhibit (struct ast_bridge_channel *bridge_channel, int request)
	Adjust the bridge_channel's bridge merge inhibit request count. More...
int	ast_bridge_channel_notify_talking (struct ast_bridge_channel *bridge_channel, int started_talking)
	Lets the bridging indicate when a bridge channel has stopped or started talking. More...
struct ast_bridge_channel *	ast_bridge_channel_peer (struct ast_bridge_channel *bridge_channel)
	Get the peer bridge channel of a two party bridge. More...
void	ast_bridge_channel_playfile (struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
	Play a file on the bridge channel. More...
int	ast_bridge_channel_queue_app (struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
	Queue a bridge action run application frame onto the bridge channel. More...
int	ast_bridge_channel_queue_callback (struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
	Queue a bridge action custom callback frame onto the bridge channel. More...
int	ast_bridge_channel_queue_control_data (struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
	Queue a control frame onto the bridge channel with data. More...
int	ast_bridge_channel_queue_frame (struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
	Write a frame to the specified bridge_channel. More...
int	ast_bridge_channel_queue_playfile (struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
	Queue a bridge action play file frame onto the bridge channel. More...
int	ast_bridge_channel_queue_playfile_sync (struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
	Synchronously queue a bridge action play file frame onto the bridge channel. More...
void	ast_bridge_channel_restore_formats (struct ast_bridge_channel *bridge_channel)
	Restore the formats of a bridge channel's channel to how they were before bridge_channel_internal_join. More...
void	ast_bridge_channel_run_app (struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
	Run an application on the bridge channel. More...
void	ast_bridge_channel_stream_map (struct ast_bridge_channel *bridge_channel)
	Maps a channel's stream topology to and from the bridge. More...
void	ast_bridge_channel_update_accountcodes (struct ast_bridge_channel *joining, struct ast_bridge_channel *leaving)
void	ast_bridge_channel_update_linkedids (struct ast_bridge_channel *bridge_channel, struct ast_bridge_channel *swap)
int	ast_bridge_channel_write_app (struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
	Write a bridge action run application frame into the bridge. More...
int	ast_bridge_channel_write_callback (struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
	Write a bridge action custom callback frame into the bridge. More...
int	ast_bridge_channel_write_control_data (struct ast_bridge_channel *bridge_channel, enum ast_control_frame_type control, const void *data, size_t datalen)
	Write a control frame into the bridge with data. More...
int	ast_bridge_channel_write_hold (struct ast_bridge_channel *bridge_channel, const char *moh_class)
	Write a hold frame into the bridge. More...
int	ast_bridge_channel_write_park (struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
	Have a bridge channel park a channel in the bridge. More...
int	ast_bridge_channel_write_playfile (struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
	Write a bridge action play file frame into the bridge. More...
int	ast_bridge_channel_write_unhold (struct ast_bridge_channel *bridge_channel)
	Write an unhold frame into the bridge. More...
int	ast_bridge_queue_everyone_else (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
	Queue the given frame to everyone else. More...
static void	bridge_channel_attended_transfer (struct ast_bridge_channel *bridge_channel, const char *target_chan_name)
static void	bridge_channel_blind_transfer (struct ast_bridge_channel *bridge_channel, struct blind_transfer_data *blind_data)
static void	bridge_channel_cancel_owed_events (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_destroy (void *obj)
static void	bridge_channel_dissolve_check (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_do_callback (struct ast_bridge_channel *bridge_channel, struct bridge_custom_callback *data)
static void	bridge_channel_dtmf_stream (struct ast_bridge_channel *bridge_channel, const char *dtmf)
static void	bridge_channel_event_join_leave (struct ast_bridge_channel *bridge_channel, enum ast_bridge_hook_type type)
static int	bridge_channel_feature_digit_add (struct ast_bridge_channel *bridge_channel, int digit, size_t dtmf_len)
static unsigned int	bridge_channel_feature_digit_timeout (struct ast_bridge_channel *bridge_channel)
static int	bridge_channel_feature_timeout (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_handle_action (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, void *data)
static void	bridge_channel_handle_control (struct ast_bridge_channel *bridge_channel, struct ast_frame *fr)
static void	bridge_channel_handle_feature_timeout (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_handle_interval (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_handle_write (struct ast_bridge_channel *bridge_channel)
struct ast_bridge_channel *	bridge_channel_internal_alloc (struct ast_bridge *bridge)
int	bridge_channel_internal_allows_optimization (struct ast_bridge_channel *bridge_channel)
int	bridge_channel_internal_join (struct ast_bridge_channel *bridge_channel)
void	bridge_channel_internal_pull (struct ast_bridge_channel *bridge_channel)
int	bridge_channel_internal_push (struct ast_bridge_channel *bridge_channel)
int	bridge_channel_internal_push_full (struct ast_bridge_channel *bridge_channel, int optimized)
int	bridge_channel_internal_queue_attended_transfer (struct ast_channel *transferee, struct ast_channel *unbridged_chan)
int	bridge_channel_internal_queue_blind_transfer (struct ast_channel *transferee, const char *exten, const char *context, transfer_channel_cb new_channel_cb, void *user_data)
void	bridge_channel_internal_suspend_nolock (struct ast_bridge_channel *bridge_channel)
void	bridge_channel_internal_unsuspend_nolock (struct ast_bridge_channel *bridge_channel)
static int	bridge_channel_next_interval (struct ast_bridge_channel *bridge_channel)
static int	bridge_channel_next_timeout (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_park (struct ast_bridge_channel *bridge_channel, struct bridge_park *payload)
static void	bridge_channel_playfile (struct ast_bridge_channel *bridge_channel, struct bridge_playfile *payload)
static void	bridge_channel_poke (struct ast_bridge_channel *bridge_channel)
static int	bridge_channel_queue_action_data (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
static int	bridge_channel_queue_action_data_sync (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
void	bridge_channel_queue_deferred_frames (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_run_app (struct ast_bridge_channel *bridge_channel, struct bridge_run_app *data)
void	bridge_channel_settle_owed_events (struct ast_bridge *orig_bridge, struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_suspend (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_talking (struct ast_bridge_channel *bridge_channel, int talking)
static void	bridge_channel_unsuspend (struct ast_bridge_channel *bridge_channel)
static void	bridge_channel_update_accountcodes_joining (struct ast_bridge_channel *joining, struct ast_bridge_channel *swap)
static void	bridge_channel_update_accountcodes_leaving (struct ast_bridge_channel *leaving)
static void	bridge_channel_wait (struct ast_bridge_channel *bridge_channel)
static int	bridge_channel_write_action_data (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)
static int	bridge_channel_write_dtmf_stream (struct ast_bridge_channel *bridge_channel, const char *dtmf)
static int	bridge_channel_write_frame (struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static void	bridge_frame_free (struct ast_frame *frame)
static struct ast_frame *	bridge_handle_dtmf (struct ast_bridge_channel *bridge_channel, struct ast_frame *frame)
static void	bridge_handle_trip (struct ast_bridge_channel *bridge_channel)
static void	bridge_sync_cleanup (struct bridge_sync *sync_struct)
	Clean up a synchronization bridge object. More...
static void	bridge_sync_init (struct bridge_sync *sync_struct, unsigned int id)
	Initialize a synchronous bridge object. More...
static void	bridge_sync_signal (struct bridge_sync *sync_struct)
	Signal that waiting for a synchronous bridge action is no longer necessary. More...
static void	bridge_sync_wait (struct bridge_sync *sync_struct)
	Wait for a synchronous bridge action to complete. More...
static void	channel_fill_empty_accountcode (struct ast_channel *dest, struct ast_channel *src)
static void	channel_fill_empty_peeraccount (struct ast_channel *dest, struct ast_channel *src)
static int	channel_set_cause (struct ast_channel *chan, int cause)
static void	channel_set_empty_accountcodes (struct ast_channel *c0, struct ast_channel *c1)
static void	channel_update_peeraccount (struct ast_channel *dest, struct ast_channel *src)
static void	channel_update_peeraccounts (struct ast_channel *c0, struct ast_channel *c1)
static int	payload_helper_app (ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, const char *app_name, const char *app_args, const char *moh_class)
static int	payload_helper_cb (ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_custom_callback_option flags, ast_bridge_custom_callback_fn callback, const void *payload, size_t payload_size)
static int	payload_helper_park (ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, const char *parkee_uuid, const char *parker_uuid, const char *app_data)
static int	payload_helper_playfile (ast_bridge_channel_post_action_data post_it, struct ast_bridge_channel *bridge_channel, ast_bridge_custom_play_fn custom_play, const char *playfile, const char *moh_class)
static int	run_app_helper (struct ast_channel *chan, const char *app_name, const char *app_args)
static void	sendtext_safe (struct ast_channel *chan, const struct ast_frame *f)
static void	testsuite_notify_feature_success (struct ast_channel *chan, const char *dtmf)

Variables
static const char *	controls []
static int	sync_ids
	Counter used for assigning synchronous bridge action IDs. More...
static struct sync_structs	sync_structs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

Detailed Description

Bridging Channel API.

Author

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

Richard Mudgett rmudg.nosp@m.ett@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Matt Jordan mjord.nosp@m.an@d.nosp@m.igium.nosp@m..com

Definition in file bridge_channel.c.

Macro Definition Documentation

PLAYBACK_TIMEOUT

#define PLAYBACK_TIMEOUT   (600 * 1000)

Failsafe for synchronous bridge action waiting.

When waiting for a synchronous bridge action to complete, if there is a frame resource leak somewhere, it is possible that we will never get notified that the synchronous action completed.

If a significant amount of time passes, then we will abandon waiting for the synchrnous bridge action to complete.

This constant represents the number of milliseconds we will wait for the bridge action to complete.

Definition at line 179 of file bridge_channel.c.

Typedef Documentation

ast_bridge_channel_post_action_data

typedef int(* ast_bridge_channel_post_action_data) (struct ast_bridge_channel *bridge_channel, enum bridge_channel_action_type action, const void *data, size_t datalen)

Used to queue an action frame onto a bridge channel and write an action frame into a bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel work with.
action	Type of bridge action frame.
data	Frame payload data to pass.
datalen	Frame payload data length to pass.

Return values

0	on success.
-1	on error.

Definition at line 74 of file bridge_channel.c.

Function Documentation

after_bridge_move_channel()

static void after_bridge_move_channel ( struct ast_channel *  chan_bridged, void *  data  )

static

Definition at line 1887 of file bridge_channel.c.

{
    RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
    struct ast_party_connected_line connected_target;
    unsigned char connected_line_data[1024];
    int payload_size;
 
    ast_party_connected_line_init(&connected_target);
 
    ast_channel_lock(chan_target);
    ast_party_connected_line_copy(&connected_target, ast_channel_connected(chan_target));
    ast_channel_unlock(chan_target);
    ast_party_id_reset(&connected_target.priv);
 
    if (ast_channel_move(chan_target, chan_bridged)) {
        ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
        ast_party_connected_line_free(&connected_target);
        return;
    }
 
    /* The ast_channel_move function will end up updating the connected line information
     * on chan_target to the value we have here, but will not inform it. To ensure that
     * AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO is executed we wipe it away here. If
     * we don't do this then the change will be considered redundant, since the connected
     * line information is already there (despite the channel not being told).
     */
    ast_channel_lock(chan_target);
    ast_party_connected_line_free(ast_channel_connected_indicated(chan_target));
    ast_party_connected_line_init(ast_channel_connected_indicated(chan_target));
    ast_channel_unlock(chan_target);
 
    if ((payload_size = ast_connected_line_build_data(connected_line_data,
        sizeof(connected_line_data), &connected_target, NULL)) != -1) {
        struct ast_control_read_action_payload *frame_payload;
        int frame_size;
 
        frame_size = payload_size + sizeof(*frame_payload);
        frame_payload = ast_alloca(frame_size);
        frame_payload->action = AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO;
        frame_payload->payload_size = payload_size;
        memcpy(frame_payload->payload, connected_line_data, payload_size);
        ast_queue_control_data(chan_target, AST_CONTROL_READ_ACTION, frame_payload, frame_size);
    }
 
    /* A connected line update is queued so that if chan_target is remotely involved with
     * anything (such as dialing a channel) the other channel(s) will be informed of the
     * new channel they are involved with.
     */
    ast_channel_lock(chan_target);
    ast_connected_line_copy_from_caller(&connected_target, ast_channel_caller(chan_target));
    ast_channel_queue_connected_line_update(chan_target, &connected_target, NULL);
    ast_channel_unlock(chan_target);
 
    ast_party_connected_line_free(&connected_target);
}

References ast_control_read_action_payload::action, ao2_cleanup, ast_alloca, ast_channel_caller(), ast_channel_connected(), ast_channel_connected_indicated(), ast_channel_lock, ast_channel_move(), ast_channel_queue_connected_line_update(), ast_channel_unlock, ast_connected_line_build_data(), ast_connected_line_copy_from_caller(), AST_CONTROL_READ_ACTION, AST_FRAME_READ_ACTION_CONNECTED_LINE_MACRO, ast_party_connected_line_copy(), ast_party_connected_line_free(), ast_party_connected_line_init(), ast_party_id_reset(), ast_queue_control_data(), ast_softhangup(), AST_SOFTHANGUP_DEV, frame_size, NULL, ast_control_read_action_payload::payload, ast_control_read_action_payload::payload_size, ast_party_connected_line::priv, and RAII_VAR.

Referenced by bridge_channel_attended_transfer().

after_bridge_move_channel_fail()

static void after_bridge_move_channel_fail ( enum ast_bridge_after_cb_reason  reason, void *  data  )

static

Definition at line 1947 of file bridge_channel.c.

{
    RAII_VAR(struct ast_channel *, chan_target, data, ao2_cleanup);
 
    ast_log(LOG_WARNING, "Unable to complete transfer: %s\n",
        ast_bridge_after_cb_reason_string(reason));
    ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
}

References ao2_cleanup, ast_bridge_after_cb_reason_string(), ast_log, ast_softhangup(), AST_SOFTHANGUP_DEV, LOG_WARNING, and RAII_VAR.

Referenced by bridge_channel_attended_transfer().

ast_bridge_channel_feature_digit()

void ast_bridge_channel_feature_digit	(	struct ast_bridge_channel *	bridge_channel,
		int	digit
	)

Add a DTMF digit to the collected digits to match against DTMF features.

Since

12.8.0

Parameters

bridge_channel	Channel that received a DTMF digit.
digit	DTMF digit to add to collected digits or 0 for timeout event.

Note

Neither the bridge nor the bridge_channel locks should be held when entering this function.

This is intended to be called by bridge hooks and the bridge channel thread.

This is intended to be called by non-DTMF bridge hooks and the bridge channel thread. Calling from a DTMF bridge hook can potentially cause unbounded recursion.

Definition at line 1705 of file bridge_channel.c.

{
    struct ast_bridge_features *features = bridge_channel->features;
    struct ast_bridge_hook_dtmf *hook = NULL;
    size_t dtmf_len;
 
    struct sanity_check_of_dtmf_size {
        char check[1 / (ARRAY_LEN(bridge_channel->dtmf_hook_state.collected) == ARRAY_LEN(hook->dtmf.code))];
    };
 
    dtmf_len = strlen(bridge_channel->dtmf_hook_state.collected);
    if (!dtmf_len && !digit) {
        /* Nothing to do */
        return;
    }
 
    if (digit) {
        dtmf_len = bridge_channel_feature_digit_add(bridge_channel, digit, dtmf_len);
    }
 
    while (digit) {
        /* See if a DTMF feature hook matches or can match */
        hook = ao2_find(features->dtmf_hooks, bridge_channel->dtmf_hook_state.collected,
            OBJ_SEARCH_PARTIAL_KEY);
        if (!hook) {
            ast_debug(1, "No DTMF feature hooks on %p(%s) match '%s'\n",
                bridge_channel, ast_channel_name(bridge_channel->chan),
                bridge_channel->dtmf_hook_state.collected);
            break;
        } else if (dtmf_len != strlen(hook->dtmf.code)) {
            unsigned int digit_timeout;
            /* Need more digits to match */
            ao2_ref(hook, -1);
            digit_timeout = bridge_channel_feature_digit_timeout(bridge_channel);
            bridge_channel->dtmf_hook_state.interdigit_timeout =
                ast_tvadd(ast_tvnow(), ast_samp2tv(digit_timeout, 1000));
            return;
        } else {
            int remove_me;
            int already_suspended;
 
            ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on %p(%s)\n",
                hook, bridge_channel->dtmf_hook_state.collected, bridge_channel,
                ast_channel_name(bridge_channel->chan));
 
            /*
             * Clear the collected digits before executing the hook
             * in case the hook starts another sequence.
             */
            bridge_channel->dtmf_hook_state.collected[0] = '\0';
 
            ast_bridge_channel_lock_bridge(bridge_channel);
            already_suspended = bridge_channel->suspended;
            if (!already_suspended) {
                bridge_channel_internal_suspend_nolock(bridge_channel);
            }
            ast_bridge_unlock(bridge_channel->bridge);
            ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
 
            /* Execute the matched hook on this channel. */
            remove_me = hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
            if (remove_me) {
                ast_debug(1, "DTMF hook %p is being removed from %p(%s)\n",
                    hook, bridge_channel, ast_channel_name(bridge_channel->chan));
                ao2_unlink(features->dtmf_hooks, hook);
            }
            testsuite_notify_feature_success(bridge_channel->chan, hook->dtmf.code);
            ao2_ref(hook, -1);
 
            ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
            if (!already_suspended) {
                bridge_channel_unsuspend(bridge_channel);
            }
 
            /*
             * If we are handing the channel off to an external hook for
             * ownership, we are not guaranteed what kind of state it will
             * come back in.  If the channel hungup, we need to detect that
             * here if the hook did not already change the state.
             */
            if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
                ast_bridge_channel_kick(bridge_channel, 0);
                bridge_channel->dtmf_hook_state.collected[0] = '\0';
                return;
            }
 
            /* if there is dtmf that has been collected then loop back through,
               but set digit to -1 so it doesn't try to do an add since the dtmf
               is already in the buffer */
            dtmf_len = strlen(bridge_channel->dtmf_hook_state.collected);
            if (!dtmf_len) {
                return;
            }
        }
    }
 
    if (!digit) {
        ast_debug(1, "DTMF feature string collection on %p(%s) timed out\n",
            bridge_channel, ast_channel_name(bridge_channel->chan));
    }
 
    /* Timeout or DTMF digit didn't allow a match with any hooks. */
    if (features->dtmf_passthrough) {
        /* Stream the collected DTMF to the other channels. */
        bridge_channel_write_dtmf_stream(bridge_channel,
            bridge_channel->dtmf_hook_state.collected);
    }
    bridge_channel->dtmf_hook_state.collected[0] = '\0';
 
    ast_test_suite_event_notify("FEATURE_DETECTION", "Result: fail");
}

References ao2_find, ao2_ref, ao2_unlink, ARRAY_LEN, ast_bridge_channel_kick(), ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_channel_name(), ast_check_hangup_locked(), AST_CONTROL_SRCUPDATE, ast_debug, ast_indicate(), ast_samp2tv(), ast_test_suite_event_notify, ast_tvadd(), ast_tvnow(), ast_bridge_channel::bridge, bridge_channel_feature_digit_add(), bridge_channel_feature_digit_timeout(), bridge_channel_internal_suspend_nolock(), bridge_channel_unsuspend(), bridge_channel_write_dtmf_stream(), ast_bridge_hook::callback, ast_bridge_channel::chan, ast_bridge_hook_dtmf_parms::code, ast_bridge_channel::collected, digit, ast_bridge_hook_dtmf::dtmf, ast_bridge_channel::dtmf_hook_state, ast_bridge_features::dtmf_hooks, ast_bridge_features::dtmf_passthrough, ast_bridge_channel::features, ast_bridge_hook_dtmf::generic, ast_bridge_hook::hook_pvt, ast_bridge_channel::interdigit_timeout, NULL, OBJ_SEARCH_PARTIAL_KEY, ast_bridge_channel::suspended, and testsuite_notify_feature_success().

Referenced by agent_alert(), bridge_channel_handle_feature_timeout(), bridge_channel_internal_join(), and bridge_handle_dtmf().

ast_bridge_channel_feature_digit_add()

void ast_bridge_channel_feature_digit_add	(	struct ast_bridge_channel *	bridge_channel,
		int	digit
	)

Add a DTMF digit to the collected digits.

Since

13.3.0

Parameters

bridge_channel	Channel that received a DTMF digit.
digit	DTMF digit to add to collected digits

Note

Neither the bridge nor the bridge_channel locks should be held when entering this function.

This is can only be called from within DTMF bridge hooks.

Definition at line 1697 of file bridge_channel.c.

{
    if (digit) {
        bridge_channel_feature_digit_add(
            bridge_channel, digit, strlen(bridge_channel->dtmf_hook_state.collected));
    }
}

References bridge_channel_feature_digit_add(), ast_bridge_channel::collected, digit, and ast_bridge_channel::dtmf_hook_state.

Referenced by play_file().

ast_bridge_channel_get_chan()

struct ast_channel * ast_bridge_channel_get_chan

(

struct ast_bridge_channel *

bridge_channel

)

Get a ref to the bridge_channel's ast_channel.

Parameters

bridge_channel

The bridge channel

Note

The returned channel NEEDS to be unref'd once you are done with it. In general, this function is best used when accessing the bridge_channel chan from outside of a bridging thread.

Return values

ref'd	ast_channel on success
NULL	otherwise

Definition at line 212 of file bridge_channel.c.

{
    struct ast_channel *chan;
 
    ao2_lock(bridge_channel);
    chan = ao2_bump(bridge_channel->chan);
    ao2_unlock(bridge_channel);
 
    return chan;
}

References ao2_bump, ao2_lock, ao2_unlock, ast_channel::bridge_channel, and ast_bridge_channel::chan.

Referenced by ast_bridge_channel_write_unhold().

ast_bridge_channel_kick()

void ast_bridge_channel_kick	(	struct ast_bridge_channel *	bridge_channel,
		int	cause
	)

Kick the channel out of the bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel is being kicked or hungup.
cause	Cause of channel being kicked. If cause <= 0 then use cause on channel if cause still <= 0 use AST_CAUSE_NORMAL_CLEARING.

Note

This is intended to be called by bridge hooks and the bridge channel thread.

Definition at line 602 of file bridge_channel.c.

{
    struct ast_bridge_features *features = bridge_channel->features;
    struct ast_bridge_hook *hook;
    struct ao2_iterator iter;
 
    ast_bridge_channel_lock(bridge_channel);
    if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
        channel_set_cause(bridge_channel->chan, cause);
        cause = 0;
    }
    ast_bridge_channel_unlock(bridge_channel);
 
    /* Run any hangup hooks. */
    iter = ao2_iterator_init(features->other_hooks, 0);
    for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
        int remove_me;
 
        if (hook->type != AST_BRIDGE_HOOK_TYPE_HANGUP) {
            continue;
        }
        remove_me = hook->callback(bridge_channel, hook->hook_pvt);
        if (remove_me) {
            ast_debug(1, "Hangup hook %p is being removed from %p(%s)\n",
                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
            ao2_unlink(features->other_hooks, hook);
        }
    }
    ao2_iterator_destroy(&iter);
 
    /* Default hangup action. */
    ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, cause);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ao2_unlink, ast_bridge_channel_leave_bridge(), ast_bridge_channel_lock, ast_bridge_channel_unlock, AST_BRIDGE_HOOK_TYPE_HANGUP, ast_channel_name(), ast_debug, BRIDGE_CHANNEL_STATE_END, BRIDGE_CHANNEL_STATE_WAIT, ast_bridge_hook::callback, ast_bridge_channel::chan, channel_set_cause(), ast_bridge_channel::features, ast_bridge_hook::hook_pvt, ast_bridge_features::other_hooks, ast_bridge_channel::state, and ast_bridge_hook::type.

Referenced by ast_bridge_channel_feature_digit(), ast_bridge_channel_run_app(), bridge_channel_attended_transfer(), bridge_channel_blind_transfer(), bridge_channel_handle_action(), bridge_channel_internal_join(), bridge_handle_trip(), and kick_it().

ast_bridge_channel_leave_bridge()

void ast_bridge_channel_leave_bridge	(	struct ast_bridge_channel *	bridge_channel,
		enum bridge_channel_state	new_state,
		int	cause
	)

Set bridge channel state to leave bridge (if not leaving already).

Parameters

bridge_channel	Channel to change the state on
new_state	The new state to place the channel into
cause	Cause of channel leaving bridge. If cause <= 0 then use cause on channel if cause still <= 0 use AST_CAUSE_NORMAL_CLEARING.

Example usage:

ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, AST_CAUSE_NORMAL_CLEARING);

This places the channel pointed to by bridge_channel into the state BRIDGE_CHANNEL_STATE_END if it was BRIDGE_CHANNEL_STATE_WAIT before.

Definition at line 325 of file bridge_channel.c.

{
    ast_bridge_channel_lock(bridge_channel);
    ast_bridge_channel_leave_bridge_nolock(bridge_channel, new_state, cause);
    ast_bridge_channel_unlock(bridge_channel);
}

References ast_bridge_channel_leave_bridge_nolock(), ast_bridge_channel_lock, and ast_bridge_channel_unlock.

Referenced by agent_connect_caller(), ast_bridge_channel_kick(), ast_bridge_depart(), ast_bridge_remove(), basic_hangup_hook(), bridge_agent_hold_heartbeat(), bridge_agent_hold_push(), bridge_channel_complete_join(), bridge_channel_dissolve_check(), bridge_channel_internal_push_full(), bridge_dissolve(), bridge_do_merge(), bridge_do_move(), bridge_features_duration_callback(), bridge_swap_attended_transfer(), bridgewait_timeout_callback(), caller_joined_bridge(), caller_safety_timeout(), feature_hangup(), parking_duration_callback(), say_parking_space(), set_softmix_bridge_data(), try_swap_optimize_out(), and user_timeout().

ast_bridge_channel_leave_bridge_nolock()

void ast_bridge_channel_leave_bridge_nolock	(	struct ast_bridge_channel *	bridge_channel,
		enum bridge_channel_state	new_state,
		int	cause
	)

Set bridge channel state to leave bridge (if not leaving already).

Parameters

bridge_channel	Channel to change the state on
new_state	The new state to place the channel into
cause	Cause of channel leaving bridge. If cause <= 0 then use cause on channel if cause still <= 0 use AST_CAUSE_NORMAL_CLEARING.

Example usage:

ast_bridge_channel_leave_bridge(bridge_channel, BRIDGE_CHANNEL_STATE_END, AST_CAUSE_NORMAL_CLEARING);

This places the channel pointed to by bridge_channel into the state BRIDGE_CHANNEL_STATE_END if it was BRIDGE_CHANNEL_STATE_WAIT before.

Definition at line 303 of file bridge_channel.c.

{
    if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
        return;
    }
 
    ast_debug(1, "Setting %p(%s) state from:%u to:%u\n",
        bridge_channel, ast_channel_name(bridge_channel->chan), bridge_channel->state,
        new_state);
 
    channel_set_cause(bridge_channel->chan, cause);
 
    ast_channel_lock(bridge_channel->chan);
    ast_bridge_vars_set(bridge_channel->chan, NULL, NULL);
    ast_channel_unlock(bridge_channel->chan);
 
    /* Change the state on the bridge channel */
    bridge_channel->state = new_state;
 
    bridge_channel_poke(bridge_channel);
}

References ast_bridge_vars_set(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, bridge_channel_poke(), BRIDGE_CHANNEL_STATE_WAIT, ast_bridge_channel::chan, channel_set_cause(), NULL, and ast_bridge_channel::state.

Referenced by ast_bridge_channel_leave_bridge(), bridge_do_merge(), and caller_abort_agent().

ast_bridge_channel_lock_bridge()

void ast_bridge_channel_lock_bridge

(

struct ast_bridge_channel *

bridge_channel

)

Lock the bridge associated with the bridge channel.

Since

12.0.0

Parameters

bridge_channel

Channel that wants to lock the bridge.

This is an upstream lock operation. The defined locking order is bridge then bridge_channel.

Note

On entry, neither the bridge nor bridge_channel is locked.

The bridge_channel->bridge pointer changes because of a bridge-merge/channel-move operation between bridges.

Definition at line 223 of file bridge_channel.c.

{
    struct ast_bridge *bridge;
 
    for (;;) {
        /* Safely get the bridge pointer */
        ast_bridge_channel_lock(bridge_channel);
        bridge = bridge_channel->bridge;
        ao2_ref(bridge, +1);
        ast_bridge_channel_unlock(bridge_channel);
 
        /* Lock the bridge and see if it is still the bridge we need to lock. */
        ast_bridge_lock(bridge);
        if (bridge == bridge_channel->bridge) {
            ao2_ref(bridge, -1);
            return;
        }
        ast_bridge_unlock(bridge);
        ao2_ref(bridge, -1);
    }
}

References ao2_ref, ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_bridge_lock, ast_bridge_unlock, and ast_bridge_channel::bridge.

Referenced by action_toggle_binaural(), agent_alert(), ast_bridge_channel_feature_digit(), ast_bridge_channel_merge_inhibit(), ast_bridge_notify_masquerade(), basic_hangup_hook(), bridge_channel_handle_control(), bridge_channel_internal_join(), bridge_channel_suspend(), bridge_channel_unsuspend(), bridge_channel_wait(), bridge_channel_write_frame(), bridge_handle_trip(), check_binaural_position_change(), deferred_action(), feature_automixmonitor(), and parking_blind_transfer_park().

ast_bridge_channel_merge_inhibit()

struct ast_bridge * ast_bridge_channel_merge_inhibit	(	struct ast_bridge_channel *	bridge_channel,
		int	request
	)

Adjust the bridge_channel's bridge merge inhibit request count.

Since

12.0.0

Parameters

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

Note

This API call is meant for internal bridging operations.

Return values

bridge

adjusted merge inhibit with reference count.

Definition at line 380 of file bridge_channel.c.

{
    struct ast_bridge *bridge;
 
    ast_bridge_channel_lock_bridge(bridge_channel);
    bridge = bridge_channel->bridge;
    ao2_ref(bridge, +1);
    bridge_merge_inhibit_nolock(bridge, request);
    ast_bridge_unlock(bridge);
    return bridge;
}

References ao2_ref, ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_bridge_channel::bridge, bridge_merge_inhibit_nolock(), and request().

Referenced by feature_attended_transfer().

ast_bridge_channel_notify_talking()

int ast_bridge_channel_notify_talking	(	struct ast_bridge_channel *	bridge_channel,
		int	started_talking
	)

Lets the bridging indicate when a bridge channel has stopped or started talking.

Note

All DSP functionality on the bridge has been pushed down to the lowest possible layer, which in this case is the specific bridging technology being used. Since it is necessary for the knowledge of which channels are talking to make its way up to the application, this function has been created to allow the bridging technology to communicate that information with the bridging core.

Parameters

bridge_channel	The bridge channel that has either started or stopped talking.
started_talking	set to 1 when this indicates the channel has started talking set to 0 when this indicates the channel has stopped talking.

Return values

0	on success.
-1	on error.

Definition at line 245 of file bridge_channel.c.

{
    struct ast_frame action = {
        .frametype = AST_FRAME_BRIDGE_ACTION,
        .subclass.integer = started_talking
            ? BRIDGE_CHANNEL_ACTION_TALKING_START : BRIDGE_CHANNEL_ACTION_TALKING_STOP,
    };
 
    return ast_bridge_channel_queue_frame(bridge_channel, &action);
}

References ast_bridge_channel_queue_frame(), AST_FRAME_BRIDGE_ACTION, BRIDGE_CHANNEL_ACTION_TALKING_START, BRIDGE_CHANNEL_ACTION_TALKING_STOP, and ast_frame::frametype.

Referenced by clear_talking(), and softmix_bridge_write_voice().

ast_bridge_channel_peer()

struct ast_bridge_channel * ast_bridge_channel_peer

(

struct ast_bridge_channel *

bridge_channel

)

Get the peer bridge channel of a two party bridge.

Since

12.0.0

Parameters

bridge_channel

What to get the peer of.

Note

On entry, bridge_channel->bridge is already locked.

This is an internal bridge function.

Return values

peer	on success.
NULL	no peer channel.

Definition at line 332 of file bridge_channel.c.

{
    struct ast_bridge *bridge = bridge_channel->bridge;
    struct ast_bridge_channel *other = NULL;
 
    if (bridge_channel->in_bridge && bridge->num_channels == 2) {
        AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
            if (other != bridge_channel) {
                break;
            }
        }
    }
 
    return other;
}

References AST_LIST_TRAVERSE, ast_bridge_channel::bridge, ast_bridge::channels, ast_bridge_channel::entry, ast_bridge_channel::in_bridge, NULL, and ast_bridge::num_channels.

Referenced by bridge_reconfigured_connected_line_update(), bridge_swap_attended_transfer(), parking_blind_transfer_park(), and try_swap_optimize_out().

ast_bridge_channel_playfile()

void ast_bridge_channel_playfile	(	struct ast_bridge_channel *	bridge_channel,
		ast_bridge_custom_play_fn	custom_play,
		const char *	playfile,
		const char *	moh_class
	)

Play a file on the bridge channel.

Since

12.0.0

Parameters

bridge_channel	Which channel to play the file on
custom_play	Call this function to play the playfile. (NULL if normal sound file to play)
playfile	Sound filename to play.
moh_class	MOH class to request bridge peers to hear while file is played. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Definition at line 1272 of file bridge_channel.c.

{
    if (moh_class) {
        ast_bridge_channel_write_hold(bridge_channel, moh_class);
    }
    if (custom_play) {
        custom_play(bridge_channel, playfile);
    } else {
        ast_stream_and_wait(bridge_channel->chan, playfile, AST_DIGIT_NONE);
    }
    if (moh_class) {
        ast_bridge_channel_write_unhold(bridge_channel);
    }
 
    /*
     * It may be necessary to resume music on hold after we finish
     * playing the announcement.
     */
    if (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_MOH)) {
        const char *latest_musicclass;
 
        ast_channel_lock(bridge_channel->chan);
        latest_musicclass = ast_strdupa(ast_channel_latest_musicclass(bridge_channel->chan));
        ast_channel_unlock(bridge_channel->chan);
        ast_moh_start(bridge_channel->chan, latest_musicclass, NULL);
    }
}

References ast_bridge_channel_write_hold(), ast_bridge_channel_write_unhold(), ast_channel_flags(), ast_channel_latest_musicclass(), ast_channel_lock, ast_channel_unlock, AST_DIGIT_NONE, AST_FLAG_MOH, ast_moh_start(), ast_strdupa, ast_stream_and_wait(), ast_test_flag, ast_bridge_channel::chan, and NULL.

Referenced by bridge_channel_playfile().

ast_bridge_channel_queue_app()

int ast_bridge_channel_queue_app	(	struct ast_bridge_channel *	bridge_channel,
		const char *	app_name,
		const char *	app_args,
		const char *	moh_class
	)

Queue a bridge action run application frame onto the bridge channel.

Since

12.0.0

Parameters

bridge_channel	Which channel to put the frame onto
app_name	Dialplan application name.
app_args	Arguments for the application. (NULL or empty for no arguments)
moh_class	MOH class to request bridge peers to hear while application is running. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1266 of file bridge_channel.c.

{
    return payload_helper_app(bridge_channel_queue_action_data,
        bridge_channel, app_name, app_args, moh_class);
}

References app_name(), bridge_channel_queue_action_data(), and payload_helper_app().

ast_bridge_channel_queue_callback()

int ast_bridge_channel_queue_callback	(	struct ast_bridge_channel *	bridge_channel,
		enum ast_bridge_channel_custom_callback_option	flags,
		ast_bridge_custom_callback_fn	callback,
		const void *	payload,
		size_t	payload_size
	)

Queue a bridge action custom callback frame onto the bridge channel.

Since

12.0.0

Parameters

bridge_channel	Which channel to put the frame onto.
flags	Custom callback option flags.
callback	Custom callback run on a bridge channel.
payload	Data to pass to the callback. (NULL if none).
payload_size	Size of the payload if payload is non-NULL. A number otherwise.

Note

The payload MUST NOT have any resources that need to be freed.

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1439 of file bridge_channel.c.

{
    return payload_helper_cb(bridge_channel_queue_action_data,
        bridge_channel, flags, callback, payload, payload_size);
}

References bridge_channel_queue_action_data(), callback(), bridge_custom_callback::flags, bridge_custom_callback::payload, payload_helper_cb(), and bridge_custom_callback::payload_size.

Referenced by ast_bridge_kick(), defer_action(), handle_bridge_kick_channel(), and send_alert_to_agent().

ast_bridge_channel_queue_control_data()

int ast_bridge_channel_queue_control_data	(	struct ast_bridge_channel *	bridge_channel,
		enum ast_control_frame_type	control,
		const void *	data,
		size_t	datalen
	)

Queue a control frame onto the bridge channel with data.

Since

12.0.0

Parameters

bridge_channel	Which channel to queue the frame onto.
control	Type of control frame.
data	Frame payload data to pass.
datalen	Frame payload data length to pass.

Return values

0	on success.
-1	on error.

Definition at line 1114 of file bridge_channel.c.

{
    struct ast_frame frame = {
        .frametype = AST_FRAME_CONTROL,
        .subclass.integer = control,
        .datalen = datalen,
        .data.ptr = (void *) data,
    };
 
    return ast_bridge_channel_queue_frame(bridge_channel, &frame);
}

References ast_bridge_channel_queue_frame(), AST_FRAME_CONTROL, ast_frame::data, ast_frame::datalen, and ast_frame::frametype.

Referenced by bridge_reconfigured_connected_line_update(), and send_colp_to_agent().

ast_bridge_channel_queue_frame()

int ast_bridge_channel_queue_frame	(	struct ast_bridge_channel *	bridge_channel,
		struct ast_frame *	fr
	)

Write a frame to the specified bridge_channel.

Since

12.0.0

Parameters

bridge_channel	Channel to queue the frame.
fr	Frame to write.

Return values

0	on success.
-1	on error.

Definition at line 1015 of file bridge_channel.c.

{
    struct ast_frame *dup;
 
    if (bridge_channel->suspended
        /* Also defer DTMF frames. */
        && fr->frametype != AST_FRAME_DTMF_BEGIN
        && fr->frametype != AST_FRAME_DTMF_END
        && !ast_is_deferrable_frame(fr)) {
        /* Drop non-deferable frames when suspended. */
        return 0;
    }
    if (fr->frametype == AST_FRAME_NULL) {
        /* "Accept" the frame and discard it. */
        return 0;
    }
 
    if ((fr->frametype == AST_FRAME_VOICE || fr->frametype == AST_FRAME_VIDEO ||
        fr->frametype == AST_FRAME_TEXT || fr->frametype == AST_FRAME_IMAGE ||
        fr->frametype == AST_FRAME_RTCP) && fr->stream_num > -1) {
        int num = -1;
 
        ast_bridge_channel_lock(bridge_channel);
        if (fr->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_channel)) {
            num = AST_VECTOR_GET(&bridge_channel->stream_map.to_channel, fr->stream_num);
        }
        ast_bridge_channel_unlock(bridge_channel);
 
        if (num == -1) {
            /* We don't have a mapped stream so just discard this frame. */
            return 0;
        }
    }
 
    dup = ast_frdup(fr);
    if (!dup) {
        return -1;
    }
 
    ast_bridge_channel_lock(bridge_channel);
    if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
        /* Drop frames on channels leaving the bridge. */
        ast_bridge_channel_unlock(bridge_channel);
        bridge_frame_free(dup);
        return 0;
    }
 
    if ((fr->frametype == AST_FRAME_TEXT || fr->frametype == AST_FRAME_TEXT_DATA) &&
        !bridge_channel->features->text_messaging) {
        /* This channel is not accepting text messages. */
        ast_bridge_channel_unlock(bridge_channel);
        bridge_frame_free(dup);
        return 0;
    }
 
    if (DEBUG_ATLEAST(1)) {
        if (fr->frametype == AST_FRAME_TEXT) {
            ast_log(LOG_DEBUG, "Queuing TEXT frame to '%s': %*.s\n", ast_channel_name(bridge_channel->chan),
                fr->datalen, (char *)fr->data.ptr);
        } else if (fr->frametype == AST_FRAME_TEXT_DATA) {
            struct ast_msg_data *msg = fr->data.ptr;
            ast_log(LOG_DEBUG, "Queueing TEXT_DATA frame from '%s' to '%s:%s': %s\n",
                ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_FROM),
                ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_TO),
                ast_channel_name(bridge_channel->chan),
                ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_BODY));
        }
    }
 
    AST_LIST_INSERT_TAIL(&bridge_channel->wr_queue, dup, frame_list);
    if (ast_alertpipe_write(bridge_channel->alert_pipe)) {
        ast_log(LOG_ERROR, "We couldn't write alert pipe for %p(%s)... something is VERY wrong\n",
            bridge_channel, ast_channel_name(bridge_channel->chan));
    }
    ast_bridge_channel_unlock(bridge_channel);
    return 0;
}

References ast_bridge_channel::alert_pipe, ast_alertpipe_write(), ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_name(), AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_IMAGE, AST_FRAME_NULL, AST_FRAME_RTCP, AST_FRAME_TEXT, AST_FRAME_TEXT_DATA, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup, ast_is_deferrable_frame(), AST_LIST_INSERT_TAIL, ast_log, AST_MSG_DATA_ATTR_BODY, AST_MSG_DATA_ATTR_FROM, AST_MSG_DATA_ATTR_TO, ast_msg_data_get_attribute(), AST_VECTOR_GET, AST_VECTOR_SIZE, BRIDGE_CHANNEL_STATE_WAIT, bridge_frame_free(), ast_bridge_channel::chan, ast_frame::data, ast_frame::datalen, DEBUG_ATLEAST, ast_bridge_channel::features, ast_frame::frametype, LOG_DEBUG, LOG_ERROR, ast_frame::ptr, ast_bridge_channel::state, ast_bridge_channel::stream_map, ast_frame::stream_num, ast_bridge_channel::suspended, ast_bridge_features::text_messaging, ast_bridge_channel::to_channel, and ast_bridge_channel::wr_queue.

Referenced by ast_bridge_channel_notify_talking(), ast_bridge_channel_queue_control_data(), ast_bridge_queue_everyone_else(), bridge_channel_queue_action_data(), bridge_channel_queue_action_data_sync(), remb_send_report(), send_message(), softmix_mixing_loop(), and softmix_pass_video_top_priority().

ast_bridge_channel_queue_playfile()

int ast_bridge_channel_queue_playfile	(	struct ast_bridge_channel *	bridge_channel,
		ast_bridge_custom_play_fn	custom_play,
		const char *	playfile,
		const char *	moh_class
	)

Queue a bridge action play file frame onto the bridge channel.

Since

12.0.0

Parameters

bridge_channel	Which channel to put the frame onto.
custom_play	Call this function to play the playfile. (NULL if normal sound file to play)
playfile	Sound filename to play.
moh_class	MOH class to request bridge peers to hear while file is played. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1353 of file bridge_channel.c.

{
    return payload_helper_playfile(bridge_channel_queue_action_data,
        bridge_channel, custom_play, playfile, moh_class);
}

References bridge_channel_queue_action_data(), bridge_playfile::custom_play, payload_helper_playfile(), and bridge_playfile::playfile.

Referenced by ast_bridge_add_channel(), bridge_parking_pull(), bridge_parking_push(), check_bridge_play_sound(), feature_automixmonitor(), parker_parked_call_message_response(), play_sound(), start_automixmonitor(), and stop_automixmonitor().

ast_bridge_channel_queue_playfile_sync()

int ast_bridge_channel_queue_playfile_sync	(	struct ast_bridge_channel *	bridge_channel,
		ast_bridge_custom_play_fn	custom_play,
		const char *	playfile,
		const char *	moh_class
	)

Synchronously queue a bridge action play file frame onto the bridge channel.

Since

12.2.0

Parameters

bridge_channel	Which channel to put the frame onto.
custom_play	Call this function to play the playfile. (NULL if normal sound file to play)
playfile	Sound filename to play.
moh_class	MOH class to request bridge peers to hear while file is played. NULL if no MOH. Empty if default MOH class.

This function will block until the queued frame has been destroyed. This will happen either if an error occurs or if the queued playback finishes.

Note

No locks may be held when calling this function.

Return values

0	The playback was successfully queued.
-1	The playback could not be queued.

Definition at line 1359 of file bridge_channel.c.

{
    return payload_helper_playfile(bridge_channel_queue_action_data_sync,
        bridge_channel, custom_play, playfile, moh_class);
}

References bridge_channel_queue_action_data_sync(), bridge_playfile::custom_play, payload_helper_playfile(), and bridge_playfile::playfile.

Referenced by parker_parked_call_message_response(), and play_uri().

ast_bridge_channel_restore_formats()

void ast_bridge_channel_restore_formats

(

struct ast_bridge_channel *

bridge_channel

)

Restore the formats of a bridge channel's channel to how they were before bridge_channel_internal_join.

Since

12.0.0

Parameters

bridge_channel

Channel to restore

Definition at line 348 of file bridge_channel.c.

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

References ast_assert, ast_channel_lock, ast_channel_name(), ast_channel_readformat(), ast_channel_unlock, ast_channel_writeformat(), ast_debug, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_name(), ast_set_read_format(), ast_set_write_format(), ast_bridge_channel::chan, NULL, ast_bridge_channel::read_format, and ast_bridge_channel::write_format.

Referenced by bridge_channel_internal_join(), and participant_reaction_announcer_leave().

ast_bridge_channel_run_app()

void ast_bridge_channel_run_app	(	struct ast_bridge_channel *	bridge_channel,
		const char *	app_name,
		const char *	app_args,
		const char *	moh_class
	)

Run an application on the bridge channel.

Since

12.0.0

Parameters

bridge_channel	Which channel to run the application on.
app_name	Dialplan application name.
app_args	Arguments for the application. (NULL tolerant)
moh_class	MOH class to request bridge peers to hear while application is running. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Definition at line 1194 of file bridge_channel.c.

{
    if (moh_class) {
        ast_bridge_channel_write_hold(bridge_channel, moh_class);
    }
    if (run_app_helper(bridge_channel->chan, app_name, S_OR(app_args, ""))) {
        /* Break the bridge if the app returns non-zero. */
        ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
    }
    if (moh_class) {
        ast_bridge_channel_write_unhold(bridge_channel);
    }
}

References app_name(), ast_bridge_channel_kick(), ast_bridge_channel_write_hold(), ast_bridge_channel_write_unhold(), AST_CAUSE_NORMAL_CLEARING, ast_channel::bridge_channel, ast_bridge_channel::chan, run_app_helper(), and S_OR.

Referenced by bridge_channel_run_app(), and dynamic_dtmf_hook_callback().

ast_bridge_channel_stream_map()

void ast_bridge_channel_stream_map

(

struct ast_bridge_channel *

bridge_channel

)

Maps a channel's stream topology to and from the bridge.

Since

15.0.0

When a channel joins a bridge or its associated stream topology is updated, each stream in the topology needs to be mapped according to its media type to the bridge. Calling this method creates a mapping of each stream on the channel indexed to the bridge's supported media types and vice versa (i.e. bridge's media types indexed to channel streams).

The first channel to join the bridge creates the initial order for the bridge's media types (e.g. a one to one mapping is made). Subsequently added channels are mapped to that order adding more media types if/when the newly added channel has more streams and/or media types specified by the bridge.

Parameters

bridge_channel

Channel to map

Note

The bridge_channel's bridge must be locked prior to calling this function.

Definition at line 3129 of file bridge_channel.c.

{
    ast_bridge_channel_lock(bridge_channel);
    ast_channel_lock(bridge_channel->chan);
    ast_stream_topology_map(ast_channel_get_stream_topology(bridge_channel->chan),
        &bridge_channel->bridge->media_types, &bridge_channel->stream_map.to_bridge,
        &bridge_channel->stream_map.to_channel);
    ast_channel_unlock(bridge_channel->chan);
    ast_bridge_channel_unlock(bridge_channel);
}

References ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_get_stream_topology(), ast_channel_lock, ast_channel_unlock, ast_stream_topology_map(), ast_bridge_channel::bridge, ast_bridge_channel::chan, ast_bridge::media_types, ast_bridge_channel::stream_map, ast_bridge_channel::to_bridge, and ast_bridge_channel::to_channel.

Referenced by bridge_channel_complete_join(), bridge_handle_trip(), native_rtp_stream_topology_changed(), simple_bridge_stream_topology_changed(), and softmix_bridge_stream_topology_changed().

ast_bridge_channel_update_accountcodes()

void ast_bridge_channel_update_accountcodes	(	struct ast_bridge_channel *	joining,
		struct ast_bridge_channel *	leaving
	)

Definition at line 593 of file bridge_channel.c.

{
    if (joining) {
        bridge_channel_update_accountcodes_joining(joining, leaving);
    } else {
        bridge_channel_update_accountcodes_leaving(leaving);
    }
}

References bridge_channel_update_accountcodes_joining(), and bridge_channel_update_accountcodes_leaving().

Referenced by bridge_basic_pull(), bridge_basic_push(), bridge_stasis_pull(), and bridge_stasis_push().

ast_bridge_channel_update_linkedids()

void ast_bridge_channel_update_linkedids	(	struct ast_bridge_channel *	bridge_channel,
		struct ast_bridge_channel *	swap
	)

Definition at line 392 of file bridge_channel.c.

{
    struct ast_bridge_channel *other;
    struct ast_bridge *bridge = bridge_channel->bridge;
    struct ast_channel *oldest_linkedid_chan = bridge_channel->chan;
 
    AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
        if (other == swap) {
            continue;
        }
        oldest_linkedid_chan = ast_channel_internal_oldest_linkedid(
            oldest_linkedid_chan, other->chan);
    }
 
    ast_channel_lock(bridge_channel->chan);
    ast_channel_internal_copy_linkedid(bridge_channel->chan, oldest_linkedid_chan);
    ast_channel_unlock(bridge_channel->chan);
    AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
        if (other == swap) {
            continue;
        }
        ast_channel_lock(other->chan);
        ast_channel_internal_copy_linkedid(other->chan, oldest_linkedid_chan);
        ast_channel_unlock(other->chan);
    }
}

References ast_channel_internal_copy_linkedid(), ast_channel_internal_oldest_linkedid(), ast_channel_lock, ast_channel_unlock, AST_LIST_TRAVERSE, ast_bridge_channel::bridge, ast_channel::bridge, ast_channel::bridge_channel, ast_bridge_channel::chan, and ast_bridge::channels.

Referenced by bridge_basic_push(), and bridge_stasis_push().

ast_bridge_channel_write_app()

int ast_bridge_channel_write_app	(	struct ast_bridge_channel *	bridge_channel,
		const char *	app_name,
		const char *	app_args,
		const char *	moh_class
	)

Write a bridge action run application frame into the bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel is putting the frame into the bridge
app_name	Dialplan application name.
app_args	Arguments for the application. (NULL or empty for no arguments)
moh_class	MOH class to request bridge peers to hear while application is running. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1260 of file bridge_channel.c.

{
    return payload_helper_app(bridge_channel_write_action_data,
        bridge_channel, app_name, app_args, moh_class);
}

References app_name(), bridge_channel_write_action_data(), and payload_helper_app().

ast_bridge_channel_write_callback()

int ast_bridge_channel_write_callback	(	struct ast_bridge_channel *	bridge_channel,
		enum ast_bridge_channel_custom_callback_option	flags,
		ast_bridge_custom_callback_fn	callback,
		const void *	payload,
		size_t	payload_size
	)

Write a bridge action custom callback frame into the bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel is putting the frame into the bridge
flags	Custom callback option flags.
callback	Custom callback run on a bridge channel.
payload	Data to pass to the callback. (NULL if none).
payload_size	Size of the payload if payload is non-NULL. A number otherwise.

Note

The payload MUST NOT have any resources that need to be freed.

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1431 of file bridge_channel.c.

{
    return payload_helper_cb(bridge_channel_write_action_data,
        bridge_channel, flags, callback, payload, payload_size);
}

References bridge_channel_write_action_data(), callback(), bridge_custom_callback::flags, bridge_custom_callback::payload, payload_helper_cb(), and bridge_custom_callback::payload_size.

Referenced by agent_connect_caller(), and dynamic_dtmf_hook_trip().

ast_bridge_channel_write_control_data()

int ast_bridge_channel_write_control_data	(	struct ast_bridge_channel *	bridge_channel,
		enum ast_control_frame_type	control,
		const void *	data,
		size_t	datalen
	)

Write a control frame into the bridge with data.

Since

12.0.0

Parameters

bridge_channel	Which channel is putting the frame into the bridge.
control	Type of control frame.
data	Frame payload data to pass.
datalen	Frame payload data length to pass.

Return values

0	on success.
-1	on error.

Definition at line 1126 of file bridge_channel.c.

{
    struct ast_frame frame = {
        .frametype = AST_FRAME_CONTROL,
        .subclass.integer = control,
        .datalen = datalen,
        .data.ptr = (void *) data,
    };
 
    return bridge_channel_write_frame(bridge_channel, &frame);
}

References AST_FRAME_CONTROL, bridge_channel_write_frame(), ast_frame::data, ast_frame::datalen, and ast_frame::frametype.

Referenced by agent_connect_caller(), ast_bridge_channel_write_hold(), ast_bridge_channel_write_unhold(), and ringing().

ast_bridge_channel_write_hold()

int ast_bridge_channel_write_hold	(	struct ast_bridge_channel *	bridge_channel,
		const char *	moh_class
	)

Write a hold frame into the bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel is putting the hold into the bridge.
moh_class	The suggested music class for the other end to use.

Return values

0	on success.
-1	on error.

Definition at line 1138 of file bridge_channel.c.

{
    struct ast_json *blob;
    int res;
    size_t datalen;
 
    if (!ast_strlen_zero(moh_class)) {
        datalen = strlen(moh_class) + 1;
 
        blob = ast_json_pack("{s: s}",
            "musicclass", moh_class);
    } else {
        moh_class = NULL;
        datalen = 0;
        blob = NULL;
    }
 
    ast_channel_publish_cached_blob(bridge_channel->chan, ast_channel_hold_type(), blob);
 
    res = ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_HOLD,
        moh_class, datalen);
 
    ast_json_unref(blob);
    return res;
}

References ast_bridge_channel_write_control_data(), ast_channel_hold_type(), ast_channel_publish_cached_blob(), AST_CONTROL_HOLD, ast_json_pack(), ast_json_unref(), ast_strlen_zero(), ast_bridge_channel::chan, and NULL.

Referenced by ast_bridge_channel_playfile(), ast_bridge_channel_run_app(), feature_attended_transfer(), feature_blind_transfer(), and hold().

ast_bridge_channel_write_park()

int ast_bridge_channel_write_park	(	struct ast_bridge_channel *	bridge_channel,
		const char *	parkee_uuid,
		const char *	parker_uuid,
		const char *	app_data
	)

Have a bridge channel park a channel in the bridge.

Since

12.0.0

Parameters

bridge_channel	Bridge channel performing the parking
parkee_uuid	Unique id of the channel we want to park
parker_uuid	Unique id of the channel parking the call
app_data	string indicating data used for park application (NULL allowed)

Note

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1502 of file bridge_channel.c.

{
    return payload_helper_park(bridge_channel_write_action_data,
        bridge_channel, parkee_uuid, parker_uuid, app_data);
}

References bridge_channel_write_action_data(), bridge_park::parkee_uuid, and payload_helper_park().

Referenced by manager_park_bridged(), and parking_blind_transfer_park().

ast_bridge_channel_write_playfile()

int ast_bridge_channel_write_playfile	(	struct ast_bridge_channel *	bridge_channel,
		ast_bridge_custom_play_fn	custom_play,
		const char *	playfile,
		const char *	moh_class
	)

Write a bridge action play file frame into the bridge.

Since

12.0.0

Parameters

bridge_channel	Which channel is putting the frame into the bridge
custom_play	Call this function to play the playfile. (NULL if normal sound file to play)
playfile	Sound filename to play.
moh_class	MOH class to request bridge peers to hear while file is played. NULL if no MOH. Empty if default MOH class.

Note

This is intended to be called by bridge hooks.

Return values

0	on success.
-1	on error.

Definition at line 1347 of file bridge_channel.c.

{
    return payload_helper_playfile(bridge_channel_write_action_data,
        bridge_channel, custom_play, playfile, moh_class);
}

References bridge_channel_write_action_data(), bridge_playfile::custom_play, payload_helper_playfile(), and bridge_playfile::playfile.

Referenced by ast_bridge_transfer_attended(), start_automixmonitor(), and stop_automixmonitor().

ast_bridge_channel_write_unhold()

int ast_bridge_channel_write_unhold

(

struct ast_bridge_channel *

bridge_channel

)

Write an unhold frame into the bridge.

Since

12.0.0

Parameters

bridge_channel

Which channel is putting the hold into the bridge.

Return values

0	on success.
-1	on error.

Definition at line 1164 of file bridge_channel.c.

{
    struct ast_channel *chan = ast_bridge_channel_get_chan(bridge_channel);
 
    if (!chan) {
        return -1;
    }
 
    ast_channel_publish_cached_blob(chan, ast_channel_unhold_type(), NULL);
    ao2_ref(chan, -1);
 
    return ast_bridge_channel_write_control_data(bridge_channel, AST_CONTROL_UNHOLD, NULL, 0);
}

References ao2_ref, ast_bridge_channel_get_chan(), ast_bridge_channel_write_control_data(), ast_channel_publish_cached_blob(), ast_channel_unhold_type(), AST_CONTROL_UNHOLD, ast_channel::bridge_channel, and NULL.

Referenced by ast_bridge_channel_playfile(), ast_bridge_channel_run_app(), ast_bridge_transfer_attended(), ast_bridge_transfer_blind(), feature_attended_transfer(), feature_blind_transfer(), and unhold().

ast_bridge_queue_everyone_else()

int ast_bridge_queue_everyone_else	(	struct ast_bridge *	bridge,
		struct ast_bridge_channel *	bridge_channel,
		struct ast_frame *	frame
	)

Queue the given frame to everyone else.

Since

12.0.0

Parameters

bridge	What bridge to distribute frame.
bridge_channel	Channel to optionally not pass frame to. (NULL to pass to everyone)
frame	Frame to pass.

Note

This is intended to be called by bridge hooks and bridge technologies.

Return values

0	Frame written to at least one channel.
-1	Frame written to no channels.

Definition at line 1093 of file bridge_channel.c.

{
    struct ast_bridge_channel *cur;
    int not_written = -1;
 
    if (frame->frametype == AST_FRAME_NULL) {
        /* "Accept" the frame and discard it. */
        return 0;
    }
 
    AST_LIST_TRAVERSE(&bridge->channels, cur, entry) {
        if (cur == bridge_channel) {
            continue;
        }
        if (!ast_bridge_channel_queue_frame(cur, frame)) {
            not_written = 0;
        }
    }
    return not_written;
}

References ast_bridge_channel_queue_frame(), AST_FRAME_NULL, AST_LIST_TRAVERSE, ast_bridge_channel::bridge, ast_bridge::channels, ast_bridge_channel::entry, and ast_frame::frametype.

Referenced by ari_bridges_play_new(), bridge_hold(), bridge_ringing(), bridge_unhold(), holding_bridge_write(), native_bridge_write(), native_rtp_bridge_write(), simple_bridge_write(), softmix_bridge_write(), softmix_bridge_write_control(), softmix_bridge_write_text(), and softmix_bridge_write_video().

bridge_channel_attended_transfer()

static void bridge_channel_attended_transfer ( struct ast_bridge_channel *  bridge_channel, const char *  target_chan_name  )

static

Definition at line 1971 of file bridge_channel.c.

{
    RAII_VAR(struct ast_channel *, chan_target, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel *, chan_bridged, NULL, ao2_cleanup);
 
    chan_target = ast_channel_get_by_name(target_chan_name);
    if (!chan_target) {
        /* Dang, it disappeared somehow */
        ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
        return;
    }
 
    ast_bridge_channel_lock(bridge_channel);
    chan_bridged = bridge_channel->chan;
    ast_assert(chan_bridged != NULL);
    ao2_ref(chan_bridged, +1);
    ast_bridge_channel_unlock(bridge_channel);
 
    if (ast_bridge_set_after_callback(chan_bridged, after_bridge_move_channel,
        after_bridge_move_channel_fail, ast_channel_ref(chan_target))) {
        ast_softhangup(chan_target, AST_SOFTHANGUP_DEV);
 
        /* Release the ref we tried to pass to ast_bridge_set_after_callback(). */
        ast_channel_unref(chan_target);
    }
    ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
}

References after_bridge_move_channel(), after_bridge_move_channel_fail(), ao2_cleanup, ao2_ref, ast_assert, ast_bridge_channel_kick(), ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_bridge_set_after_callback(), AST_CAUSE_NORMAL_CLEARING, ast_channel_get_by_name(), ast_channel_ref, ast_channel_unref, ast_softhangup(), AST_SOFTHANGUP_DEV, ast_bridge_channel::chan, NULL, and RAII_VAR.

Referenced by bridge_channel_handle_action().

bridge_channel_blind_transfer()

static void bridge_channel_blind_transfer ( struct ast_bridge_channel *  bridge_channel, struct blind_transfer_data *  blind_data  )

static

Definition at line 1960 of file bridge_channel.c.

{
    ast_async_goto(bridge_channel->chan, blind_data->context, blind_data->exten, 1);
    ast_bridge_channel_kick(bridge_channel, AST_CAUSE_NORMAL_CLEARING);
}

References ast_async_goto(), ast_bridge_channel_kick(), AST_CAUSE_NORMAL_CLEARING, ast_bridge_channel::chan, blind_transfer_data::context, and blind_transfer_data::exten.

Referenced by bridge_channel_handle_action().

bridge_channel_cancel_owed_events()

static void bridge_channel_cancel_owed_events ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 781 of file bridge_channel.c.

{
    bridge_channel->owed.dtmf_digit = '\0';
    bridge_channel->owed.t38_terminate = 0;
}

References ast_bridge_channel::dtmf_digit, ast_bridge_channel::owed, and ast_bridge_channel::t38_terminate.

Referenced by bridge_channel_internal_push_full().

bridge_channel_destroy()

static void bridge_channel_destroy ( void *  obj )

static

Definition at line 3072 of file bridge_channel.c.

{
    struct ast_bridge_channel *bridge_channel = obj;
    struct ast_frame *fr;
 
    if (bridge_channel->callid) {
        bridge_channel->callid = 0;
    }
 
    if (bridge_channel->bridge) {
        ao2_ref(bridge_channel->bridge, -1);
        bridge_channel->bridge = NULL;
    }
 
    /* Flush any unhandled wr_queue frames. */
    while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->wr_queue, frame_list))) {
        bridge_frame_free(fr);
    }
    ast_alertpipe_close(bridge_channel->alert_pipe);
 
    /* Flush any unhandled deferred_queue frames. */
    while ((fr = AST_LIST_REMOVE_HEAD(&bridge_channel->deferred_queue, frame_list))) {
        ast_frfree(fr);
    }
 
    ast_cond_destroy(&bridge_channel->cond);
 
    ao2_cleanup(bridge_channel->write_format);
    ao2_cleanup(bridge_channel->read_format);
 
    AST_VECTOR_FREE(&bridge_channel->stream_map.to_bridge);
    AST_VECTOR_FREE(&bridge_channel->stream_map.to_channel);
}

References ast_bridge_channel::alert_pipe, ao2_cleanup, ao2_ref, ast_alertpipe_close(), ast_cond_destroy, ast_frfree, AST_LIST_REMOVE_HEAD, AST_VECTOR_FREE, ast_bridge_channel::bridge, bridge_frame_free(), ast_bridge_channel::callid, ast_bridge_channel::cond, ast_bridge_channel::deferred_queue, NULL, ast_bridge_channel::read_format, ast_bridge_channel::stream_map, ast_bridge_channel::to_bridge, ast_bridge_channel::to_channel, ast_bridge_channel::wr_queue, and ast_bridge_channel::write_format.

Referenced by bridge_channel_internal_alloc().

bridge_channel_dissolve_check()

static void bridge_channel_dissolve_check ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2076 of file bridge_channel.c.

{
    struct ast_bridge *bridge = bridge_channel->bridge;
 
    if (bridge->dissolved) {
        return;
    }
 
    if (!bridge->num_channels
        && ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_EMPTY)) {
        /* Last channel leaving the bridge turns off the lights. */
        bridge_dissolve(bridge, ast_channel_hangupcause(bridge_channel->chan));
        return;
    }
 
    switch (bridge_channel->state) {
    case BRIDGE_CHANNEL_STATE_END:
        /* Do we need to dissolve the bridge because this channel hung up? */
        if (ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_HANGUP)
            || (bridge_channel->features->usable
                && ast_test_flag(&bridge_channel->features->feature_flags,
                    AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP))) {
            bridge_dissolve(bridge, ast_channel_hangupcause(bridge_channel->chan));
            return;
        }
        break;
    default:
        break;
    }
 
    if (bridge->num_lonely && bridge->num_lonely == bridge->num_channels) {
        /*
         * This will start a chain reaction where each channel leaving
         * enters this function and causes the next to leave as long as
         * there aren't non-lonely channels in the bridge.
         */
        ast_bridge_channel_leave_bridge(AST_LIST_FIRST(&bridge->channels),
            BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE,
            ast_channel_hangupcause(bridge_channel->chan));
    }
}

References AST_BRIDGE_CHANNEL_FLAG_DISSOLVE_HANGUP, ast_bridge_channel_leave_bridge(), AST_BRIDGE_FLAG_DISSOLVE_EMPTY, AST_BRIDGE_FLAG_DISSOLVE_HANGUP, ast_channel_hangupcause(), AST_LIST_FIRST, ast_test_flag, ast_bridge_channel::bridge, BRIDGE_CHANNEL_STATE_END, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, bridge_dissolve(), ast_bridge_channel::chan, ast_bridge::channels, ast_bridge::dissolved, ast_bridge::feature_flags, ast_bridge_features::feature_flags, ast_bridge_channel::features, ast_bridge::num_channels, ast_bridge::num_lonely, ast_bridge_channel::state, and ast_bridge_features::usable.

Referenced by bridge_channel_internal_join(), and bridge_channel_internal_pull().

bridge_channel_do_callback()

static void bridge_channel_do_callback ( struct ast_bridge_channel *  bridge_channel, struct bridge_custom_callback *  data  )

static

Definition at line 1387 of file bridge_channel.c.

{
    if (ast_test_flag(data, AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA)) {
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
    }
    data->callback(bridge_channel, data->payload_exists ? data->payload : NULL, data->payload_size);
    if (ast_test_flag(data, AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA)) {
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
    }
}

References AST_BRIDGE_CHANNEL_CB_OPTION_MEDIA, AST_CONTROL_SRCUPDATE, ast_indicate(), ast_test_flag, bridge_channel_suspend(), bridge_channel_unsuspend(), bridge_custom_callback::callback, ast_bridge_channel::chan, NULL, bridge_custom_callback::payload, bridge_custom_callback::payload_exists, and bridge_custom_callback::payload_size.

Referenced by bridge_channel_handle_action().

bridge_channel_dtmf_stream()

static void bridge_channel_dtmf_stream ( struct ast_bridge_channel *  bridge_channel, const char *  dtmf  )

static

Definition at line 1870 of file bridge_channel.c.

{
    ast_debug(1, "Playing DTMF stream '%s' out to %p(%s)\n",
        dtmf, bridge_channel, ast_channel_name(bridge_channel->chan));
    ast_dtmf_stream(bridge_channel->chan, NULL, dtmf, 0, 0);
}

References ast_channel_name(), ast_debug, ast_dtmf_stream(), ast_bridge_channel::chan, and NULL.

Referenced by bridge_channel_handle_action().

bridge_channel_event_join_leave()

static void bridge_channel_event_join_leave ( struct ast_bridge_channel *  bridge_channel, enum ast_bridge_hook_type  type  )

static

Definition at line 2800 of file bridge_channel.c.

{
    struct ast_bridge_features *features = bridge_channel->features;
    struct ast_bridge_hook *hook;
    struct ao2_iterator iter;
 
    /* Run the specified hooks. */
    iter = ao2_iterator_init(features->other_hooks, 0);
    for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
        if (hook->type == type) {
            break;
        }
    }
    if (hook) {
        /* Found the first specified hook to run. */
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        do {
            if (hook->type == type) {
                hook->callback(bridge_channel, hook->hook_pvt);
                ao2_unlink(features->other_hooks, hook);
            }
            ao2_ref(hook, -1);
        } while ((hook = ao2_iterator_next(&iter)));
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
    }
    ao2_iterator_destroy(&iter);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ao2_unlink, AST_CONTROL_SRCUPDATE, ast_indicate(), bridge_channel_suspend(), bridge_channel_unsuspend(), ast_bridge_hook::callback, ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_hook::hook_pvt, ast_bridge_features::other_hooks, type, and ast_bridge_hook::type.

Referenced by bridge_channel_internal_join().

bridge_channel_feature_digit_add()

static int bridge_channel_feature_digit_add ( struct ast_bridge_channel *  bridge_channel, int  digit, size_t  dtmf_len  )

static

Definition at line 1660 of file bridge_channel.c.

{
    if (dtmf_len < ARRAY_LEN(bridge_channel->dtmf_hook_state.collected) - 1) {
        /* Add the new digit to the DTMF string so we can do our matching */
        bridge_channel->dtmf_hook_state.collected[dtmf_len++] = digit;
        bridge_channel->dtmf_hook_state.collected[dtmf_len] = '\0';
 
        ast_debug(1, "DTMF feature string on %p(%s) is now '%s'\n",
              bridge_channel, ast_channel_name(bridge_channel->chan),
              bridge_channel->dtmf_hook_state.collected);
    }
 
    return dtmf_len;
}

References ARRAY_LEN, ast_channel_name(), ast_debug, ast_bridge_channel::chan, ast_bridge_channel::collected, digit, and ast_bridge_channel::dtmf_hook_state.

Referenced by ast_bridge_channel_feature_digit(), and ast_bridge_channel_feature_digit_add().

bridge_channel_feature_digit_timeout()

static unsigned int bridge_channel_feature_digit_timeout ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 1676 of file bridge_channel.c.

{
    unsigned int digit_timeout;
    struct ast_features_general_config *gen_cfg;
 
    /* Determine interdigit timeout */
    ast_channel_lock(bridge_channel->chan);
    gen_cfg = ast_get_chan_features_general_config(bridge_channel->chan);
    ast_channel_unlock(bridge_channel->chan);
 
    if (!gen_cfg) {
        ast_log(LOG_ERROR, "Unable to retrieve features configuration.\n");
        return 3000; /* Pick a reasonable failsafe timeout in ms */
    }
 
    digit_timeout = gen_cfg->featuredigittimeout;
    ao2_ref(gen_cfg, -1);
 
    return digit_timeout;
}

References ao2_ref, ast_channel_lock, ast_channel_unlock, ast_get_chan_features_general_config(), ast_log, ast_bridge_channel::chan, ast_features_general_config::featuredigittimeout, and LOG_ERROR.

Referenced by ast_bridge_channel_feature_digit().

bridge_channel_feature_timeout()

static int bridge_channel_feature_timeout ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2685 of file bridge_channel.c.

{
    int ms;
 
    if (bridge_channel->dtmf_hook_state.collected[0]) {
        ms = ast_tvdiff_ms(bridge_channel->dtmf_hook_state.interdigit_timeout,
            ast_tvnow());
        if (ms < 0) {
            /* Expire immediately. */
            ms = 0;
        }
    } else {
        /* Timer is not active so wait forever. */
        ms = -1;
    }
 
    return ms;
}

References ast_tvdiff_ms(), ast_tvnow(), ast_bridge_channel::collected, ast_bridge_channel::dtmf_hook_state, and ast_bridge_channel::interdigit_timeout.

Referenced by bridge_channel_next_timeout().

bridge_channel_handle_action()

static void bridge_channel_handle_action ( struct ast_bridge_channel *  bridge_channel, enum bridge_channel_action_type  action, void *  data  )

static

Definition at line 2009 of file bridge_channel.c.

{
    switch (action) {
    case BRIDGE_CHANNEL_ACTION_DTMF_STREAM:
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_dtmf_stream(bridge_channel, data);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
        break;
    case BRIDGE_CHANNEL_ACTION_TALKING_START:
    case BRIDGE_CHANNEL_ACTION_TALKING_STOP:
        bridge_channel_talking(bridge_channel,
            action == BRIDGE_CHANNEL_ACTION_TALKING_START);
        break;
    case BRIDGE_CHANNEL_ACTION_PLAY_FILE:
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_playfile(bridge_channel, data);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
        break;
    case BRIDGE_CHANNEL_ACTION_RUN_APP:
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_run_app(bridge_channel, data);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
        break;
    case BRIDGE_CHANNEL_ACTION_CALLBACK:
        bridge_channel_do_callback(bridge_channel, data);
        break;
    case BRIDGE_CHANNEL_ACTION_PARK:
        bridge_channel_suspend(bridge_channel);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_park(bridge_channel, data);
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
        break;
    case BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER:
        bridge_channel_blind_transfer(bridge_channel, data);
        break;
    case BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER:
        bridge_channel_attended_transfer(bridge_channel, data);
        break;
    default:
        break;
    }
 
    /* While invoking an action it is possible for the channel to be hung up. So
     * that the bridge respects this we check here and if hung up kick it out.
     */
    if (bridge_channel->chan && ast_check_hangup_locked(bridge_channel->chan)) {
        ast_bridge_channel_kick(bridge_channel, 0);
    }
}

References ast_control_read_action_payload::action, ast_bridge_channel_kick(), ast_check_hangup_locked(), AST_CONTROL_SRCUPDATE, ast_indicate(), BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER, BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER, BRIDGE_CHANNEL_ACTION_CALLBACK, BRIDGE_CHANNEL_ACTION_DTMF_STREAM, BRIDGE_CHANNEL_ACTION_PARK, BRIDGE_CHANNEL_ACTION_PLAY_FILE, BRIDGE_CHANNEL_ACTION_RUN_APP, BRIDGE_CHANNEL_ACTION_TALKING_START, BRIDGE_CHANNEL_ACTION_TALKING_STOP, bridge_channel_attended_transfer(), bridge_channel_blind_transfer(), bridge_channel_do_callback(), bridge_channel_dtmf_stream(), bridge_channel_park(), bridge_channel_playfile(), bridge_channel_run_app(), bridge_channel_suspend(), bridge_channel_talking(), bridge_channel_unsuspend(), and ast_bridge_channel::chan.

Referenced by bridge_channel_handle_write().

bridge_channel_handle_control()

static void bridge_channel_handle_control ( struct ast_bridge_channel *  bridge_channel, struct ast_frame *  fr  )

static

Definition at line 2268 of file bridge_channel.c.

{
    struct ast_channel *chan;
    struct ast_option_header *aoh;
 
    chan = bridge_channel->chan;
    switch (fr->subclass.integer) {
    case AST_CONTROL_REDIRECTING:
        if (ast_channel_redirecting_sub(NULL, chan, fr, 1)) {
            ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
        }
        break;
    case AST_CONTROL_CONNECTED_LINE:
        if (ast_channel_connected_line_sub(NULL, chan, fr, 1)) {
            ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
        }
        break;
    case AST_CONTROL_OPTION:
        /*
         * Forward option Requests, but only ones we know are safe These
         * are ONLY sent by chan_iax2 and I'm not convinced that they
         * are useful. I haven't deleted them entirely because I just am
         * not sure of the ramifications of removing them.
         */
        aoh = fr->data.ptr;
        if (aoh && aoh->flag == AST_OPTION_FLAG_REQUEST) {
            switch (ntohs(aoh->option)) {
            case AST_OPTION_TONE_VERIFY:
            case AST_OPTION_TDD:
            case AST_OPTION_RELAXDTMF:
            case AST_OPTION_AUDIO_MODE:
            case AST_OPTION_DIGIT_DETECT:
            case AST_OPTION_FAX_DETECT:
                ast_channel_setoption(chan, ntohs(aoh->option), aoh->data,
                    fr->datalen - sizeof(*aoh), 0);
                break;
            default:
                break;
            }
        }
        break;
    case AST_CONTROL_ANSWER:
        if (ast_channel_state(chan) != AST_STATE_UP) {
            ast_answer(chan);
            ast_bridge_channel_lock_bridge(bridge_channel);
            bridge_channel->bridge->reconfigured = 1;
            bridge_reconfigured(bridge_channel->bridge, 0);
            ast_bridge_unlock(bridge_channel->bridge);
        } else {
            ast_indicate(chan, -1);
        }
        break;
    case AST_CONTROL_MASQUERADE_NOTIFY:
        /* Should never happen. */
        ast_assert(0);
        break;
    case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
        ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
        break;
    default:
        ast_indicate_data(chan, fr->subclass.integer, fr->data.ptr, fr->datalen);
        break;
    }
}

References ast_answer(), ast_assert, ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_channel_connected_line_sub(), ast_channel_redirecting_sub(), ast_channel_setoption(), AST_CONTROL_ANSWER, AST_CONTROL_CONNECTED_LINE, AST_CONTROL_MASQUERADE_NOTIFY, AST_CONTROL_OPTION, AST_CONTROL_REDIRECTING, AST_CONTROL_STREAM_TOPOLOGY_CHANGED, ast_indicate(), ast_indicate_data(), AST_OPTION_AUDIO_MODE, AST_OPTION_DIGIT_DETECT, AST_OPTION_FAX_DETECT, AST_OPTION_FLAG_REQUEST, AST_OPTION_RELAXDTMF, AST_OPTION_TDD, AST_OPTION_TONE_VERIFY, AST_STATE_UP, ast_bridge_channel::bridge, bridge_reconfigured(), ast_bridge_channel::chan, ast_frame::data, ast_option_header::data, ast_frame::datalen, ast_frame_subclass::integer, NULL, ast_frame::ptr, ast_bridge::reconfigured, and ast_frame::subclass.

Referenced by bridge_channel_handle_write().

bridge_channel_handle_feature_timeout()

static void bridge_channel_handle_feature_timeout ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 1824 of file bridge_channel.c.

{
    if (!bridge_channel->dtmf_hook_state.collected[0]
        || 0 < ast_tvdiff_ms(bridge_channel->dtmf_hook_state.interdigit_timeout,
            ast_tvnow())) {
        /* Not within a sequence or not timed out. */
        return;
    }
 
    ast_bridge_channel_feature_digit(bridge_channel, 0);
}

References ast_bridge_channel_feature_digit(), ast_tvdiff_ms(), ast_tvnow(), ast_bridge_channel::collected, ast_bridge_channel::dtmf_hook_state, and ast_bridge_channel::interdigit_timeout.

Referenced by bridge_channel_wait().

bridge_channel_handle_interval()

static void bridge_channel_handle_interval ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 1515 of file bridge_channel.c.

{
    struct ast_heap *interval_hooks;
    struct ast_bridge_hook_timer *hook;
    struct timeval start;
    int chan_suspended = 0;
 
    interval_hooks = bridge_channel->features->interval_hooks;
    ast_heap_wrlock(interval_hooks);
    start = ast_tvnow();
    while ((hook = ast_heap_peek(interval_hooks, 1))) {
        int interval;
        unsigned int execution_time;
 
        if (ast_tvdiff_ms(hook->timer.trip_time, start) > 0) {
            ast_debug(1, "Hook %p on %p(%s) wants to happen in the future, stopping our traversal\n",
                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
            break;
        }
        ao2_ref(hook, +1);
        ast_heap_unlock(interval_hooks);
 
        if (!chan_suspended
            && ast_test_flag(&hook->timer, AST_BRIDGE_HOOK_TIMER_OPTION_MEDIA)) {
            chan_suspended = 1;
            bridge_channel_suspend(bridge_channel);
            ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        }
 
        ast_debug(1, "Executing hook %p on %p(%s)\n",
            hook, bridge_channel, ast_channel_name(bridge_channel->chan));
        interval = hook->generic.callback(bridge_channel, hook->generic.hook_pvt);
 
        ast_heap_wrlock(interval_hooks);
        if (ast_heap_peek(interval_hooks, hook->timer.heap_index) != hook
            || !ast_heap_remove(interval_hooks, hook)) {
            /* Interval hook is already removed from the bridge_channel. */
            ao2_ref(hook, -1);
            continue;
        }
        ao2_ref(hook, -1);
 
        if (interval < 0) {
            ast_debug(1, "Removed interval hook %p from %p(%s)\n",
                hook, bridge_channel, ast_channel_name(bridge_channel->chan));
            ao2_ref(hook, -1);
            continue;
        }
        if (interval) {
            /* Set new interval for the hook. */
            hook->timer.interval = interval;
        }
 
        ast_debug(1, "Updating interval hook %p with interval %u on %p(%s)\n",
            hook, hook->timer.interval, bridge_channel,
            ast_channel_name(bridge_channel->chan));
 
        /* resetting start */
        start = ast_tvnow();
 
        /*
         * Resetup the interval hook for the next interval.  We may need
         * to skip over any missed intervals because the hook was
         * delayed or took too long.
         */
        execution_time = ast_tvdiff_ms(start, hook->timer.trip_time);
        while (hook->timer.interval < execution_time) {
            execution_time -= hook->timer.interval;
        }
        hook->timer.trip_time = ast_tvadd(start, ast_samp2tv(hook->timer.interval - execution_time, 1000));
        hook->timer.seqno = ast_atomic_fetchadd_int((int *) &bridge_channel->features->interval_sequence, +1);
 
        if (ast_heap_push(interval_hooks, hook)) {
            /* Could not push the hook back onto the heap. */
            ao2_ref(hook, -1);
        }
    }
    ast_heap_unlock(interval_hooks);
 
    if (chan_suspended) {
        ast_indicate(bridge_channel->chan, AST_CONTROL_SRCUPDATE);
        bridge_channel_unsuspend(bridge_channel);
    }
}

References ao2_ref, ast_atomic_fetchadd_int(), AST_BRIDGE_HOOK_TIMER_OPTION_MEDIA, ast_channel_name(), AST_CONTROL_SRCUPDATE, ast_debug, ast_heap_peek(), ast_heap_push, ast_heap_remove(), ast_heap_unlock, ast_heap_wrlock, ast_indicate(), ast_samp2tv(), ast_test_flag, ast_tvadd(), ast_tvdiff_ms(), ast_tvnow(), bridge_channel_suspend(), bridge_channel_unsuspend(), ast_bridge_hook::callback, ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_hook_timer::generic, ast_bridge_hook_timer_parms::heap_index, ast_bridge_hook::hook_pvt, ast_bridge_hook_timer_parms::interval, ast_bridge_features::interval_hooks, ast_bridge_features::interval_sequence, ast_bridge_hook_timer_parms::seqno, ast_bridge_hook_timer::timer, and ast_bridge_hook_timer_parms::trip_time.

Referenced by bridge_channel_wait().

bridge_channel_handle_write()

static void bridge_channel_handle_write ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2373 of file bridge_channel.c.

{
    struct ast_frame *fr;
    struct sync_payload *sync_payload;
    int num;
    struct ast_msg_data *msg;
 
    ast_bridge_channel_lock(bridge_channel);
 
    /* It's not good to have unbalanced frames and alert_pipe alerts. */
    ast_assert(!AST_LIST_EMPTY(&bridge_channel->wr_queue));
    if (AST_LIST_EMPTY(&bridge_channel->wr_queue)) {
        /* No frame, flush the alert pipe of excess alerts. */
        ast_log(LOG_WARNING, "Weird.  No frame from bridge for %s to process?\n",
            ast_channel_name(bridge_channel->chan));
        ast_alertpipe_read(bridge_channel->alert_pipe);
        ast_bridge_channel_unlock(bridge_channel);
        return;
    }
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(&bridge_channel->wr_queue, fr, frame_list) {
        if (bridge_channel->dtmf_hook_state.collected[0]) {
            switch (fr->frametype) {
            case AST_FRAME_BRIDGE_ACTION:
            case AST_FRAME_BRIDGE_ACTION_SYNC:
                /* Defer processing these frames while DTMF is collected. */
                continue;
            default:
                break;
            }
        }
        ast_alertpipe_read(bridge_channel->alert_pipe);
        AST_LIST_REMOVE_CURRENT(frame_list);
        break;
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    ast_bridge_channel_unlock(bridge_channel);
 
    if (!fr) {
        /*
         * Wait some to reduce CPU usage from a tight loop
         * without any wait because we only have deferred
         * frames in the wr_queue.
         */
        usleep(1);
        return;
    }
 
    switch (fr->frametype) {
    case AST_FRAME_BRIDGE_ACTION:
        bridge_channel_handle_action(bridge_channel, fr->subclass.integer, fr->data.ptr);
        break;
    case AST_FRAME_BRIDGE_ACTION_SYNC:
        sync_payload = fr->data.ptr;
        bridge_channel_handle_action(bridge_channel, fr->subclass.integer, sync_payload->data);
        break;
    case AST_FRAME_CONTROL:
        bridge_channel_handle_control(bridge_channel, fr);
        break;
    case AST_FRAME_NULL:
        break;
    case AST_FRAME_TEXT:
        ast_debug(1, "Sending TEXT frame to '%s': %*.s\n",
            ast_channel_name(bridge_channel->chan), fr->datalen, (char *)fr->data.ptr);
        sendtext_safe(bridge_channel->chan, fr);
        break;
    case AST_FRAME_TEXT_DATA:
        msg = (struct ast_msg_data *)fr->data.ptr;
        ast_debug(1, "Sending TEXT_DATA frame from '%s' to '%s:%s': %s\n",
            ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_FROM),
            ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_TO),
            ast_channel_name(bridge_channel->chan),
            ast_msg_data_get_attribute(msg, AST_MSG_DATA_ATTR_BODY));
        ast_sendtext_data(bridge_channel->chan, msg);
        break;
    default:
        /* Assume that there is no mapped stream for this */
        num = -1;
 
        if (fr->stream_num > -1) {
            ast_bridge_channel_lock(bridge_channel);
            if (fr->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_channel)) {
                num = AST_VECTOR_GET(&bridge_channel->stream_map.to_channel, fr->stream_num);
            }
            ast_bridge_channel_unlock(bridge_channel);
 
            /* If there is no mapped stream after checking the mapping then there is nowhere
             * to write this frame to, so drop it.
             */
            if (num == -1) {
                break;
            }
        }
 
        /* Write the frame to the channel. */
        bridge_channel->activity = BRIDGE_CHANNEL_THREAD_SIMPLE;
        ast_write_stream(bridge_channel->chan, num, fr);
        break;
    }
    bridge_frame_free(fr);
}

References ast_bridge_channel::activity, ast_bridge_channel::alert_pipe, ast_alertpipe_read(), ast_assert, ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_name(), ast_debug, AST_FRAME_BRIDGE_ACTION, AST_FRAME_BRIDGE_ACTION_SYNC, AST_FRAME_CONTROL, AST_FRAME_NULL, AST_FRAME_TEXT, AST_FRAME_TEXT_DATA, AST_LIST_EMPTY, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log, AST_MSG_DATA_ATTR_BODY, AST_MSG_DATA_ATTR_FROM, AST_MSG_DATA_ATTR_TO, ast_msg_data_get_attribute(), ast_sendtext_data(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_write_stream(), bridge_channel_handle_action(), bridge_channel_handle_control(), BRIDGE_CHANNEL_THREAD_SIMPLE, bridge_frame_free(), ast_bridge_channel::chan, ast_bridge_channel::collected, ast_frame::data, sync_payload::data, ast_frame::datalen, ast_bridge_channel::dtmf_hook_state, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, ast_frame::ptr, sendtext_safe(), ast_bridge_channel::stream_map, ast_frame::stream_num, ast_frame::subclass, ast_bridge_channel::to_channel, and ast_bridge_channel::wr_queue.

Referenced by bridge_channel_wait().

bridge_channel_internal_alloc()

struct ast_bridge_channel * bridge_channel_internal_alloc

(

struct ast_bridge *

bridge

)

Definition at line 3106 of file bridge_channel.c.

{
    struct ast_bridge_channel *bridge_channel;
 
    bridge_channel = ao2_alloc(sizeof(struct ast_bridge_channel), bridge_channel_destroy);
    if (!bridge_channel) {
        return NULL;
    }
    ast_cond_init(&bridge_channel->cond, NULL);
    if (ast_alertpipe_init(bridge_channel->alert_pipe)) {
        ao2_ref(bridge_channel, -1);
        return NULL;
    }
    if (bridge) {
        bridge_channel->bridge = bridge;
        ao2_ref(bridge_channel->bridge, +1);
    }
 
    /* The stream_map is initialized later - see ast_bridge_channel_stream_map */
 
    return bridge_channel;
}

References ast_bridge_channel::alert_pipe, ao2_alloc, ao2_ref, ast_alertpipe_init(), ast_cond_init, ast_bridge_channel::bridge, bridge_channel_destroy(), ast_bridge_channel::cond, and NULL.

Referenced by ast_bridge_join(), and bridge_impart_internal().

bridge_channel_internal_allows_optimization()

int bridge_channel_internal_allows_optimization

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 3065 of file bridge_channel.c.

{
    return bridge_channel->in_bridge
        && AST_LIST_EMPTY(&bridge_channel->wr_queue);
}

References AST_LIST_EMPTY, ast_bridge_channel::in_bridge, and ast_bridge_channel::wr_queue.

Referenced by optimize_lock_chan_stack(), and optimize_lock_peer_stack().

bridge_channel_internal_join()

int bridge_channel_internal_join

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 2830 of file bridge_channel.c.

{
    int res = 0;
    uint8_t indicate_src_change = 0;
    struct ast_bridge_features *channel_features;
    struct ast_channel *peer;
    struct ast_channel *swap;
 
    ast_debug(1, "Bridge %s: %p(%s) is joining\n",
        bridge_channel->bridge->uniqueid,
        bridge_channel, ast_channel_name(bridge_channel->chan));
 
    /*
     * Directly locking the bridge is safe here because nobody else
     * knows about this bridge_channel yet.
     */
    ast_bridge_lock(bridge_channel->bridge);
 
    ast_channel_lock(bridge_channel->chan);
    peer = ast_local_get_peer(bridge_channel->chan);
 
    if (peer) {
        struct ast_bridge *peer_bridge;
 
        ast_channel_unlock(bridge_channel->chan);
 
        ast_channel_lock(peer);
        peer_bridge = ast_channel_internal_bridge(peer);
        ast_channel_unlock(peer);
        ast_channel_unref(peer);
 
        /* As we are only doing a pointer comparison we don't need the peer_bridge
         * to be reference counted or locked.
         */
        if (peer_bridge == bridge_channel->bridge) {
            ast_bridge_unlock(bridge_channel->bridge);
            ast_debug(1, "Bridge %s: %p(%s) denying Bridge join to prevent Local channel loop\n",
                bridge_channel->bridge->uniqueid,
                bridge_channel,
                ast_channel_name(bridge_channel->chan));
            return -1;
        }
 
        ast_channel_lock(bridge_channel->chan);
    }
 
    bridge_channel->read_format = ao2_bump(ast_channel_readformat(bridge_channel->chan));
    bridge_channel->write_format = ao2_bump(ast_channel_writeformat(bridge_channel->chan));
 
    /* Make sure we're still good to be put into a bridge */
    if (ast_channel_internal_bridge(bridge_channel->chan)
        || ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_ZOMBIE)) {
        ast_channel_unlock(bridge_channel->chan);
        ast_bridge_unlock(bridge_channel->bridge);
        ast_debug(1, "Bridge %s: %p(%s) failed to join Bridge\n",
            bridge_channel->bridge->uniqueid,
            bridge_channel,
            ast_channel_name(bridge_channel->chan));
        return -1;
    }
    ast_channel_internal_bridge_set(bridge_channel->chan, bridge_channel->bridge);
 
    /* Attach features requested by the channel */
    channel_features = ast_channel_feature_hooks_get(bridge_channel->chan);
    if (channel_features) {
        ast_bridge_features_merge(bridge_channel->features, channel_features);
    }
    ast_channel_unlock(bridge_channel->chan);
 
    /* Add the jitterbuffer if the channel requires it */
    ast_jb_enable_for_channel(bridge_channel->chan);
 
    if (!bridge_channel->bridge->callid) {
        bridge_channel->bridge->callid = ast_read_threadstorage_callid();
    }
 
    /* Take the swap channel ref from the bridge_channel struct. */
    swap = bridge_channel->swap;
 
    if (bridge_channel_internal_push(bridge_channel)) {
        int cause = bridge_channel->bridge->cause;
 
        ast_bridge_unlock(bridge_channel->bridge);
        ast_bridge_channel_kick(bridge_channel, cause);
        ast_bridge_channel_lock_bridge(bridge_channel);
        ast_bridge_features_remove(bridge_channel->features,
            AST_BRIDGE_HOOK_REMOVE_ON_PULL);
        bridge_channel_dissolve_check(bridge_channel);
        res = -1;
    }
    bridge_reconfigured(bridge_channel->bridge, !bridge_channel->inhibit_colp);
 
    if (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
        /*
         * Indicate a source change since this channel is entering the
         * bridge system only if the bridge technology is not MULTIMIX
         * capable.  The MULTIMIX technology has already done it.
         */
        if (!(bridge_channel->bridge->technology->capabilities
            & AST_BRIDGE_CAPABILITY_MULTIMIX)) {
            indicate_src_change = 1;
        }
 
        bridge_channel_impart_signal(bridge_channel->chan);
        ast_bridge_unlock(bridge_channel->bridge);
 
        /* Must release any swap ref after unlocking the bridge. */
        ao2_t_cleanup(swap, "Bridge push with swap successful");
        swap = NULL;
 
        if (indicate_src_change) {
            ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
        }
 
        bridge_channel_event_join_leave(bridge_channel, AST_BRIDGE_HOOK_TYPE_JOIN);
 
        while (bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
            /* Wait for something to do. */
            bridge_channel_wait(bridge_channel);
        }
 
        /* Force a timeout on any accumulated DTMF hook digits. */
        ast_bridge_channel_feature_digit(bridge_channel, 0);
 
        bridge_channel_event_join_leave(bridge_channel, AST_BRIDGE_HOOK_TYPE_LEAVE);
        ast_bridge_channel_lock_bridge(bridge_channel);
    }
 
    bridge_channel_internal_pull(bridge_channel);
    bridge_channel_settle_owed_events(bridge_channel->bridge, bridge_channel);
    bridge_reconfigured(bridge_channel->bridge, 1);
 
    /* Remove ourselves if we are the video source */
    ast_bridge_remove_video_src(bridge_channel->bridge, bridge_channel->chan);
 
    ast_bridge_unlock(bridge_channel->bridge);
 
    /* Must release any swap ref after unlocking the bridge. */
    ao2_t_cleanup(swap, "Bridge push with swap failed or exited immediately");
 
    /* Complete any active hold before exiting the bridge. */
    if (ast_channel_hold_state(bridge_channel->chan) == AST_CONTROL_HOLD) {
        ast_debug(1, "Channel %s simulating UNHOLD for bridge end.\n",
            ast_channel_name(bridge_channel->chan));
        ast_indicate(bridge_channel->chan, AST_CONTROL_UNHOLD);
    }
 
    /* Complete any partial DTMF digit before exiting the bridge. */
    if (ast_channel_sending_dtmf_digit(bridge_channel->chan)) {
        ast_channel_end_dtmf(bridge_channel->chan,
            ast_channel_sending_dtmf_digit(bridge_channel->chan),
            ast_channel_sending_dtmf_tv(bridge_channel->chan), "bridge end");
    }
 
    /* Complete any T.38 session before exiting the bridge. */
    if (ast_channel_is_t38_active(bridge_channel->chan)) {
        struct ast_control_t38_parameters t38_parameters = {
            .request_response = AST_T38_TERMINATED,
        };
 
        ast_debug(1, "Channel %s simulating T.38 terminate for bridge end.\n",
            ast_channel_name(bridge_channel->chan));
        ast_indicate_data(bridge_channel->chan, AST_CONTROL_T38_PARAMETERS,
            &t38_parameters, sizeof(t38_parameters));
    }
 
    /* Indicate a source change since this channel is leaving the bridge system. */
    ast_indicate(bridge_channel->chan, AST_CONTROL_SRCCHANGE);
 
    /*
     * Wait for any dual redirect to complete.
     *
     * Must be done while "still in the bridge" for ast_async_goto()
     * to work right.
     */
    while (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT)) {
        sched_yield();
    }
    ast_channel_lock(bridge_channel->chan);
    ast_channel_internal_bridge_set(bridge_channel->chan, NULL);
    ast_channel_unlock(bridge_channel->chan);
 
    ast_bridge_channel_restore_formats(bridge_channel);
 
    return res;
}

References ao2_bump, ao2_t_cleanup, AST_BRIDGE_CAPABILITY_MULTIMIX, ast_bridge_channel_feature_digit(), ast_bridge_channel_kick(), ast_bridge_channel_lock_bridge(), ast_bridge_channel_restore_formats(), ast_bridge_features_merge(), ast_bridge_features_remove(), AST_BRIDGE_HOOK_REMOVE_ON_PULL, AST_BRIDGE_HOOK_TYPE_JOIN, AST_BRIDGE_HOOK_TYPE_LEAVE, ast_bridge_lock, ast_bridge_remove_video_src(), ast_bridge_unlock, ast_channel_end_dtmf(), ast_channel_feature_hooks_get(), ast_channel_flags(), ast_channel_hold_state(), ast_channel_internal_bridge(), ast_channel_internal_bridge_set(), ast_channel_is_t38_active(), ast_channel_lock, ast_channel_name(), ast_channel_readformat(), ast_channel_sending_dtmf_digit(), ast_channel_sending_dtmf_tv(), ast_channel_unlock, ast_channel_unref, ast_channel_writeformat(), AST_CONTROL_HOLD, AST_CONTROL_SRCCHANGE, AST_CONTROL_T38_PARAMETERS, AST_CONTROL_UNHOLD, ast_debug, AST_FLAG_BRIDGE_DUAL_REDIRECT_WAIT, AST_FLAG_ZOMBIE, ast_indicate(), ast_indicate_data(), ast_jb_enable_for_channel(), ast_local_get_peer(), ast_read_threadstorage_callid(), AST_T38_TERMINATED, ast_test_flag, ast_bridge_channel::bridge, ast_channel::bridge_channel, bridge_channel_dissolve_check(), bridge_channel_event_join_leave(), bridge_channel_impart_signal(), bridge_channel_internal_pull(), bridge_channel_internal_push(), bridge_channel_settle_owed_events(), BRIDGE_CHANNEL_STATE_WAIT, bridge_channel_wait(), bridge_reconfigured(), ast_bridge::callid, ast_bridge_technology::capabilities, ast_bridge::cause, ast_bridge_channel::chan, ast_bridge_channel::features, ast_bridge_channel::inhibit_colp, NULL, ast_bridge_channel::read_format, ast_control_t38_parameters::request_response, ast_bridge_channel::state, ast_bridge_channel::swap, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge_channel::write_format.

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

bridge_channel_internal_pull()

void bridge_channel_internal_pull

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 2118 of file bridge_channel.c.

{
    struct ast_bridge *bridge = bridge_channel->bridge;
 
    if (!bridge_channel->in_bridge) {
        return;
    }
    bridge_channel->in_bridge = 0;
 
    ast_debug(1, "Bridge %s: pulling %p(%s)\n",
        bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
 
    ast_verb(3, "Channel %s left '%s' %s-bridge <%s>\n",
        ast_channel_name(bridge_channel->chan),
        bridge->technology->name,
        bridge->v_table->name,
        bridge->uniqueid);
 
    if (!bridge_channel->just_joined) {
        /* Tell the bridge technology we are leaving so they tear us down */
        ast_debug(1, "Bridge %s: %p(%s) is leaving %s technology\n",
            bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
            bridge->technology->name);
        if (bridge->technology->leave) {
            bridge->technology->leave(bridge, bridge_channel);
        }
    }
 
    /* Remove channel from the bridge */
    if (!bridge_channel->suspended) {
        --bridge->num_active;
    }
    if (ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
        --bridge->num_lonely;
    }
    --bridge->num_channels;
    AST_LIST_REMOVE(&bridge->channels, bridge_channel, entry);
 
    bridge_channel_dissolve_check(bridge_channel);
    bridge->v_table->pull(bridge, bridge_channel);
 
    ast_bridge_channel_clear_roles(bridge_channel);
 
    /* If we are not going to be hung up after leaving a bridge, and we were an
     * outgoing channel, clear the outgoing flag.
     */
    if (ast_test_flag(ast_channel_flags(bridge_channel->chan), AST_FLAG_OUTGOING)
        && (ast_channel_is_leaving_bridge(bridge_channel->chan)
            || bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT)) {
        ast_debug(2, "Channel %s will survive this bridge; clearing outgoing (dialed) flag\n", ast_channel_name(bridge_channel->chan));
        ast_channel_clear_flag(bridge_channel->chan, AST_FLAG_OUTGOING);
    }
 
    bridge->reconfigured = 1;
    ast_bridge_publish_leave(bridge, bridge_channel->chan);
}

References ast_bridge_channel_clear_roles(), AST_BRIDGE_CHANNEL_FLAG_LONELY, ast_bridge_publish_leave(), ast_channel_clear_flag(), ast_channel_flags(), ast_channel_is_leaving_bridge(), ast_channel_name(), ast_debug, AST_FLAG_OUTGOING, AST_LIST_REMOVE, ast_test_flag, ast_verb, ast_bridge_channel::bridge, bridge_channel_dissolve_check(), BRIDGE_CHANNEL_STATE_WAIT, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_features::feature_flags, ast_bridge_channel::features, ast_bridge_channel::in_bridge, ast_bridge_channel::just_joined, ast_bridge_technology::leave, ast_bridge_methods::name, ast_bridge_technology::name, ast_bridge::num_active, ast_bridge::num_channels, ast_bridge::num_lonely, ast_bridge_methods::pull, ast_bridge::reconfigured, ast_bridge_channel::state, ast_bridge_channel::suspended, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by bridge_channel_internal_join(), bridge_channel_internal_push_full(), bridge_do_merge(), and bridge_do_move().

bridge_channel_internal_push()

int bridge_channel_internal_push

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 2255 of file bridge_channel.c.

{
    return bridge_channel_internal_push_full(bridge_channel, 0);
}

References bridge_channel_internal_push_full().

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

bridge_channel_internal_push_full()

int bridge_channel_internal_push_full	(	struct ast_bridge_channel *	bridge_channel,
		int	optimized
	)

Definition at line 2175 of file bridge_channel.c.

{
    struct ast_bridge *bridge = bridge_channel->bridge;
    struct ast_bridge_channel *swap;
 
    ast_assert(!bridge_channel->in_bridge);
 
    swap = bridge_find_channel(bridge, bridge_channel->swap);
    bridge_channel->swap = NULL;
 
    if (swap) {
        ast_debug(1, "Bridge %s: pushing %p(%s) by swapping with %p(%s)\n",
            bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan),
            swap, ast_channel_name(swap->chan));
    } else {
        ast_debug(1, "Bridge %s: pushing %p(%s)\n",
            bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
    }
 
    /* Add channel to the bridge */
    if (bridge->dissolved
        || bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT
        || (swap && swap->state != BRIDGE_CHANNEL_STATE_WAIT)
        || bridge->v_table->push(bridge, bridge_channel, swap)) {
        ast_debug(1, "Bridge %s: pushing %p(%s) into bridge failed\n",
            bridge->uniqueid, bridge_channel, ast_channel_name(bridge_channel->chan));
        return -1;
    }
 
    ast_bridge_channel_establish_roles(bridge_channel);
 
    if (swap) {
        int dissolve = ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_EMPTY);
 
        /* This flag is cleared so the act of this channel leaving does not cause it to dissolve if need be */
        ast_clear_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE_EMPTY);
 
        if (optimized) {
            bridge_channel_cancel_owed_events(swap);
        }
        ast_bridge_channel_leave_bridge(swap, BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, 0);
        bridge_channel_internal_pull(swap);
 
        ast_set2_flag(&bridge->feature_flags, dissolve, AST_BRIDGE_FLAG_DISSOLVE_EMPTY);
    }
 
    bridge_channel->in_bridge = 1;
    bridge_channel->just_joined = 1;
    AST_LIST_INSERT_TAIL(&bridge->channels, bridge_channel, entry);
    ++bridge->num_channels;
    if (ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
        ++bridge->num_lonely;
    }
    if (!bridge_channel->suspended) {
        ++bridge->num_active;
    }
 
    ast_verb(3, "Channel %s %s%s%s '%s' %s-bridge <%s>\n",
        ast_channel_name(bridge_channel->chan),
        swap ? "swapped with " : "joined",
        swap ? ast_channel_name(swap->chan) : "",
        swap ? " into" : "",
        bridge->technology->name,
        bridge->v_table->name,
        bridge->uniqueid);
 
    ast_bridge_publish_enter(bridge, bridge_channel->chan, swap ? swap->chan : NULL);
 
    /* Clear any BLINDTRANSFER,ATTENDEDTRANSFER and FORWARDERNAME since the transfer has completed. */
    pbx_builtin_setvar_helper(bridge_channel->chan, "BLINDTRANSFER", NULL);
    pbx_builtin_setvar_helper(bridge_channel->chan, "ATTENDEDTRANSFER", NULL);
    pbx_builtin_setvar_helper(bridge_channel->chan, "FORWARDERNAME", NULL);
 
    /* Wake up the bridge channel thread to reevaluate any interval timers. */
    ast_queue_frame(bridge_channel->chan, &ast_null_frame);
 
    bridge->reconfigured = 1;
    return 0;
}

References ast_assert, ast_bridge_channel_establish_roles(), AST_BRIDGE_CHANNEL_FLAG_LONELY, ast_bridge_channel_leave_bridge(), AST_BRIDGE_FLAG_DISSOLVE_EMPTY, ast_bridge_publish_enter(), ast_channel_name(), ast_clear_flag, ast_debug, AST_LIST_INSERT_TAIL, ast_null_frame, ast_queue_frame(), ast_set2_flag, ast_test_flag, ast_verb, ast_bridge_channel::bridge, bridge_channel_cancel_owed_events(), bridge_channel_internal_pull(), BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, BRIDGE_CHANNEL_STATE_WAIT, bridge_find_channel(), ast_bridge_channel::chan, ast_bridge::channels, ast_bridge::dissolved, ast_bridge_channel::entry, ast_bridge::feature_flags, ast_bridge_features::feature_flags, ast_bridge_channel::features, ast_bridge_channel::in_bridge, ast_bridge_channel::just_joined, ast_bridge_methods::name, ast_bridge_technology::name, NULL, ast_bridge::num_active, ast_bridge::num_channels, ast_bridge::num_lonely, pbx_builtin_setvar_helper(), ast_bridge_methods::push, ast_bridge::reconfigured, ast_bridge_channel::state, ast_channel::state, ast_bridge_channel::suspended, ast_bridge_channel::swap, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge::v_table.

Referenced by bridge_channel_internal_push(), and bridge_do_move().

bridge_channel_internal_queue_attended_transfer()

int bridge_channel_internal_queue_attended_transfer	(	struct ast_channel *	transferee,
		struct ast_channel *	unbridged_chan
	)

Definition at line 3043 of file bridge_channel.c.

{
    RAII_VAR(struct ast_bridge_channel *, transferee_bridge_channel, NULL, ao2_cleanup);
    char unbridged_chan_name[AST_CHANNEL_NAME];
 
    ast_channel_lock(transferee);
    transferee_bridge_channel = ast_channel_get_bridge_channel(transferee);
    ast_channel_unlock(transferee);
 
    if (!transferee_bridge_channel) {
        return -1;
    }
 
    ast_copy_string(unbridged_chan_name, ast_channel_name(unbridged_chan),
        sizeof(unbridged_chan_name));
 
    return bridge_channel_queue_action_data(transferee_bridge_channel,
        BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER, unbridged_chan_name,
        sizeof(unbridged_chan_name));
}

References ao2_cleanup, ast_channel_get_bridge_channel(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_name(), ast_channel_unlock, ast_copy_string(), BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER, bridge_channel_queue_action_data(), NULL, and RAII_VAR.

Referenced by ast_bridge_transfer_attended().

bridge_channel_internal_queue_blind_transfer()

int bridge_channel_internal_queue_blind_transfer	(	struct ast_channel *	transferee,
		const char *	exten,
		const char *	context,
		transfer_channel_cb	new_channel_cb,
		void *	user_data
	)

Definition at line 3017 of file bridge_channel.c.

{
    RAII_VAR(struct ast_bridge_channel *, transferee_bridge_channel, NULL, ao2_cleanup);
    struct blind_transfer_data blind_data;
 
    ast_channel_lock(transferee);
    transferee_bridge_channel = ast_channel_get_bridge_channel(transferee);
    ast_channel_unlock(transferee);
 
    if (!transferee_bridge_channel) {
        return -1;
    }
 
    if (new_channel_cb) {
        new_channel_cb(transferee, user_data, AST_BRIDGE_TRANSFER_SINGLE_PARTY);
    }
 
    ast_copy_string(blind_data.exten, exten, sizeof(blind_data.exten));
    ast_copy_string(blind_data.context, context, sizeof(blind_data.context));
 
    return bridge_channel_queue_action_data(transferee_bridge_channel,
        BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER, &blind_data, sizeof(blind_data));
}

References ao2_cleanup, AST_BRIDGE_TRANSFER_SINGLE_PARTY, ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER, bridge_channel_queue_action_data(), voicemailpwcheck::context, blind_transfer_data::context, blind_transfer_data::exten, NULL, and RAII_VAR.

Referenced by ast_bridge_transfer_blind().

bridge_channel_internal_suspend_nolock()

void bridge_channel_internal_suspend_nolock

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 839 of file bridge_channel.c.

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

References ast_bridge_channel::bridge, ast_bridge_channel::in_bridge, ast_bridge::num_active, ast_bridge_technology::suspend, ast_bridge_channel::suspended, and ast_bridge::technology.

Referenced by ast_bridge_channel_feature_digit(), ast_bridge_suspend(), and bridge_channel_suspend().

bridge_channel_internal_unsuspend_nolock()

void bridge_channel_internal_unsuspend_nolock

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 865 of file bridge_channel.c.

{
    bridge_channel->suspended = 0;
    if (bridge_channel->in_bridge) {
        ++bridge_channel->bridge->num_active;
    }
 
    /* Wake technology bridge threads to take care of channel again. */
    if (bridge_channel->bridge->technology->unsuspend) {
        bridge_channel->bridge->technology->unsuspend(bridge_channel->bridge, bridge_channel);
    }
 
    /* Wake suspended channel. */
    ast_bridge_channel_lock(bridge_channel);
    ast_cond_signal(&bridge_channel->cond);
    ast_bridge_channel_unlock(bridge_channel);
}

References ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_cond_signal, ast_bridge_channel::bridge, ast_bridge_channel::cond, ast_bridge_channel::in_bridge, ast_bridge::num_active, ast_bridge_channel::suspended, ast_bridge::technology, and ast_bridge_technology::unsuspend.

Referenced by ast_bridge_unsuspend(), and bridge_channel_unsuspend().

bridge_channel_next_interval()

static int bridge_channel_next_interval ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2652 of file bridge_channel.c.

{
    struct ast_heap *interval_hooks = bridge_channel->features->interval_hooks;
    struct ast_bridge_hook_timer *hook;
    int ms;
 
    ast_heap_wrlock(interval_hooks);
    hook = ast_heap_peek(interval_hooks, 1);
    if (hook) {
        ms = ast_tvdiff_ms(hook->timer.trip_time, ast_tvnow());
        if (ms < 0) {
            /* Expire immediately.  An interval hook is ready to run. */
            ms = 0;
        }
    } else {
        /* No hook so wait forever. */
        ms = -1;
    }
    ast_heap_unlock(interval_hooks);
 
    return ms;
}

References ast_heap_peek(), ast_heap_unlock, ast_heap_wrlock, ast_tvdiff_ms(), ast_tvnow(), ast_bridge_channel::features, ast_bridge_features::interval_hooks, ast_bridge_hook_timer::timer, and ast_bridge_hook_timer_parms::trip_time.

Referenced by bridge_channel_next_timeout().

bridge_channel_next_timeout()

static int bridge_channel_next_timeout ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2714 of file bridge_channel.c.

{
    int ms_interval;
    int ms;
 
    ms_interval = bridge_channel_next_interval(bridge_channel);
    ms = bridge_channel_feature_timeout(bridge_channel);
    if (ms < 0 || (0 <= ms_interval && ms_interval < ms)) {
        /* Interval hook timeout is next. */
        ms = ms_interval;
    }
 
    return ms;
}

References bridge_channel_feature_timeout(), and bridge_channel_next_interval().

Referenced by bridge_channel_wait().

bridge_channel_park()

static void bridge_channel_park ( struct ast_bridge_channel *  bridge_channel, struct bridge_park *  payload  )

static

Definition at line 1458 of file bridge_channel.c.

{
    if (!ast_parking_provider_registered()) {
        ast_log(AST_LOG_WARNING, "Unable to park %s: No parking provider loaded!\n",
            ast_channel_name(bridge_channel->chan));
        return;
    }
 
    if (ast_parking_park_bridge_channel(bridge_channel, payload->parkee_uuid,
        &payload->parkee_uuid[payload->parker_uuid_offset],
        payload->app_data_offset ? &payload->parkee_uuid[payload->app_data_offset] : NULL)) {
        ast_log(AST_LOG_WARNING, "Error occurred while parking %s\n",
            ast_channel_name(bridge_channel->chan));
    }
}

References bridge_park::app_data_offset, ast_channel_name(), ast_log, AST_LOG_WARNING, ast_parking_park_bridge_channel(), ast_parking_provider_registered(), ast_bridge_channel::chan, NULL, bridge_park::parkee_uuid, and bridge_park::parker_uuid_offset.

Referenced by bridge_channel_handle_action().

bridge_channel_playfile()

static void bridge_channel_playfile ( struct ast_bridge_channel *  bridge_channel, struct bridge_playfile *  payload  )

static

Definition at line 1317 of file bridge_channel.c.

{
    ast_bridge_channel_playfile(bridge_channel, payload->custom_play, payload->playfile,
        payload->moh_offset ? &payload->playfile[payload->moh_offset] : NULL);
}

References ast_bridge_channel_playfile(), bridge_playfile::custom_play, bridge_playfile::moh_offset, NULL, and bridge_playfile::playfile.

Referenced by bridge_channel_handle_action().

bridge_channel_poke()

static void bridge_channel_poke ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 260 of file bridge_channel.c.

{
    if (!pthread_equal(pthread_self(), bridge_channel->thread)) {
        /* Wake up the bridge channel thread. */
        ast_queue_frame(bridge_channel->chan, &ast_null_frame);
    }
}

References ast_null_frame, ast_queue_frame(), ast_bridge_channel::chan, and ast_bridge_channel::thread.

Referenced by ast_bridge_channel_leave_bridge_nolock().

bridge_channel_queue_action_data()

static int bridge_channel_queue_action_data ( struct ast_bridge_channel *  bridge_channel, enum bridge_channel_action_type  action, const void *  data, size_t  datalen  )

static

Definition at line 909 of file bridge_channel.c.

{
    struct ast_frame frame = {
        .frametype = AST_FRAME_BRIDGE_ACTION,
        .subclass.integer = action,
        .datalen = datalen,
        .data.ptr = (void *) data,
    };
 
    return ast_bridge_channel_queue_frame(bridge_channel, &frame);
}

References ast_bridge_channel_queue_frame(), AST_FRAME_BRIDGE_ACTION, ast_frame::data, ast_frame::datalen, and ast_frame::frametype.

Referenced by ast_bridge_channel_queue_app(), ast_bridge_channel_queue_callback(), ast_bridge_channel_queue_playfile(), bridge_channel_internal_queue_attended_transfer(), and bridge_channel_internal_queue_blind_transfer().

bridge_channel_queue_action_data_sync()

static int bridge_channel_queue_action_data_sync ( struct ast_bridge_channel *  bridge_channel, enum bridge_channel_action_type  action, const void *  data, size_t  datalen  )

static

Definition at line 937 of file bridge_channel.c.

{
    struct sync_payload *sync_payload;
    int sync_payload_len = sizeof(*sync_payload) + datalen;
    struct bridge_sync sync_struct;
    struct ast_frame frame = {
        .frametype = AST_FRAME_BRIDGE_ACTION_SYNC,
        .subclass.integer = action,
    };
 
    /* Make sure we don't end up trying to wait on ourself to deliver the frame */
    ast_assert(!pthread_equal(pthread_self(), bridge_channel->thread));
 
    sync_payload = ast_alloca(sync_payload_len);
    sync_payload->id = ast_atomic_fetchadd_int(&sync_ids, +1);
    memcpy(sync_payload->data, data, datalen);
 
    frame.datalen = sync_payload_len;
    frame.data.ptr = sync_payload;
 
    bridge_sync_init(&sync_struct, sync_payload->id);
    if (ast_bridge_channel_queue_frame(bridge_channel, &frame)) {
        bridge_sync_cleanup(&sync_struct);
        return -1;
    }
 
    bridge_sync_wait(&sync_struct);
    bridge_sync_cleanup(&sync_struct);
    return 0;
}

References ast_alloca, ast_assert, ast_atomic_fetchadd_int(), ast_bridge_channel_queue_frame(), AST_FRAME_BRIDGE_ACTION_SYNC, bridge_sync_cleanup(), bridge_sync_init(), bridge_sync_wait(), ast_frame::data, sync_payload::data, ast_frame::datalen, ast_frame::frametype, sync_payload::id, ast_frame::ptr, sync_ids, and ast_bridge_channel::thread.

Referenced by ast_bridge_channel_queue_playfile_sync().

bridge_channel_queue_deferred_frames()

void bridge_channel_queue_deferred_frames

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 825 of file bridge_channel.c.

{
    struct ast_frame *frame;
 
    ast_bridge_channel_lock(bridge_channel);
    ast_channel_lock(bridge_channel->chan);
    while ((frame = AST_LIST_REMOVE_HEAD(&bridge_channel->deferred_queue, frame_list))) {
        ast_queue_frame_head(bridge_channel->chan, frame);
        ast_frfree(frame);
    }
    ast_channel_unlock(bridge_channel->chan);
    ast_bridge_channel_unlock(bridge_channel);
}

References ast_bridge_channel_lock, ast_bridge_channel_unlock, ast_channel_lock, ast_channel_unlock, ast_frfree, AST_LIST_REMOVE_HEAD, ast_queue_frame_head(), ast_bridge_channel::chan, and ast_bridge_channel::deferred_queue.

Referenced by bridge_complete_join().

bridge_channel_run_app()

static void bridge_channel_run_app ( struct ast_bridge_channel *  bridge_channel, struct bridge_run_app *  data  )

static

Definition at line 1225 of file bridge_channel.c.

{
    ast_bridge_channel_run_app(bridge_channel, data->app_name,
        data->app_args_offset ? &data->app_name[data->app_args_offset] : NULL,
        data->moh_offset ? &data->app_name[data->moh_offset] : NULL);
}

References bridge_run_app::app_args_offset, bridge_run_app::app_name, ast_bridge_channel_run_app(), bridge_run_app::moh_offset, and NULL.

Referenced by bridge_channel_handle_action().

bridge_channel_settle_owed_events()

void bridge_channel_settle_owed_events	(	struct ast_bridge *	orig_bridge,
		struct ast_bridge_channel *	bridge_channel
	)

Definition at line 787 of file bridge_channel.c.

{
    if (bridge_channel->owed.dtmf_digit) {
        struct ast_frame frame = {
            .frametype = AST_FRAME_DTMF_END,
            .subclass.integer = bridge_channel->owed.dtmf_digit,
            .src = "Bridge channel owed DTMF",
        };
 
        frame.len = ast_tvdiff_ms(ast_tvnow(), bridge_channel->owed.dtmf_tv);
        if (frame.len < option_dtmfminduration) {
            frame.len = option_dtmfminduration;
        }
        ast_log(LOG_DTMF, "DTMF end '%c' simulated to bridge %s because %s left.  Duration %ld ms.\n",
            bridge_channel->owed.dtmf_digit, orig_bridge->uniqueid,
            ast_channel_name(bridge_channel->chan), frame.len);
        bridge_channel->owed.dtmf_digit = '\0';
        orig_bridge->technology->write(orig_bridge, NULL, &frame);
    }
    if (bridge_channel->owed.t38_terminate) {
        struct ast_control_t38_parameters t38_parameters = {
            .request_response = AST_T38_TERMINATED,
        };
        struct ast_frame frame = {
            .frametype = AST_FRAME_CONTROL,
            .subclass.integer = AST_CONTROL_T38_PARAMETERS,
            .data.ptr = &t38_parameters,
            .datalen = sizeof(t38_parameters),
            .src = "Bridge channel owed T.38 terminate",
        };
 
        ast_debug(1, "T.38 terminate simulated to bridge %s because %s left.\n",
            orig_bridge->uniqueid, ast_channel_name(bridge_channel->chan));
        bridge_channel->owed.t38_terminate = 0;
        orig_bridge->technology->write(orig_bridge, NULL, &frame);
    }
}

References ast_channel_name(), AST_CONTROL_T38_PARAMETERS, ast_debug, AST_FRAME_CONTROL, AST_FRAME_DTMF_END, ast_log, AST_T38_TERMINATED, ast_tvdiff_ms(), ast_tvnow(), ast_bridge_channel::chan, ast_bridge_channel::dtmf_digit, ast_bridge_channel::dtmf_tv, ast_frame::frametype, ast_frame::len, LOG_DTMF, NULL, option_dtmfminduration, ast_bridge_channel::owed, ast_control_t38_parameters::request_response, ast_frame::src, ast_bridge_channel::t38_terminate, ast_bridge::technology, ast_bridge::uniqueid, and ast_bridge_technology::write.

Referenced by bridge_channel_internal_join(), and bridge_do_move().

bridge_channel_suspend()

static void bridge_channel_suspend ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 858 of file bridge_channel.c.

{
    ast_bridge_channel_lock_bridge(bridge_channel);
    bridge_channel_internal_suspend_nolock(bridge_channel);
    ast_bridge_unlock(bridge_channel->bridge);
}

References ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_bridge_channel::bridge, and bridge_channel_internal_suspend_nolock().

Referenced by bridge_channel_do_callback(), bridge_channel_event_join_leave(), bridge_channel_handle_action(), and bridge_channel_handle_interval().

bridge_channel_talking()

static void bridge_channel_talking ( struct ast_bridge_channel *  bridge_channel, int  talking  )

static

Definition at line 1840 of file bridge_channel.c.

{
    struct ast_bridge_features *features = bridge_channel->features;
    struct ast_bridge_hook *hook;
    struct ao2_iterator iter;
 
    /* Run any talk detection hooks. */
    iter = ao2_iterator_init(features->other_hooks, 0);
    for (; (hook = ao2_iterator_next(&iter)); ao2_ref(hook, -1)) {
        int remove_me;
        ast_bridge_talking_indicate_callback talk_cb;
 
        if (hook->type != AST_BRIDGE_HOOK_TYPE_TALK) {
            continue;
        }
        talk_cb = (ast_bridge_talking_indicate_callback) hook->callback;
        remove_me = talk_cb(bridge_channel, hook->hook_pvt, talking);
        if (remove_me) {
            ast_debug(1, "Talk 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_TALK, 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_channel_handle_action().

bridge_channel_unsuspend()

static void bridge_channel_unsuspend ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 889 of file bridge_channel.c.

{
    ast_bridge_channel_lock_bridge(bridge_channel);
    bridge_channel_internal_unsuspend_nolock(bridge_channel);
    ast_bridge_unlock(bridge_channel->bridge);
}

References ast_bridge_channel_lock_bridge(), ast_bridge_unlock, ast_bridge_channel::bridge, and bridge_channel_internal_unsuspend_nolock().

Referenced by ast_bridge_channel_feature_digit(), bridge_channel_do_callback(), bridge_channel_event_join_leave(), bridge_channel_handle_action(), and bridge_channel_handle_interval().

bridge_channel_update_accountcodes_joining()

static void bridge_channel_update_accountcodes_joining ( struct ast_bridge_channel *  joining, struct ast_bridge_channel *  swap  )

static

Definition at line 528 of file bridge_channel.c.

{
    struct ast_bridge *bridge = joining->bridge;
    struct ast_bridge_channel *other;
    unsigned int swap_in_bridge = 0;
    unsigned int will_be_two_party;
 
    /*
     * Only update the peeraccount to match if the joining channel
     * will make it a two party bridge.
     */
    if (bridge->num_channels <= 2 && swap) {
        AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
            if (other == swap) {
                swap_in_bridge = 1;
                break;
            }
        }
    }
    will_be_two_party = (1 == bridge->num_channels - swap_in_bridge);
 
    AST_LIST_TRAVERSE(&bridge->channels, other, entry) {
        if (other == swap) {
            continue;
        }
        ast_assert(joining != other);
        ast_channel_lock_both(joining->chan, other->chan);
        channel_set_empty_accountcodes(joining->chan, other->chan);
        if (will_be_two_party) {
            channel_update_peeraccounts(joining->chan, other->chan);
        }
        ast_channel_unlock(joining->chan);
        ast_channel_unlock(other->chan);
    }
}

References ast_assert, ast_channel_lock_both, ast_channel_unlock, AST_LIST_TRAVERSE, ast_bridge_channel::bridge, ast_bridge_channel::chan, channel_set_empty_accountcodes(), channel_update_peeraccounts(), ast_bridge::channels, ast_bridge_channel::entry, ast_bridge::num_channels, and ast_bridge_channel::swap.

Referenced by ast_bridge_channel_update_accountcodes().

bridge_channel_update_accountcodes_leaving()

static void bridge_channel_update_accountcodes_leaving ( struct ast_bridge_channel *  leaving )

static

Definition at line 573 of file bridge_channel.c.

{
    struct ast_bridge *bridge = leaving->bridge;
    struct ast_bridge_channel *first;
    struct ast_bridge_channel *second;
 
    if (bridge->num_channels != 2 || bridge->dissolved) {
        return;
    }
 
    first = AST_LIST_FIRST(&bridge->channels);
    second = AST_LIST_LAST(&bridge->channels);
    ast_assert(first && first != second);
    ast_channel_lock_both(first->chan, second->chan);
    channel_set_empty_accountcodes(first->chan, second->chan);
    channel_update_peeraccounts(first->chan, second->chan);
    ast_channel_unlock(second->chan);
    ast_channel_unlock(first->chan);
}

References ast_assert, ast_channel_lock_both, ast_channel_unlock, AST_LIST_FIRST, AST_LIST_LAST, ast_bridge_channel::bridge, ast_bridge_channel::chan, channel_set_empty_accountcodes(), channel_update_peeraccounts(), ast_bridge::channels, ast_bridge::dissolved, first, and ast_bridge::num_channels.

Referenced by ast_bridge_channel_update_accountcodes().

bridge_channel_wait()

static void bridge_channel_wait ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2738 of file bridge_channel.c.

{
    int ms;
    int outfd;
    struct ast_channel *chan;
 
    /* Wait for data to either come from the channel or us to be signaled */
    ast_bridge_channel_lock(bridge_channel);
    if (bridge_channel->state != BRIDGE_CHANNEL_STATE_WAIT) {
    } else if (bridge_channel->suspended) {
/* XXX ASTERISK-21271 the external party use of suspended will go away as will these references because this is the bridge channel thread */
        ast_debug(1, "Bridge %s: %p(%s) is going into a signal wait\n",
            bridge_channel->bridge->uniqueid, bridge_channel,
            ast_channel_name(bridge_channel->chan));
        ast_cond_wait(&bridge_channel->cond, ao2_object_get_lockaddr(bridge_channel));
    } else {
        ast_bridge_channel_unlock(bridge_channel);
        outfd = -1;
        ms = bridge_channel_next_timeout(bridge_channel);
        chan = ast_waitfor_nandfds(&bridge_channel->chan, 1,
            &bridge_channel->alert_pipe[0], 1, NULL, &outfd, &ms);
        if (ast_channel_unbridged(bridge_channel->chan)) {
            ast_channel_set_unbridged(bridge_channel->chan, 0);
            ast_bridge_channel_lock_bridge(bridge_channel);
            bridge_channel->bridge->reconfigured = 1;
            bridge_reconfigured(bridge_channel->bridge, 0);
            ast_bridge_unlock(bridge_channel->bridge);
        }
        ast_bridge_channel_lock(bridge_channel);
        bridge_channel->activity = BRIDGE_CHANNEL_THREAD_FRAME;
        ast_bridge_channel_unlock(bridge_channel);
        if (!bridge_channel->suspended
            && bridge_channel->state == BRIDGE_CHANNEL_STATE_WAIT) {
            if (chan) {
                bridge_handle_trip(bridge_channel);
            } else if (ms == 0) {
                /* An interdigit timeout or interval expired. */
                bridge_channel_handle_feature_timeout(bridge_channel);
                bridge_channel_handle_interval(bridge_channel);
            } else if (-1 < outfd) {
                /*
                 * Must do this after checking timeouts or may have
                 * an infinite loop due to deferring write queue
                 * actions while trying to match DTMF feature hooks.
                 */
                bridge_channel_handle_write(bridge_channel);
            }
        }
        bridge_channel->activity = BRIDGE_CHANNEL_THREAD_IDLE;
        return;
    }
    ast_bridge_channel_unlock(bridge_channel);
}

References ast_bridge_channel::activity, ast_bridge_channel::alert_pipe, ao2_object_get_lockaddr(), ast_bridge_channel_lock, ast_bridge_channel_lock_bridge(), ast_bridge_channel_unlock, ast_bridge_unlock, ast_channel_name(), ast_channel_set_unbridged(), ast_channel_unbridged(), ast_cond_wait, ast_debug, ast_waitfor_nandfds(), ast_bridge_channel::bridge, ast_channel::bridge_channel, bridge_channel_handle_feature_timeout(), bridge_channel_handle_interval(), bridge_channel_handle_write(), bridge_channel_next_timeout(), BRIDGE_CHANNEL_STATE_WAIT, BRIDGE_CHANNEL_THREAD_FRAME, BRIDGE_CHANNEL_THREAD_IDLE, bridge_handle_trip(), bridge_reconfigured(), ast_bridge_channel::chan, ast_bridge_channel::cond, NULL, ast_bridge::reconfigured, ast_bridge_channel::state, ast_bridge_channel::suspended, and ast_bridge::uniqueid.

Referenced by bridge_channel_internal_join().

bridge_channel_write_action_data()

static int bridge_channel_write_action_data ( struct ast_bridge_channel *  bridge_channel, enum bridge_channel_action_type  action, const void *  data, size_t  datalen  )

static

Definition at line 981 of file bridge_channel.c.

{
    struct ast_frame frame = {
        .frametype = AST_FRAME_BRIDGE_ACTION,
        .subclass.integer = action,
        .datalen = datalen,
        .data.ptr = (void *) data,
    };
 
    return bridge_channel_write_frame(bridge_channel, &frame);
}

References AST_FRAME_BRIDGE_ACTION, bridge_channel_write_frame(), ast_frame::data, ast_frame::datalen, and ast_frame::frametype.

Referenced by ast_bridge_channel_write_app(), ast_bridge_channel_write_callback(), ast_bridge_channel_write_park(), ast_bridge_channel_write_playfile(), and bridge_channel_write_dtmf_stream().

bridge_channel_write_dtmf_stream()

static int bridge_channel_write_dtmf_stream ( struct ast_bridge_channel *  bridge_channel, const char *  dtmf  )

static

Definition at line 1604 of file bridge_channel.c.

{
    return bridge_channel_write_action_data(bridge_channel,
        BRIDGE_CHANNEL_ACTION_DTMF_STREAM, dtmf, strlen(dtmf) + 1);
}

References BRIDGE_CHANNEL_ACTION_DTMF_STREAM, and bridge_channel_write_action_data().

Referenced by ast_bridge_channel_feature_digit().

bridge_channel_write_frame()

static int bridge_channel_write_frame ( struct ast_bridge_channel *  bridge_channel, struct ast_frame *  frame  )

static

Definition at line 647 of file bridge_channel.c.

{
    const struct ast_control_t38_parameters *t38_parameters;
    int unmapped_stream_num;
    int deferred;
 
    ast_assert(frame->frametype != AST_FRAME_BRIDGE_ACTION_SYNC);
 
    ast_bridge_channel_lock_bridge(bridge_channel);
 
    /*
     * Map the frame to the bridge.
     * We need to lock the bridge_channel to make sure that bridge_channel->chan
     * isn't NULL and keep it locked while we do multistream processing.
     */
    ast_bridge_channel_lock(bridge_channel);
    if (bridge_channel->chan && ast_channel_is_multistream(bridge_channel->chan)) {
        unmapped_stream_num = frame->stream_num;
        switch (frame->frametype) {
        case AST_FRAME_VOICE:
        case AST_FRAME_VIDEO:
        case AST_FRAME_TEXT:
        case AST_FRAME_IMAGE:
        case AST_FRAME_RTCP:
            /* These frames need to be mapped to an appropriate write stream */
            if (frame->stream_num < 0) {
                /* Map to default stream */
                frame->stream_num = -1;
                break;
            }
            if (frame->stream_num < (int)AST_VECTOR_SIZE(&bridge_channel->stream_map.to_bridge)) {
                frame->stream_num = AST_VECTOR_GET(
                    &bridge_channel->stream_map.to_bridge, frame->stream_num);
                if (0 <= frame->stream_num) {
                    break;
                }
            }
            ast_bridge_channel_unlock(bridge_channel);
            ast_bridge_unlock(bridge_channel->bridge);
            /*
             * Ignore frame because we don't know how to map the frame
             * or the bridge is not expecting any media from that
             * stream.
             */
            return 0;
        case AST_FRAME_DTMF_BEGIN:
        case AST_FRAME_DTMF_END:
            /*
             * XXX It makes sense that DTMF could be on any audio stream.
             * For now we will only put it on the default audio stream.
             */
        default:
            frame->stream_num = -1;
            break;
        }
    } else {
        unmapped_stream_num = -1;
        frame->stream_num = -1;
    }
    ast_bridge_channel_unlock(bridge_channel);
 
    deferred = bridge_channel->bridge->technology->write(bridge_channel->bridge, bridge_channel, frame);
    if (deferred) {
        struct ast_frame *dup;
 
        dup = ast_frdup(frame);
        if (dup) {
            /*
             * We have to unmap the deferred frame so it comes back
             * in like a new frame.
             */
            dup->stream_num = unmapped_stream_num;
            ast_bridge_channel_lock(bridge_channel);
            AST_LIST_INSERT_HEAD(&bridge_channel->deferred_queue, dup, frame_list);
            ast_bridge_channel_unlock(bridge_channel);
        }
    }
 
    /* Remember any owed events to the bridge. */
    switch (frame->frametype) {
    case AST_FRAME_DTMF_BEGIN:
        bridge_channel->owed.dtmf_tv = ast_tvnow();
        bridge_channel->owed.dtmf_digit = frame->subclass.integer;
        break;
    case AST_FRAME_DTMF_END:
        bridge_channel->owed.dtmf_digit = '\0';
        break;
    case AST_FRAME_CONTROL:
        /*
         * We explicitly will not remember HOLD/UNHOLD frames because
         * things like attended transfers will handle them.
         */
        switch (frame->subclass.integer) {
        case AST_CONTROL_T38_PARAMETERS:
            t38_parameters = frame->data.ptr;
            switch (t38_parameters->request_response) {
            case AST_T38_REQUEST_NEGOTIATE:
            case AST_T38_NEGOTIATED:
                bridge_channel->owed.t38_terminate = 1;
                break;
            case AST_T38_REQUEST_TERMINATE:
            case AST_T38_TERMINATED:
            case AST_T38_REFUSED:
                bridge_channel->owed.t38_terminate = 0;
                break;
            default:
                break;
            }
            break;
        default:
            break;
        }
        break;
    default:
        break;
    }
    ast_bridge_unlock(bridge_channel->bridge);
 
    /*
     * Claim successful write to bridge.  If deferred frame
     * support is added, claim successfully deferred.
     */
    return 0;
}

References ast_assert, ast_bridge_channel_lock, ast_bridge_channel_lock_bridge(), ast_bridge_channel_unlock, ast_bridge_unlock, ast_channel_is_multistream(), AST_CONTROL_T38_PARAMETERS, AST_FRAME_BRIDGE_ACTION_SYNC, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_IMAGE, AST_FRAME_RTCP, AST_FRAME_TEXT, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frdup, AST_LIST_INSERT_HEAD, AST_T38_NEGOTIATED, AST_T38_REFUSED, AST_T38_REQUEST_NEGOTIATE, AST_T38_REQUEST_TERMINATE, AST_T38_TERMINATED, ast_tvnow(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_bridge_channel::bridge, ast_bridge_channel::chan, ast_frame::data, ast_bridge_channel::deferred_queue, ast_bridge_channel::dtmf_digit, ast_bridge_channel::dtmf_tv, ast_frame::frametype, ast_frame_subclass::integer, ast_bridge_channel::owed, ast_frame::ptr, ast_control_t38_parameters::request_response, ast_bridge_channel::stream_map, ast_frame::stream_num, ast_frame::subclass, ast_bridge_channel::t38_terminate, ast_bridge::technology, ast_bridge_channel::to_bridge, and ast_bridge_technology::write.

Referenced by ast_bridge_channel_write_control_data(), bridge_channel_write_action_data(), and bridge_handle_trip().

bridge_frame_free()

static void bridge_frame_free ( struct ast_frame *  frame )

static

Definition at line 994 of file bridge_channel.c.

{
    if (frame->frametype == AST_FRAME_BRIDGE_ACTION_SYNC) {
        struct sync_payload *sync_payload = frame->data.ptr;
        struct bridge_sync *sync;
 
        AST_RWLIST_RDLOCK(&sync_structs);
        AST_RWLIST_TRAVERSE(&sync_structs, sync, list) {
            if (sync->id == sync_payload->id) {
                break;
            }
        }
        if (sync) {
            bridge_sync_signal(sync);
        }
        AST_RWLIST_UNLOCK(&sync_structs);
    }
 
    ast_frfree(frame);
}

References AST_FRAME_BRIDGE_ACTION_SYNC, ast_frfree, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, bridge_sync_signal(), ast_frame::data, ast_frame::frametype, sync_payload::id, bridge_sync::id, bridge_sync::list, and ast_frame::ptr.

Referenced by ast_bridge_channel_queue_frame(), bridge_channel_destroy(), bridge_channel_handle_write(), bridge_handle_dtmf(), and bridge_handle_trip().

bridge_handle_dtmf()

static struct ast_frame * bridge_handle_dtmf ( struct ast_bridge_channel *  bridge_channel, struct ast_frame *  frame  )

static

Definition at line 2480 of file bridge_channel.c.

{
    struct ast_bridge_features *features = bridge_channel->features;
    struct ast_bridge_hook_dtmf *hook = NULL;
    char dtmf[2];
 
    /*
     * See if we are already matching a DTMF feature hook sequence or
     * if this DTMF matches the beginning of any DTMF feature hooks.
     */
    dtmf[0] = frame->subclass.integer;
    dtmf[1] = '\0';
    if (bridge_channel->dtmf_hook_state.collected[0]
        || (hook = ao2_find(features->dtmf_hooks, dtmf, OBJ_SEARCH_PARTIAL_KEY))) {
        enum ast_frame_type frametype = frame->frametype;
 
        bridge_frame_free(frame);
        frame = NULL;
 
        ao2_cleanup(hook);
 
        switch (frametype) {
        case AST_FRAME_DTMF_BEGIN:
            /* Just eat the frame. */
            break;
        case AST_FRAME_DTMF_END:
            ast_bridge_channel_feature_digit(bridge_channel, dtmf[0]);
            break;
        default:
            /* Unexpected frame type. */
            ast_assert(0);
            break;
        }
#ifdef TEST_FRAMEWORK
    } else if (frame->frametype == AST_FRAME_DTMF_END) {
        /* Only transmit this event on DTMF end or else every DTMF
         * press will result in the event being broadcast twice
         */
        ast_test_suite_event_notify("FEATURE_DETECTION", "Result: fail");
#endif
    }
 
    return frame;
}

References ao2_cleanup, ao2_find, ast_assert, ast_bridge_channel_feature_digit(), AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_test_suite_event_notify, bridge_frame_free(), ast_bridge_channel::collected, ast_bridge_hook_dtmf::dtmf, ast_bridge_channel::dtmf_hook_state, ast_bridge_features::dtmf_hooks, ast_bridge_channel::features, ast_frame::frametype, ast_frame_subclass::integer, NULL, OBJ_SEARCH_PARTIAL_KEY, and ast_frame::subclass.

Referenced by bridge_handle_trip().

bridge_handle_trip()

static void bridge_handle_trip ( struct ast_bridge_channel *  bridge_channel )

static

Definition at line 2540 of file bridge_channel.c.

{
    struct ast_frame *frame;
    int blocked;
 
    if (!ast_strlen_zero(ast_channel_call_forward(bridge_channel->chan))) {
        /* TODO If early bridging is ever used by anything other than ARI,
         * it's important that we actually attempt to handle the call forward
         * attempt, as well as expand features on a bridge channel to allow/disallow
         * call forwarding. For now, all we do is raise an event, showing that
         * a call forward is being attempted.
         */
        ast_channel_publish_dial_forward(NULL, bridge_channel->chan, NULL, NULL, "CANCEL",
            ast_channel_call_forward(bridge_channel->chan));
    }
 
    if (bridge_channel->features->mute) {
        frame = ast_read_stream_noaudio(bridge_channel->chan);
    } else {
        frame = ast_read_stream(bridge_channel->chan);
    }
 
    if (!frame) {
        ast_bridge_channel_kick(bridge_channel, 0);
        return;
    }
 
    if (!ast_channel_is_multistream(bridge_channel->chan)) {
        /* This may not be initialized by non-multistream channel drivers */
        frame->stream_num = -1;
    }
 
    switch (frame->frametype) {
    case AST_FRAME_CONTROL:
        switch (frame->subclass.integer) {
        case AST_CONTROL_CONGESTION:
        case AST_CONTROL_BUSY:
            ast_channel_publish_dial(NULL, bridge_channel->chan, NULL, controls[frame->subclass.integer]);
            break;
        case AST_CONTROL_HANGUP:
            ast_bridge_channel_kick(bridge_channel, 0);
            bridge_frame_free(frame);
            return;
        case AST_CONTROL_RINGING:
        case AST_CONTROL_PROGRESS:
        case AST_CONTROL_PROCEEDING:
        case AST_CONTROL_ANSWER:
            ast_channel_publish_dial(NULL, bridge_channel->chan, NULL, controls[frame->subclass.integer]);
            break;
        case AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE:
            ast_bridge_channel_lock_bridge(bridge_channel);
            blocked = bridge_channel->bridge->technology->stream_topology_request_change
                && bridge_channel->bridge->technology->stream_topology_request_change(
                    bridge_channel->bridge, bridge_channel);
            ast_bridge_unlock(bridge_channel->bridge);
            if (blocked) {
                /*
                 * Topology change was intercepted by the bridge technology
                 * so drop frame.
                 */
                bridge_frame_free(frame);
                return;
            }
            break;
        case AST_CONTROL_STREAM_TOPOLOGY_CHANGED:
            /*
             * If a stream topology has changed then the bridge_channel's
             * media mapping needs to be updated.
             */
            ast_bridge_channel_lock_bridge(bridge_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);
            }
            ast_bridge_unlock(bridge_channel->bridge);
            break;
        default:
            break;
        }
        break;
    case AST_FRAME_DTMF_BEGIN:
    case AST_FRAME_DTMF_END:
        frame = bridge_handle_dtmf(bridge_channel, frame);
        if (!frame) {
            return;
        }
        if (!bridge_channel->features->dtmf_passthrough) {
            bridge_frame_free(frame);
            return;
        }
        break;
    default:
        break;
    }
 
    /* Simply write the frame out to the bridge technology. */
    bridge_channel_write_frame(bridge_channel, frame);
    bridge_frame_free(frame);
}

References ast_bridge_channel_kick(), ast_bridge_channel_lock_bridge(), ast_bridge_channel_stream_map(), ast_bridge_unlock, ast_channel_call_forward(), ast_channel_is_multistream(), ast_channel_publish_dial(), ast_channel_publish_dial_forward(), AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_PROCEEDING, AST_CONTROL_PROGRESS, AST_CONTROL_RINGING, AST_CONTROL_STREAM_TOPOLOGY_CHANGED, AST_CONTROL_STREAM_TOPOLOGY_REQUEST_CHANGE, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, ast_read_stream(), ast_read_stream_noaudio(), ast_strlen_zero(), ast_bridge_channel::bridge, bridge_channel_write_frame(), bridge_frame_free(), bridge_handle_dtmf(), ast_bridge_channel::chan, controls, ast_bridge_features::dtmf_passthrough, ast_bridge_channel::features, ast_frame::frametype, ast_frame_subclass::integer, ast_bridge_features::mute, NULL, ast_frame::stream_num, ast_bridge_technology::stream_topology_changed, ast_bridge_technology::stream_topology_request_change, ast_frame::subclass, and ast_bridge::technology.

Referenced by bridge_channel_wait().

bridge_sync_cleanup()

static void bridge_sync_cleanup ( struct bridge_sync *  sync_struct )

static

Clean up a synchronization bridge object.

This frees fields within the synchronization object and removes it from the list of active synchronization objects.

Since synchronization objects are stack-allocated, it is vital that this is called before the synchronization object goes out of scope.

Parameters

sync_struct

Synchronization object to clean up.

Definition at line 148 of file bridge_channel.c.

{
    struct bridge_sync *iter;
 
    AST_RWLIST_WRLOCK(&sync_structs);
    AST_LIST_TRAVERSE_SAFE_BEGIN(&sync_structs, iter, list) {
        if (iter->id == sync_struct->id) {
            AST_LIST_REMOVE_CURRENT(list);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&sync_structs);
 
    ast_sem_destroy(&sync_struct->sem);
}

References AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sem_destroy(), bridge_sync::id, bridge_sync::list, and bridge_sync::sem.

Referenced by bridge_channel_queue_action_data_sync().

bridge_sync_init()

static void bridge_sync_init ( struct bridge_sync *  sync_struct, unsigned int  id  )

static

Initialize a synchronous bridge object.

This both initializes the structure and adds it to the list of synchronization structures.

Parameters

sync_struct	The synchronization object to initialize.
id	ID to assign to the synchronization object.

Definition at line 125 of file bridge_channel.c.

{
    memset(sync_struct, 0, sizeof(*sync_struct));
    sync_struct->id = id;
    ast_sem_init(&sync_struct->sem, 0, 0);
 
    AST_RWLIST_WRLOCK(&sync_structs);
    AST_RWLIST_INSERT_TAIL(&sync_structs, sync_struct, list);
    AST_RWLIST_UNLOCK(&sync_structs);
}

References AST_RWLIST_INSERT_TAIL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_sem_init(), id, bridge_sync::id, and bridge_sync::sem.

Referenced by bridge_channel_queue_action_data_sync().

bridge_sync_signal()

static void bridge_sync_signal ( struct bridge_sync *  sync_struct )

static

Signal that waiting for a synchronous bridge action is no longer necessary.

This may occur for several reasons

• The synchronous bridge action has completed.
• The bridge channel has been removed from the bridge.
• The synchronous bridge action could not be queued.

Parameters

sync_struct

Synchronization object corresponding to the bridge action.

Definition at line 207 of file bridge_channel.c.

{
    ast_sem_post(&sync_struct->sem);
}

References ast_sem_post(), and bridge_sync::sem.

Referenced by bridge_frame_free().

bridge_sync_wait()

static void bridge_sync_wait ( struct bridge_sync *  sync_struct )

static

Wait for a synchronous bridge action to complete.

Parameters

sync_struct

Synchronization object corresponding to the bridge action.

Definition at line 186 of file bridge_channel.c.

{
    struct timeval timeout_val = ast_tvadd(ast_tvnow(), ast_samp2tv(PLAYBACK_TIMEOUT, 1000));
    struct timespec timeout_spec = {
        .tv_sec = timeout_val.tv_sec,
        .tv_nsec = timeout_val.tv_usec * 1000,
    };
 
    ast_sem_timedwait(&sync_struct->sem, &timeout_spec);
}

References ast_samp2tv(), ast_sem_timedwait(), ast_tvadd(), ast_tvnow(), PLAYBACK_TIMEOUT, and bridge_sync::sem.

Referenced by bridge_channel_queue_action_data_sync().

channel_fill_empty_accountcode()

static void channel_fill_empty_accountcode ( struct ast_channel *  dest, struct ast_channel *  src  )

static

Definition at line 450 of file bridge_channel.c.

{
    if (ast_strlen_zero(ast_channel_accountcode(dest))
        && !ast_strlen_zero(ast_channel_peeraccount(src))) {
        ast_debug(1, "Setting channel %s accountcode with channel %s peeraccount '%s'.\n",
            ast_channel_name(dest),
            ast_channel_name(src), ast_channel_peeraccount(src));
        ast_channel_accountcode_set(dest, ast_channel_peeraccount(src));
    }
}

References ast_channel_accountcode(), ast_channel_name(), ast_channel_peeraccount(), ast_debug, and ast_strlen_zero().

Referenced by channel_set_empty_accountcodes().

channel_fill_empty_peeraccount()

static void channel_fill_empty_peeraccount ( struct ast_channel *  dest, struct ast_channel *  src  )

static

Definition at line 429 of file bridge_channel.c.

{
    if (ast_strlen_zero(ast_channel_peeraccount(dest))
        && !ast_strlen_zero(ast_channel_accountcode(src))) {
        ast_debug(1, "Setting channel %s peeraccount with channel %s accountcode '%s'.\n",
            ast_channel_name(dest),
            ast_channel_name(src), ast_channel_accountcode(src));
        ast_channel_peeraccount_set(dest, ast_channel_accountcode(src));
    }
}

References ast_channel_accountcode(), ast_channel_name(), ast_channel_peeraccount(), ast_debug, and ast_strlen_zero().

Referenced by channel_set_empty_accountcodes().

channel_set_cause()

static int channel_set_cause ( struct ast_channel *  chan, int  cause  )

static

Definition at line 279 of file bridge_channel.c.

{
    int current_cause;
    ast_channel_lock(chan);
    current_cause = ast_channel_hangupcause(chan);
 
    /* if the hangupcause is already set, leave it */
    if (current_cause > 0) {
        ast_channel_unlock(chan);
        return current_cause;
    }
 
    if (cause <= 0) {
        cause = ast_channel_hangupcause(chan);
        if (cause <= 0) {
            cause = AST_CAUSE_NORMAL_CLEARING;
        }
    }
 
    ast_channel_hangupcause_set(chan, cause);
    ast_channel_unlock(chan);
    return cause;
}

References AST_CAUSE_NORMAL_CLEARING, ast_channel_hangupcause(), ast_channel_hangupcause_set(), ast_channel_lock, and ast_channel_unlock.

Referenced by ast_bridge_channel_kick(), and ast_bridge_channel_leave_bridge_nolock().

channel_set_empty_accountcodes()

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

static

Definition at line 471 of file bridge_channel.c.

{
    /* Set empty peeraccount from the other channel's accountcode. */
    channel_fill_empty_peeraccount(c0, c1);
    channel_fill_empty_peeraccount(c1, c0);
 
    /* Set empty accountcode from the other channel's peeraccount. */
    channel_fill_empty_accountcode(c0, c1);
    channel_fill_empty_accountcode(c1, c0);
}

References channel_fill_empty_accountcode(), and channel_fill_empty_peeraccount().

Referenced by bridge_channel_update_accountcodes_joining(), and bridge_channel_update_accountcodes_leaving().

channel_update_peeraccount()

static void channel_update_peeraccount ( struct ast_channel *  dest, struct ast_channel *  src  )

static

Definition at line 492 of file bridge_channel.c.

{
    if (strcmp(ast_channel_accountcode(src), ast_channel_peeraccount(dest))) {
        ast_debug(1, "Changing channel %s peeraccount '%s' to match channel %s accountcode '%s'.\n",
            ast_channel_name(dest), ast_channel_peeraccount(dest),
            ast_channel_name(src), ast_channel_accountcode(src));
        ast_channel_peeraccount_set(dest, ast_channel_accountcode(src));
    }
}

References ast_channel_accountcode(), ast_channel_name(), ast_channel_peeraccount(), and ast_debug.

Referenced by channel_update_peeraccounts().

channel_update_peeraccounts()

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

static

Definition at line 512 of file bridge_channel.c.

{
    channel_update_peeraccount(c0, c1);
    channel_update_peeraccount(c1, c0);
}

References channel_update_peeraccount().

Referenced by bridge_channel_update_accountcodes_joining(), and bridge_channel_update_accountcodes_leaving().

payload_helper_app()

static int payload_helper_app ( ast_bridge_channel_post_action_data  post_it, struct ast_bridge_channel *  bridge_channel, const char *  app_name, const char *  app_args, const char *  moh_class  )

static

Definition at line 1236 of file bridge_channel.c.

{
    struct bridge_run_app *app_data;
    size_t len_name = strlen(app_name) + 1;
    size_t len_args = ast_strlen_zero(app_args) ? 0 : strlen(app_args) + 1;
    size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
    size_t len_data = sizeof(*app_data) + len_name + len_args + len_moh;
 
    /* Fill in application run frame data. */
    app_data = alloca(len_data);
    app_data->app_args_offset = len_args ? len_name : 0;
    app_data->moh_offset = len_moh ? len_name + len_args : 0;
    strcpy(app_data->app_name, app_name);/* Safe */
    if (len_args) {
        strcpy(&app_data->app_name[app_data->app_args_offset], app_args);/* Safe */
    }
    if (moh_class) {
        strcpy(&app_data->app_name[app_data->moh_offset], moh_class);/* Safe */
    }
 
    return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_RUN_APP, app_data, len_data);
}

References app_name(), ast_strlen_zero(), and BRIDGE_CHANNEL_ACTION_RUN_APP.

Referenced by ast_bridge_channel_queue_app(), and ast_bridge_channel_write_app().

payload_helper_cb()

static int payload_helper_cb ( ast_bridge_channel_post_action_data  post_it, struct ast_bridge_channel *  bridge_channel, enum ast_bridge_channel_custom_callback_option  flags, ast_bridge_custom_callback_fn  callback, const void *  payload, size_t  payload_size  )

static

Definition at line 1404 of file bridge_channel.c.

{
    struct bridge_custom_callback *cb_data;
    size_t len_data = sizeof(*cb_data) + (payload ? payload_size : 0);
 
    /* Sanity check. */
    if (!callback) {
        ast_assert(0);
        return -1;
    }
 
    /* Fill in custom callback frame data. */
    cb_data = alloca(len_data);
    cb_data->callback = callback;
    cb_data->payload_size = payload_size;
    cb_data->flags = flags;
    cb_data->payload_exists = payload && payload_size;
    if (cb_data->payload_exists) {
        memcpy(cb_data->payload, payload, payload_size);/* Safe */
    }
 
    return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_CALLBACK, cb_data, len_data);
}

References ast_assert, BRIDGE_CHANNEL_ACTION_CALLBACK, bridge_custom_callback::callback, callback(), bridge_custom_callback::flags, bridge_custom_callback::payload, bridge_custom_callback::payload_exists, and bridge_custom_callback::payload_size.

Referenced by ast_bridge_channel_queue_callback(), and ast_bridge_channel_write_callback().

payload_helper_park()

static int payload_helper_park ( ast_bridge_channel_post_action_data  post_it, struct ast_bridge_channel *  bridge_channel, const char *  parkee_uuid, const char *  parker_uuid, const char *  app_data  )

static

Definition at line 1478 of file bridge_channel.c.

{
    struct bridge_park *payload;
    size_t len_parkee_uuid = strlen(parkee_uuid) + 1;
    size_t len_parker_uuid = strlen(parker_uuid) + 1;
    size_t len_app_data = !app_data ? 0 : strlen(app_data) + 1;
    size_t len_payload = sizeof(*payload) + len_parker_uuid + len_parkee_uuid + len_app_data;
 
    payload = alloca(len_payload);
    payload->app_data_offset = len_app_data ? len_parkee_uuid + len_parker_uuid : 0;
    payload->parker_uuid_offset = len_parkee_uuid;
    strcpy(payload->parkee_uuid, parkee_uuid);
    strcpy(&payload->parkee_uuid[payload->parker_uuid_offset], parker_uuid);
    if (app_data) {
        strcpy(&payload->parkee_uuid[payload->app_data_offset], app_data);
    }
 
    return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_PARK, payload, len_payload);
}

References bridge_park::app_data_offset, BRIDGE_CHANNEL_ACTION_PARK, bridge_park::parkee_uuid, and bridge_park::parker_uuid_offset.

Referenced by ast_bridge_channel_write_park().

payload_helper_playfile()

static int payload_helper_playfile ( ast_bridge_channel_post_action_data  post_it, struct ast_bridge_channel *  bridge_channel, ast_bridge_custom_play_fn  custom_play, const char *  playfile, const char *  moh_class  )

static

Definition at line 1327 of file bridge_channel.c.

{
    struct bridge_playfile *payload;
    size_t len_name = strlen(playfile) + 1;
    size_t len_moh = !moh_class ? 0 : strlen(moh_class) + 1;
    size_t len_payload = sizeof(*payload) + len_name + len_moh;
 
    /* Fill in play file frame data. */
    payload = ast_alloca(len_payload);
    payload->custom_play = custom_play;
    payload->moh_offset = len_moh ? len_name : 0;
    strcpy(payload->playfile, playfile);/* Safe */
    if (moh_class) {
        strcpy(&payload->playfile[payload->moh_offset], moh_class);/* Safe */
    }
 
    return post_it(bridge_channel, BRIDGE_CHANNEL_ACTION_PLAY_FILE, payload, len_payload);
}

References ast_alloca, BRIDGE_CHANNEL_ACTION_PLAY_FILE, bridge_playfile::custom_play, bridge_playfile::moh_offset, and bridge_playfile::playfile.

Referenced by ast_bridge_channel_queue_playfile(), ast_bridge_channel_queue_playfile_sync(), and ast_bridge_channel_write_playfile().

run_app_helper()

static int run_app_helper ( struct ast_channel *  chan, const char *  app_name, const char *  app_args  )

static

Definition at line 1182 of file bridge_channel.c.

{
    int res = 0;
 
    if (!strcasecmp("Gosub", app_name)) {
        ast_app_exec_sub(NULL, chan, app_args, 0);
    } else {
        res = ast_pbx_exec_application(chan, app_name, app_args);
    }
    return res;
}

References app_name(), ast_app_exec_sub(), ast_pbx_exec_application(), and NULL.

Referenced by ast_bridge_channel_run_app().

sendtext_safe()

static void sendtext_safe ( struct ast_channel *  chan, const struct ast_frame *  f  )

static

Definition at line 2340 of file bridge_channel.c.

{
    if (f->datalen) {
        char *text = f->data.ptr;
 
        if (text[f->datalen - 1]) {
            /* Not zero terminated, we need to allocate */
            text = ast_strndup(text, f->datalen);
            if (!text) {
                return;
            }
        }
 
        ast_sendtext(chan, text);
 
        if (text != f->data.ptr) {
            /* Only free if we allocated */
            ast_free(text);
        }
    } else {
        /* Special case if the frame length is zero (although I
         * am not sure this is possible?) */
        ast_sendtext(chan, "");
    }
}

References ast_free, ast_sendtext(), ast_strndup, ast_frame::data, ast_frame::datalen, ast_frame::ptr, and text.

Referenced by bridge_channel_handle_write().

testsuite_notify_feature_success()

static void testsuite_notify_feature_success ( struct ast_channel *  chan, const char *  dtmf  )

static

Definition at line 1620 of file bridge_channel.c.

{
#ifdef TEST_FRAMEWORK
    char *feature = "unknown";
    struct ast_featuremap_config *featuremap;
    struct ast_features_xfer_config *xfer;
 
    ast_channel_lock(chan);
    featuremap = ast_get_chan_featuremap_config(chan);
    xfer = ast_get_chan_features_xfer_config(chan);
    ast_channel_unlock(chan);
 
    if (featuremap) {
        if (!strcmp(dtmf, featuremap->blindxfer)) {
            feature = "blindxfer";
        } else if (!strcmp(dtmf, featuremap->atxfer)) {
            feature = "atxfer";
        } else if (!strcmp(dtmf, featuremap->disconnect)) {
            feature = "disconnect";
        } else if (!strcmp(dtmf, featuremap->automixmon)) {
            feature = "automixmon";
        } else if (!strcmp(dtmf, featuremap->parkcall)) {
            feature = "parkcall";
        }
    }
    if (xfer) {
        if (!strcmp(dtmf, xfer->atxferthreeway)) {
            feature = "atxferthreeway";
        }
    }
 
    ao2_cleanup(featuremap);
    ao2_cleanup(xfer);
 
    ast_test_suite_event_notify("FEATURE_DETECTION",
            "Result: success\r\n"
            "Feature: %s", feature);
#endif /* TEST_FRAMEWORK */
}

References ao2_cleanup, ast_channel_lock, ast_channel_unlock, ast_get_chan_featuremap_config(), ast_get_chan_features_xfer_config(), ast_test_suite_event_notify, ast_featuremap_config::atxfer, ast_features_xfer_config::atxferthreeway, ast_featuremap_config::automixmon, ast_featuremap_config::blindxfer, ast_featuremap_config::disconnect, and ast_featuremap_config::parkcall.

Referenced by ast_bridge_channel_feature_digit().

Variable Documentation

controls

const char* controls[]

static

Definition at line 2525 of file bridge_channel.c.

Referenced by bridge_handle_trip().

sync_ids

int sync_ids

static

Counter used for assigning synchronous bridge action IDs.

Definition at line 79 of file bridge_channel.c.

Referenced by bridge_channel_queue_action_data_sync().

sync_structs

struct sync_structs sync_structs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static