bridge_channel_internal.h File Reference

Private Bridging Channel API. More...

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	bridge_channel_action_type {   BRIDGE_CHANNEL_ACTION_DTMF_STREAM , BRIDGE_CHANNEL_ACTION_TALKING_START , BRIDGE_CHANNEL_ACTION_TALKING_STOP , BRIDGE_CHANNEL_ACTION_PLAY_FILE ,   BRIDGE_CHANNEL_ACTION_RUN_APP , BRIDGE_CHANNEL_ACTION_CALLBACK , BRIDGE_CHANNEL_ACTION_PARK , BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER ,   BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER , BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY = 1000 , BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING }

Functions
void	bridge_channel_impart_signal (struct ast_channel *chan)
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)
void	bridge_channel_queue_deferred_frames (struct ast_bridge_channel *bridge_channel)
void	bridge_channel_settle_owed_events (struct ast_bridge *orig_bridge, struct ast_bridge_channel *bridge_channel)

Detailed Description

Private Bridging Channel API.

Author

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

A private API to manipulate channels in a bridge. These can be called on a channel in a bridge by bridge.c. These functions should not be called elsewhere, including by other members of the Bridging API.

See Also:

• Bridging API
• CREDITS

Definition in file bridge_channel_internal.h.

Enumeration Type Documentation

bridge_channel_action_type

enum bridge_channel_action_type

Enumerator
BRIDGE_CHANNEL_ACTION_DTMF_STREAM	Bridged channel is to send a DTMF stream out
BRIDGE_CHANNEL_ACTION_TALKING_START	Bridged channel is to indicate talking start
BRIDGE_CHANNEL_ACTION_TALKING_STOP	Bridged channel is to indicate talking stop
BRIDGE_CHANNEL_ACTION_PLAY_FILE	Bridge channel is to play the indicated sound file.
BRIDGE_CHANNEL_ACTION_RUN_APP	Bridge channel is to run the indicated application.
BRIDGE_CHANNEL_ACTION_CALLBACK	Bridge channel is to run the custom callback routine.
BRIDGE_CHANNEL_ACTION_PARK	Bridge channel is to get parked.
BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER	Bridge channel is to execute a blind transfer.
BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER	Bridge channel is to execute an attended transfer
BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY	Bridge reconfiguration deferred technology destruction.
BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING	Bridge deferred dissolving.

Definition at line 41 of file bridge_channel_internal.h.

                                {
    /*! Bridged channel is to send a DTMF stream out */
    BRIDGE_CHANNEL_ACTION_DTMF_STREAM,
    /*! Bridged channel is to indicate talking start */
    BRIDGE_CHANNEL_ACTION_TALKING_START,
    /*! Bridged channel is to indicate talking stop */
    BRIDGE_CHANNEL_ACTION_TALKING_STOP,
    /*! Bridge channel is to play the indicated sound file. */
    BRIDGE_CHANNEL_ACTION_PLAY_FILE,
    /*! Bridge channel is to run the indicated application. */
    BRIDGE_CHANNEL_ACTION_RUN_APP,
    /*! Bridge channel is to run the custom callback routine. */
    BRIDGE_CHANNEL_ACTION_CALLBACK,
    /*! Bridge channel is to get parked. */
    BRIDGE_CHANNEL_ACTION_PARK,
    /*! Bridge channel is to execute a blind transfer. */
    BRIDGE_CHANNEL_ACTION_BLIND_TRANSFER,
    /*! Bridge channel is to execute an attended transfer */
    BRIDGE_CHANNEL_ACTION_ATTENDED_TRANSFER,
 
    /*
     * Bridge actions put after this comment must never be put onto
     * the bridge_channel wr_queue because they have other resources
     * that must be freed.
     */
 
    /*! Bridge reconfiguration deferred technology destruction. */
    BRIDGE_CHANNEL_ACTION_DEFERRED_TECH_DESTROY = 1000,
    /*! Bridge deferred dissolving. */
    BRIDGE_CHANNEL_ACTION_DEFERRED_DISSOLVING,
};

Function Documentation

bridge_channel_impart_signal()

void bridge_channel_impart_signal

(

struct ast_channel *

chan

)

Definition at line 1582 of file bridge.c.

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

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

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

bridge_channel_internal_alloc()

struct ast_bridge_channel * bridge_channel_internal_alloc

(

struct ast_bridge *

bridge

)

Definition at line 3096 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 3055 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 2820 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 2108 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 2245 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 2165 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::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 3033 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 3007 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 829 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 855 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_queue_deferred_frames()

void bridge_channel_queue_deferred_frames

(

struct ast_bridge_channel *

bridge_channel

)

Definition at line 815 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_settle_owed_events()

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

Definition at line 777 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().