Channel Bridging API. More...
#include "asterisk.h"
#include <signal.h>
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/bridging.h"
#include "asterisk/bridging_technology.h"
#include "asterisk/app.h"
#include "asterisk/file.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
Go to the source code of this file.
Data Structures | |
struct | bridge_technologies |
Defines | |
#define | BRIDGE_ARRAY_GROW 32 |
#define | BRIDGE_ARRAY_START 128 |
Functions | |
int | __ast_bridge_technology_register (struct ast_bridge_technology *technology, struct ast_module *module) |
Register a bridge technology for use. | |
static void | __fini_bridge_technologies (void) |
static void | __init_bridge_technologies (void) |
void | ast_bridge_change_state (struct ast_bridge_channel *bridge_channel, enum ast_bridge_channel_state new_state) |
Change the state of a bridged channel. | |
int | ast_bridge_check (int capabilities) |
See if it is possible to create a bridge. | |
int | ast_bridge_depart (struct ast_bridge *bridge, struct ast_channel *chan) |
Depart a channel from a bridge. | |
int | ast_bridge_destroy (struct ast_bridge *bridge) |
Destroy a bridge. | |
int | ast_bridge_dtmf_stream (struct ast_bridge *bridge, const char *dtmf, struct ast_channel *chan) |
Play a DTMF stream into a bridge, optionally not to a given channel. | |
int | ast_bridge_features_cleanup (struct ast_bridge_features *features) |
Clean up the contents of a bridge features structure. | |
int | ast_bridge_features_enable (struct ast_bridge_features *features, enum ast_bridge_builtin_feature feature, const char *dtmf, void *config) |
Enable a built in feature on a bridge features structure. | |
int | ast_bridge_features_hook (struct ast_bridge_features *features, const char *dtmf, ast_bridge_features_hook_callback callback, void *hook_pvt) |
Attach a custom hook to a bridge features structure. | |
int | ast_bridge_features_init (struct ast_bridge_features *features) |
Initialize bridge features structure. | |
int | ast_bridge_features_register (enum ast_bridge_builtin_feature feature, ast_bridge_features_hook_callback callback, const char *dtmf) |
Register a handler for a built in feature. | |
int | ast_bridge_features_set_flag (struct ast_bridge_features *features, enum ast_bridge_feature_flags flag) |
Set a flag on a bridge features structure. | |
int | ast_bridge_features_unregister (enum ast_bridge_builtin_feature feature) |
Unregister a handler for a built in feature. | |
void | ast_bridge_handle_trip (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_channel *chan, int outfd) |
Feed notification that a frame is waiting on a channel into the bridging core. | |
int | ast_bridge_impart (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features) |
Impart (non-blocking) a channel on a bridge. | |
enum ast_bridge_channel_state | ast_bridge_join (struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features) |
Join (blocking) a channel to a bridge. | |
int | ast_bridge_merge (struct ast_bridge *bridge0, struct ast_bridge *bridge1) |
Merge two bridges together. | |
struct ast_bridge * | ast_bridge_new (int capabilities, int flags) |
Create a new bridge. | |
int | ast_bridge_remove (struct ast_bridge *bridge, struct ast_channel *chan) |
Remove a channel from a bridge. | |
int | ast_bridge_suspend (struct ast_bridge *bridge, struct ast_channel *chan) |
Suspend a channel temporarily from a bridge. | |
void | ast_bridge_technology_suspend (struct ast_bridge_technology *technology) |
Suspend a bridge technology from consideration. | |
int | ast_bridge_technology_unregister (struct ast_bridge_technology *technology) |
Unregister a bridge technology from use. | |
void | ast_bridge_technology_unsuspend (struct ast_bridge_technology *technology) |
Unsuspend a bridge technology. | |
int | ast_bridge_unsuspend (struct ast_bridge *bridge, struct ast_channel *chan) |
Unsuspend a channel from a bridge. | |
static void | bridge_array_add (struct ast_bridge *bridge, struct ast_channel *chan) |
Helper function to add a channel to the bridge array. | |
static void | bridge_array_remove (struct ast_bridge *bridge, struct ast_channel *chan) |
Helper function to remove a channel from the bridge array. | |
static void | bridge_channel_dtmf_stream (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
Internal function that plays back DTMF on a bridge channel. | |
static void | bridge_channel_feature (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
Internal function that executes a feature on a bridge channel. | |
static enum ast_bridge_channel_state | bridge_channel_join (struct ast_bridge_channel *bridge_channel) |
Join a channel to a bridge and handle anything the bridge may want us to do. | |
static enum ast_bridge_channel_state | bridge_channel_join_multithreaded (struct ast_bridge_channel *bridge_channel) |
Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve. | |
static enum ast_bridge_channel_state | bridge_channel_join_singlethreaded (struct ast_bridge_channel *bridge_channel) |
Run in a singlethreaded model. Each joined channel yields itself to the main bridge thread. TODO: Improve. | |
static void | bridge_channel_suspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
Internal function that suspends a channel from a bridge. | |
static void * | bridge_channel_thread (void *data) |
Thread responsible for imparted bridged channels. | |
static void | bridge_channel_unsuspend (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
Internal function that unsuspends a channel from a bridge. | |
static void | bridge_check_dissolve (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
Internal function to see whether a bridge should dissolve, and if so do it. | |
static int | bridge_drop_control_frame (int subclass) |
Internal function used to determine whether a control frame should be dropped or not. | |
static struct ast_frame * | bridge_handle_dtmf (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, struct ast_frame *frame) |
Internal function to handle DTMF from a channel. | |
static int | bridge_make_compatible (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel) |
static void | bridge_poke (struct ast_bridge *bridge) |
Helper function to poke the bridge thread. | |
static void * | bridge_thread (void *data) |
Bridge thread function. | |
static void | destroy_bridge (void *obj) |
static struct ast_bridge_technology * | find_best_technology (int capabilities) |
Helper function used to find the "best" bridge technology given a specified capabilities. | |
static struct ast_bridge_channel * | find_bridge_channel (struct ast_bridge *bridge, struct ast_channel *chan) |
Helper function to find a bridge channel given a channel. | |
static int | generic_thread_loop (struct ast_bridge *bridge) |
Generic thread loop, TODO: Rethink this/improve it. | |
static int | smart_bridge_operation (struct ast_bridge *bridge, struct ast_bridge_channel *bridge_channel, int count) |
Perform the smart bridge operation. Basically sees if a new bridge technology should be used instead of the current one. | |
Variables | |
static struct bridge_technologies | bridge_technologies |
static char | builtin_features_dtmf [AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING] |
static void * | builtin_features_handlers [AST_BRIDGE_BUILTIN_END] |
Channel Bridging API.
Definition in file bridging.c.
#define BRIDGE_ARRAY_GROW 32 |
Definition at line 51 of file bridging.c.
Referenced by bridge_array_add().
#define BRIDGE_ARRAY_START 128 |
Definition at line 48 of file bridging.c.
Referenced by ast_bridge_new().
int __ast_bridge_technology_register | ( | struct ast_bridge_technology * | technology, |
struct ast_module * | mod | ||
) |
Register a bridge technology for use.
technology | The bridge technology to register |
module | The module that is registering the bridge technology |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_technology_register(&simple_bridge_tech);
This registers a bridge technology declared as the structure simple_bridge_tech with the bridging core and makes it available for use when creating bridges.
Definition at line 59 of file bridging.c.
References ast_log(), AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), ast_verbose(), ast_bridge_technology::capabilities, LOG_WARNING, ast_bridge_technology::mod, ast_bridge_technology::name, option_verbose, VERBOSE_PREFIX_2, and ast_bridge_technology::write.
{ struct ast_bridge_technology *current = NULL; /* Perform a sanity check to make sure the bridge technology conforms to our needed requirements */ if (ast_strlen_zero(technology->name) || !technology->capabilities || !technology->write) { ast_log(LOG_WARNING, "Bridge technology %s failed registration sanity check.\n", technology->name); return -1; } AST_RWLIST_WRLOCK(&bridge_technologies); /* Look for duplicate bridge technology already using this name, or already registered */ AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) { if ((!strcasecmp(current->name, technology->name)) || (current == technology)) { ast_log(LOG_WARNING, "A bridge technology of %s already claims to exist in our world.\n", technology->name); AST_RWLIST_UNLOCK(&bridge_technologies); return -1; } } /* Copy module pointer so reference counting can keep the module from unloading */ technology->mod = module; /* Insert our new bridge technology into the list and print out a pretty message */ AST_RWLIST_INSERT_TAIL(&bridge_technologies, technology, entry); AST_RWLIST_UNLOCK(&bridge_technologies); if (option_verbose > 1) { ast_verbose(VERBOSE_PREFIX_2 "Registered bridge technology %s\n", technology->name); } return 0; }
static void __fini_bridge_technologies | ( | void | ) | [static] |
Definition at line 45 of file bridging.c.
{
static void __init_bridge_technologies | ( | void | ) | [static] |
Definition at line 45 of file bridging.c.
{
void ast_bridge_change_state | ( | struct ast_bridge_channel * | bridge_channel, |
enum ast_bridge_channel_state | new_state | ||
) |
Change the state of a bridged channel.
bridge_channel | Channel to change the state on |
new_state | The new state to place the channel into |
Example usage:
ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT);
This places the channel pointed to by bridge_channel into the state AST_BRIDGE_CHANNEL_STATE_WAIT.
Definition at line 118 of file bridging.c.
References ast_cond_signal(), ast_mutex_lock(), ast_mutex_unlock(), ast_bridge_channel::cond, ast_bridge_channel::lock, ast_bridge_channel::state, and ast_bridge_channel::thread.
Referenced by ast_bridge_depart(), ast_bridge_destroy(), ast_bridge_dtmf_stream(), ast_bridge_handle_trip(), ast_bridge_remove(), attended_abort_transfer(), attended_threeway_transfer(), bridge_channel_dtmf_stream(), bridge_channel_feature(), bridge_channel_join(), bridge_check_dissolve(), bridge_handle_dtmf(), feature_attended_transfer(), feature_blind_transfer(), and feature_hangup().
{ /* Change the state on the bridge channel */ bridge_channel->state = new_state; /* Only poke the channel's thread if it is not us */ if (!pthread_equal(pthread_self(), bridge_channel->thread)) { pthread_kill(bridge_channel->thread, SIGURG); ast_mutex_lock(&bridge_channel->lock); ast_cond_signal(&bridge_channel->cond); ast_mutex_unlock(&bridge_channel->lock); } return; }
int ast_bridge_check | ( | int | capabilities | ) |
See if it is possible to create a bridge.
capabilities | The capabilities that the bridge will use |
1 | if possible |
0 | if not possible |
Example usage:
int possible = ast_bridge_check(AST_BRIDGE_CAPABILITY_1TO1MIX);
This sees if it is possible to create a bridge capable of bridging two channels together.
Definition at line 501 of file bridging.c.
References ast_module_unref(), find_best_technology(), and ast_bridge_technology::mod.
{ struct ast_bridge_technology *bridge_technology = NULL; if (!(bridge_technology = find_best_technology(capabilities))) { return 0; } ast_module_unref(bridge_technology->mod); return 1; }
int ast_bridge_depart | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) |
Depart a channel from a bridge.
bridge | Bridge to depart from |
chan | Channel to depart |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_depart(bridge, chan);
This removes the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and gives control to the calling thread. This does not hang up the channel.
Definition at line 1069 of file bridging.c.
References ao2_lock(), ao2_unlock(), ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_DEPART, find_bridge_channel(), ast_bridge_channel::thread, and thread.
Referenced by feature_attended_transfer(), and play_sound_file().
{ struct ast_bridge_channel *bridge_channel = NULL; pthread_t thread; ao2_lock(bridge); /* Try to find the channel that we want to depart */ if (!(bridge_channel = find_bridge_channel(bridge, chan))) { ao2_unlock(bridge); return -1; } ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DEPART); thread = bridge_channel->thread; ao2_unlock(bridge); pthread_join(thread, NULL); return 0; }
int ast_bridge_destroy | ( | struct ast_bridge * | bridge | ) |
Destroy a bridge.
bridge | Bridge to destroy |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_destroy(bridge);
This destroys a bridge that was previously created using ast_bridge_new.
Definition at line 514 of file bridging.c.
References ao2_lock(), ao2_ref, ao2_unlock(), ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_END, ast_debug, AST_LIST_TRAVERSE, bridge_poke(), ast_bridge::channels, ast_bridge_channel::entry, and ast_bridge::stop.
Referenced by ast_bridge_new(), destroy_conference_bridge(), and feature_attended_transfer().
{ struct ast_bridge_channel *bridge_channel = NULL; ao2_lock(bridge); bridge->stop = 1; bridge_poke(bridge); ast_debug(1, "Telling all channels in bridge %p to end and leave the party\n", bridge); /* Drop every bridged channel, the last one will cause the bridge thread (if it exists) to exit */ AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END); } ao2_unlock(bridge); ao2_ref(bridge, -1); return 0; }
int ast_bridge_dtmf_stream | ( | struct ast_bridge * | bridge, |
const char * | dtmf, | ||
struct ast_channel * | chan | ||
) |
Play a DTMF stream into a bridge, optionally not to a given channel.
bridge | Bridge to play stream into |
dtmf | DTMF to play |
chan | Channel to optionally not play to |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_dtmf_stream(bridge, "0123456789", NULL);
This sends the DTMF digits '0123456789' to all channels in the bridge pointed to by the bridge pointer. Optionally a channel may be excluded by passing it's channel pointer using the chan parameter.
Definition at line 1337 of file bridging.c.
References ao2_lock(), ao2_unlock(), ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_DTMF, ast_copy_string(), AST_LIST_TRAVERSE, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_channel::dtmf_stream_q, and ast_bridge_channel::entry.
Referenced by bridge_channel_feature().
{ struct ast_bridge_channel *bridge_channel = NULL; ao2_lock(bridge); AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { if (bridge_channel->chan == chan) { continue; } ast_copy_string(bridge_channel->dtmf_stream_q, dtmf, sizeof(bridge_channel->dtmf_stream_q)); ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_DTMF); } ao2_unlock(bridge); return 0; }
int ast_bridge_features_cleanup | ( | struct ast_bridge_features * | features | ) |
Clean up the contents of a bridge features structure.
features | Bridge features structure |
0 | on success |
-1 | on failure |
Example usage:
struct ast_bridge_features features; ast_bridge_features_init(&features); ast_bridge_features_cleanup(&features);
This cleans up the feature structure 'features'.
Definition at line 1325 of file bridging.c.
References ast_free, AST_LIST_REMOVE_HEAD, ast_bridge_features_hook::entry, and ast_bridge_features::hooks.
Referenced by confbridge_exec(), destroy_bridge(), and feature_attended_transfer().
{ struct ast_bridge_features_hook *hook = NULL; /* This is relatively simple, hooks are kept as a list on the features structure so we just pop them off and free them */ while ((hook = AST_LIST_REMOVE_HEAD(&features->hooks, entry))) { ast_free(hook); } return 0; }
int ast_bridge_features_enable | ( | struct ast_bridge_features * | features, |
enum ast_bridge_builtin_feature | feature, | ||
const char * | dtmf, | ||
void * | config | ||
) |
Enable a built in feature on a bridge features structure.
features | Bridge features structure |
feature | Feature to enable |
dtmf | Optionally the DTMF stream to trigger the feature, if not specified it will be the default |
config | Configuration structure unique to the built in type |
0 | on success |
-1 | on failure |
Example usage:
struct ast_bridge_features features; ast_bridge_features_init(&features); ast_bridge_features_enable(&features, AST_BRIDGE_BUILTIN_ATTENDEDTRANSFER, NULL);
This enables the attended transfer DTMF option using the default DTMF string. An alternate string may be provided using the dtmf parameter. Internally this is simply setting up a hook to a built in feature callback function.
Definition at line 1287 of file bridging.c.
References ast_bridge_features_hook(), ast_debug, and ast_strlen_zero().
Referenced by feature_attended_transfer().
{ /* If no alternate DTMF stream was provided use the default one */ if (ast_strlen_zero(dtmf)) { dtmf = builtin_features_dtmf[feature]; /* If no DTMF is still available (ie: it has been disabled) then error out now */ if (ast_strlen_zero(dtmf)) { ast_debug(1, "Failed to enable built in feature %d on %p, no DTMF string is available for it.\n", feature, features); return -1; } } if (!builtin_features_handlers[feature]) { return -1; } /* The rest is basically pretty easy. We create another hook using the built in feature's callback and DTMF, easy as pie. */ return ast_bridge_features_hook(features, dtmf, builtin_features_handlers[feature], config); }
int ast_bridge_features_hook | ( | struct ast_bridge_features * | features, |
const char * | dtmf, | ||
ast_bridge_features_hook_callback | callback, | ||
void * | hook_pvt | ||
) |
Attach a custom hook to a bridge features structure.
features | Bridge features structure |
dtmf | DTMF string to be activated upon |
callback | Function to execute upon activation |
hook_pvt | Unique data |
0 | on success |
-1 | on failure |
Example usage:
struct ast_bridge_features features; ast_bridge_features_init(&features); ast_bridge_features_hook(&features, "#", pound_callback, NULL);
This makes the bridging core call pound_callback if a channel that has this feature structure inputs the DTMF string '#'. A pointer to useful data may be provided to the hook_pvt parameter.
Definition at line 1266 of file bridging.c.
References ast_calloc, ast_copy_string(), AST_LIST_INSERT_TAIL, ast_bridge_features_hook::callback, ast_bridge_features_hook::dtmf, ast_bridge_features_hook::entry, ast_bridge_features_hook::hook_pvt, ast_bridge_features::hooks, and ast_bridge_features::usable.
Referenced by ast_bridge_features_enable(), confbridge_exec(), and feature_attended_transfer().
{ struct ast_bridge_features_hook *hook = NULL; /* Allocate new memory and setup it's various variables */ if (!(hook = ast_calloc(1, sizeof(*hook)))) { return -1; } ast_copy_string(hook->dtmf, dtmf, sizeof(hook->dtmf)); hook->callback = callback; hook->hook_pvt = hook_pvt; /* Once done we add it onto the list. Now it will be picked up when DTMF is used */ AST_LIST_INSERT_TAIL(&features->hooks, hook, entry); features->usable = 1; return 0; }
int ast_bridge_features_init | ( | struct ast_bridge_features * | features | ) |
Initialize bridge features structure.
features | Bridge featues structure |
0 | on success |
-1 | on failure |
Example usage:
struct ast_bridge_features features; ast_bridge_features_init(&features);
This initializes the feature structure 'features' to have nothing enabled.
Definition at line 1314 of file bridging.c.
References AST_LIST_HEAD_INIT_NOLOCK, and ast_bridge_features::hooks.
Referenced by confbridge_exec(), and feature_attended_transfer().
{ /* Zero out the structure */ memset(features, 0, sizeof(*features)); /* Initialize the hooks list, just in case */ AST_LIST_HEAD_INIT_NOLOCK(&features->hooks); return 0; }
int ast_bridge_features_register | ( | enum ast_bridge_builtin_feature | feature, |
ast_bridge_features_hook_callback | callback, | ||
const char * | dtmf | ||
) |
Register a handler for a built in feature.
feature | The feature that the handler will be responsible for |
callback | The callback function that will handle it |
dtmf | Default DTMF string used to activate the feature |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_features_register(AST_BRIDGE_BUILTIN_ATTENDED_TRANSFER, bridge_builtin_attended_transfer, "*1");
This registers the function bridge_builtin_attended_transfer as the function responsible for the built in attended transfer feature.
Definition at line 1240 of file bridging.c.
References ast_copy_string(), and ast_strlen_zero().
Referenced by load_module().
{ if (builtin_features_handlers[feature]) { return -1; } if (!ast_strlen_zero(dtmf)) { ast_copy_string(builtin_features_dtmf[feature], dtmf, sizeof(builtin_features_dtmf[feature])); } builtin_features_handlers[feature] = callback; return 0; }
int ast_bridge_features_set_flag | ( | struct ast_bridge_features * | features, |
enum ast_bridge_feature_flags | flag | ||
) |
Set a flag on a bridge features structure.
features | Bridge features structure |
flag | Flag to enable |
0 | on success |
-1 | on failure |
Example usage:
struct ast_bridge_features features; ast_bridge_features_init(&features); ast_bridge_features_set_flag(&features, AST_BRIDGE_FLAG_DISSOLVE);
This sets the AST_BRIDGE_FLAG_DISSOLVE feature to be enabled on the features structure 'features'.
Definition at line 1307 of file bridging.c.
References ast_set_flag, ast_bridge_features::feature_flags, and ast_bridge_features::usable.
Referenced by feature_attended_transfer().
{ ast_set_flag(&features->feature_flags, flag); features->usable = 1; return 0; }
int ast_bridge_features_unregister | ( | enum ast_bridge_builtin_feature | feature | ) |
Unregister a handler for a built in feature.
feature | The feature to unregister |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_features_unregister(AST_BRIDGE_BUILTIN_ATTENDED_TRANSFER);
This unregisters the function that is handling the built in attended transfer feature.
Definition at line 1255 of file bridging.c.
{ if (!builtin_features_handlers[feature]) { return -1; } builtin_features_handlers[feature] = NULL; return 0; }
void ast_bridge_handle_trip | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel, | ||
struct ast_channel * | chan, | ||
int | outfd | ||
) |
Feed notification that a frame is waiting on a channel into the bridging core.
bridge | The bridge that the notification should influence |
bridge_channel | Bridge channel the notification was received on (if known) |
chan | Channel the notification was received on (if known) |
outfd | File descriptor that the notification was received on (if known) |
Example usage:
ast_bridge_handle_trip(bridge, NULL, chan, -1);
This tells the bridging core that a frame has been received on the channel pointed to by chan and that it should be read and handled.
Definition at line 276 of file bridging.c.
References ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_END, AST_CONTROL_HANGUP, ast_debug, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, ast_frfree, ast_read(), ast_read_noaudio(), bridge_drop_control_frame(), bridge_handle_dtmf(), ast_bridge_technology::fd, ast_bridge_channel::features, ast_bridge::features, find_bridge_channel(), ast_frame::frametype, ast_bridge_features::mute, ast_bridge_technology::poke, ast_frame::subclass, ast_bridge::technology, and ast_bridge_technology::write.
Referenced by bridge_channel_join_multithreaded(), generic_thread_loop(), and multiplexed_thread_function().
{ /* If no bridge channel has been provided and the actual channel has been provided find it */ if (chan && !bridge_channel) { bridge_channel = find_bridge_channel(bridge, chan); } /* If a bridge channel with actual channel is present read a frame and handle it */ if (chan && bridge_channel) { struct ast_frame *frame = (((bridge->features.mute) || (bridge_channel->features && bridge_channel->features->mute)) ? ast_read_noaudio(chan) : ast_read(chan)); /* This is pretty simple... see if they hung up */ if (!frame || (frame->frametype == AST_FRAME_CONTROL && frame->subclass == AST_CONTROL_HANGUP)) { /* Signal the thread that is handling the bridged channel that it should be ended */ ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_END); } else if (frame->frametype == AST_FRAME_CONTROL && bridge_drop_control_frame(frame->subclass)) { ast_debug(1, "Dropping control frame from bridge channel %p\n", bridge_channel); } else { if (frame->frametype == AST_FRAME_DTMF_BEGIN) { frame = bridge_handle_dtmf(bridge, bridge_channel, frame); } /* Simply write the frame out to the bridge technology if it still exists */ if (frame) { bridge->technology->write(bridge, bridge_channel, frame); } } if (frame) { ast_frfree(frame); } return; } /* If a file descriptor actually tripped pass it off to the bridge technology */ if (outfd > -1 && bridge->technology->fd) { bridge->technology->fd(bridge, bridge_channel, outfd); return; } /* If all else fails just poke the bridge */ if (bridge->technology->poke && bridge_channel) { bridge->technology->poke(bridge, bridge_channel); return; } return; }
int ast_bridge_impart | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan, | ||
struct ast_channel * | swap, | ||
struct ast_bridge_features * | features | ||
) |
Impart (non-blocking) a channel on a bridge.
bridge | Bridge to impart on |
chan | Channel to impart |
swap | Channel to swap out if swapping |
features | Bridge features structure |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_impart(bridge, chan, NULL, NULL);
This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will return immediately and will not wait until the channel is no longer part of the bridge.
If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.
If channel specific features are enabled a pointer to the features structure can be specified in the features parameter.
Definition at line 1035 of file bridging.c.
References ao2_ref, ast_calloc, ast_cond_destroy(), ast_cond_init(), ast_free, ast_mutex_destroy(), ast_mutex_init(), ast_pthread_create, ast_bridge_channel::bridge, bridge_channel_thread(), chan, ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge_channel::features, ast_bridge_channel::lock, ast_bridge_channel::swap, and ast_bridge_channel::thread.
Referenced by bridge_call(), feature_attended_transfer(), feature_blind_transfer(), and play_sound_file().
{ struct ast_bridge_channel *bridge_channel = NULL; /* Try to allocate a structure for the bridge channel */ if (!(bridge_channel = ast_calloc(1, sizeof(*bridge_channel)))) { return -1; } /* Setup various parameters */ bridge_channel->chan = chan; bridge_channel->swap = swap; bridge_channel->bridge = bridge; bridge_channel->features = features; /* Initialize our mutex lock and condition */ ast_mutex_init(&bridge_channel->lock); ast_cond_init(&bridge_channel->cond, NULL); /* Bump up the reference count on the bridge, it'll get decremented later */ ao2_ref(bridge, +1); /* Actually create the thread that will handle the channel */ if (ast_pthread_create(&bridge_channel->thread, NULL, bridge_channel_thread, bridge_channel)) { ao2_ref(bridge, -1); ast_cond_destroy(&bridge_channel->cond); ast_mutex_destroy(&bridge_channel->lock); ast_free(bridge_channel); return -1; } return 0; }
enum ast_bridge_channel_state ast_bridge_join | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan, | ||
struct ast_channel * | swap, | ||
struct ast_bridge_features * | features | ||
) |
Join (blocking) a channel to a bridge.
bridge | Bridge to join |
chan | Channel to join |
swap | Channel to swap out if swapping |
features | Bridge features structure |
state | that channel exited the bridge with |
Example usage:
ast_bridge_join(bridge, chan, NULL, NULL);
This adds a channel pointed to by the chan pointer to the bridge pointed to by the bridge pointer. This function will not return until the channel has been removed from the bridge, swapped out for another channel, or has hung up.
If this channel will be replacing another channel the other channel can be specified in the swap parameter. The other channel will be thrown out of the bridge in an atomic fashion.
If channel specific features are enabled a pointer to the features structure can be specified in the features parameter.
Definition at line 985 of file bridging.c.
References ao2_ref, ast_cond_destroy(), ast_cond_init(), ast_mutex_destroy(), ast_mutex_init(), ast_bridge_channel::bridge, ast_channel::bridge, bridge_channel_join(), chan, ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge_channel::features, ast_bridge::features, ast_bridge_channel::lock, ast_bridge_channel::state, and ast_bridge_channel::swap.
Referenced by confbridge_exec(), and feature_attended_transfer().
{ struct ast_bridge_channel bridge_channel = { .chan = chan, .swap = swap, .bridge = bridge, .features = features, }; enum ast_bridge_channel_state state; /* Initialize various other elements of the bridge channel structure that we can't do above */ ast_mutex_init(&bridge_channel.lock); ast_cond_init(&bridge_channel.cond, NULL); ao2_ref(bridge_channel.bridge, +1); state = bridge_channel_join(&bridge_channel); ao2_ref(bridge_channel.bridge, -1); /* Destroy some elements of the bridge channel structure above */ ast_mutex_destroy(&bridge_channel.lock); ast_cond_destroy(&bridge_channel.cond); return state; }
int ast_bridge_merge | ( | struct ast_bridge * | bridge0, |
struct ast_bridge * | bridge1 | ||
) |
Merge two bridges together.
bridge0 | First bridge |
bridge1 | Second bridge |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_merge(bridge0, bridge1);
This merges the bridge pointed to by bridge1 with the bridge pointed to by bridge0. In reality all of the channels in bridge1 are simply moved to bridge0.
Definition at line 1111 of file bridging.c.
References ao2_lock(), ao2_ref, ao2_unlock(), AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_FLAG_SMART, ast_cond_signal(), ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_REMOVE_HEAD, ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_STOP, ast_test_flag, ast_bridge_channel::bridge, bridge_array_add(), bridge_array_remove(), bridge_make_compatible(), ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_channel::cond, ast_bridge_channel::entry, ast_bridge::feature_flags, ast_bridge_technology::join, ast_bridge_technology::leave, ast_bridge_channel::lock, ast_bridge_technology::name, ast_bridge::num, smart_bridge_operation(), ast_bridge::technology, ast_bridge_channel::thread, and ast_bridge::thread.
{ struct ast_bridge_channel *bridge_channel = NULL; ao2_lock(bridge0); ao2_lock(bridge1); /* If the first bridge currently has 2 channels and is not capable of becoming a multimixing bridge we can not merge */ if ((bridge0->num + bridge1->num) > 2 && (!(bridge0->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) && !ast_test_flag(&bridge0->feature_flags, AST_BRIDGE_FLAG_SMART))) { ao2_unlock(bridge1); ao2_unlock(bridge0); ast_debug(1, "Can't merge bridge %p into bridge %p, multimix is needed and it could not be acquired.\n", bridge1, bridge0); return -1; } ast_debug(1, "Merging channels from bridge %p into bridge %p\n", bridge1, bridge0); /* Perform smart bridge operation on bridge we are merging into so it can change bridge technology if needed */ if (smart_bridge_operation(bridge0, NULL, bridge0->num + bridge1->num)) { ao2_unlock(bridge1); ao2_unlock(bridge0); ast_debug(1, "Can't merge bridge %p into bridge %p, tried to perform smart bridge operation and failed.\n", bridge1, bridge0); return -1; } /* If a thread is currently executing on bridge1 tell it to stop */ if (bridge1->thread) { ast_debug(1, "Telling bridge thread on bridge %p to stop as it is being merged into %p\n", bridge1, bridge0); bridge1->thread = AST_PTHREADT_STOP; } /* Move channels from bridge1 over to bridge0 */ while ((bridge_channel = AST_LIST_REMOVE_HEAD(&bridge1->channels, entry))) { /* Tell the technology handling bridge1 that the bridge channel is leaving */ if (bridge1->technology->leave) { ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge1->technology->name, bridge_channel, bridge1); if (bridge1->technology->leave(bridge1, bridge_channel)) { ast_debug(1, "Bridge technology %s failed to allow %p to leave bridge %p\n", bridge1->technology->name, bridge_channel, bridge1); } } /* Drop channel count and reference count on the bridge they are leaving */ bridge1->num--; ao2_ref(bridge1, -1); bridge_array_remove(bridge1, bridge_channel->chan); /* Now add them into the bridge they are joining, increase channel count, and bump up reference count */ bridge_channel->bridge = bridge0; AST_LIST_INSERT_TAIL(&bridge0->channels, bridge_channel, entry); bridge0->num++; ao2_ref(bridge0, +1); bridge_array_add(bridge0, bridge_channel->chan); /* Make the channel compatible with the new bridge it is joining or else formats would go amuck */ bridge_make_compatible(bridge0, bridge_channel); /* Tell the technology handling bridge0 that the bridge channel is joining */ if (bridge0->technology->join) { ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge0->technology->name, bridge_channel, bridge0); if (bridge0->technology->join(bridge0, bridge_channel)) { ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge0->technology->name, bridge_channel, bridge0); } } /* Poke the bridge channel, this will cause it to wake up and execute the proper threading model for the new bridge it is in */ pthread_kill(bridge_channel->thread, SIGURG); ast_mutex_lock(&bridge_channel->lock); ast_cond_signal(&bridge_channel->cond); ast_mutex_unlock(&bridge_channel->lock); } ast_debug(1, "Merged channels from bridge %p into bridge %p\n", bridge1, bridge0); ao2_unlock(bridge1); ao2_unlock(bridge0); return 0; }
struct ast_bridge* ast_bridge_new | ( | int | capabilities, |
int | flags | ||
) | [read] |
Create a new bridge.
capabilities | The capabilities that we require to be used on the bridge |
flags | Flags that will alter the behavior of the bridge |
a | pointer to a new bridge on success |
NULL | on failure |
Example usage:
struct ast_bridge *bridge; bridge = ast_bridge_new(AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_FLAG_DISSOLVE);
This creates a simple two party bridge that will be destroyed once one of the channels hangs up.
Definition at line 448 of file bridging.c.
References ao2_alloc, ao2_ref, ast_bridge::array, ast_bridge::array_size, AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_MULTIMIX, ast_bridge_destroy(), AST_BRIDGE_FLAG_SMART, ast_bridge_new(), ast_calloc, ast_debug, AST_PTHREADT_NULL, ast_set_flag, BRIDGE_ARRAY_START, ast_bridge_technology::create, destroy_bridge(), ast_bridge::feature_flags, find_best_technology(), ast_bridge_technology::name, ast_bridge::technology, and ast_bridge::thread.
Referenced by ast_bridge_new(), feature_attended_transfer(), and join_conference_bridge().
{ struct ast_bridge *bridge = NULL; struct ast_bridge_technology *bridge_technology = NULL; /* If we need to be a smart bridge see if we can move between 1to1 and multimix bridges */ if (flags & AST_BRIDGE_FLAG_SMART) { struct ast_bridge *other_bridge; if (!(other_bridge = ast_bridge_new((capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) ? AST_BRIDGE_CAPABILITY_MULTIMIX : AST_BRIDGE_CAPABILITY_1TO1MIX, 0))) { return NULL; } ast_bridge_destroy(other_bridge); } /* If capabilities were provided use our helper function to find the "best" bridge technology, otherwise we can * just look for the most basic capability needed, single 1to1 mixing. */ bridge_technology = (capabilities ? find_best_technology(capabilities) : find_best_technology(AST_BRIDGE_CAPABILITY_1TO1MIX)); /* If no bridge technology was found we can't possibly do bridging so fail creation of the bridge */ if (!bridge_technology) { ast_debug(1, "Failed to find a bridge technology to satisfy capabilities %d\n", capabilities); return NULL; } /* We have everything we need to create this bridge... so allocate the memory, link things together, and fire her up! */ if (!(bridge = ao2_alloc(sizeof(*bridge), destroy_bridge))) { return NULL; } bridge->technology = bridge_technology; bridge->thread = AST_PTHREADT_NULL; /* Create an array of pointers for the channels that will be joining us */ bridge->array = ast_calloc(BRIDGE_ARRAY_START, sizeof(struct ast_channel*)); bridge->array_size = BRIDGE_ARRAY_START; ast_set_flag(&bridge->feature_flags, flags); /* Pass off the bridge to the technology to manipulate if needed */ if (bridge->technology->create) { ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", bridge->technology->name, bridge); if (bridge->technology->create(bridge)) { ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", bridge->technology->name, bridge); ao2_ref(bridge, -1); bridge = NULL; } } return bridge; }
int ast_bridge_remove | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) |
Remove a channel from a bridge.
bridge | Bridge that the channel is to be removed from |
chan | Channel to remove |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_remove(bridge, chan);
This removes the channel pointed to by the chan pointer from the bridge pointed to by the bridge pointer and requests that it be hung up. Control over the channel will NOT be given to the calling thread.
Definition at line 1092 of file bridging.c.
References ao2_lock(), ao2_unlock(), ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_HANGUP, and find_bridge_channel().
Referenced by menu_callback().
{ struct ast_bridge_channel *bridge_channel = NULL; ao2_lock(bridge); /* Try to find the channel that we want to remove */ if (!(bridge_channel = find_bridge_channel(bridge, chan))) { ao2_unlock(bridge); return -1; } ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_HANGUP); ao2_unlock(bridge); return 0; }
int ast_bridge_suspend | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) |
Suspend a channel temporarily from a bridge.
bridge | Bridge to suspend the channel from |
chan | Channel to suspend |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_suspend(bridge, chan);
This suspends the channel pointed to by chan from the bridge pointed to by bridge temporarily. Control of the channel is given to the calling thread. This differs from ast_bridge_depart as the channel will not be removed from the bridge.
Definition at line 1192 of file bridging.c.
References ao2_lock(), ao2_unlock(), bridge_channel_suspend(), and find_bridge_channel().
Referenced by leave_conference_bridge(), post_join_marked(), and post_join_unmarked().
{ struct ast_bridge_channel *bridge_channel; ao2_lock(bridge); if (!(bridge_channel = find_bridge_channel(bridge, chan))) { ao2_unlock(bridge); return -1; } bridge_channel_suspend(bridge, bridge_channel); ao2_unlock(bridge); return 0; }
void ast_bridge_technology_suspend | ( | struct ast_bridge_technology * | technology | ) |
Suspend a bridge technology from consideration.
technology | The bridge technology to suspend |
Example usage:
ast_bridge_technology_suspend(&simple_bridge_tech);
This suspends the bridge technology simple_bridge_tech from being considered when creating a new bridge. Existing bridges using the bridge technology are not affected.
Definition at line 1228 of file bridging.c.
References ast_bridge_technology::suspended.
{ technology->suspended = 1; return; }
int ast_bridge_technology_unregister | ( | struct ast_bridge_technology * | technology | ) |
Unregister a bridge technology from use.
technology | The bridge technology to unregister |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_technology_unregister(&simple_bridge_tech);
This unregisters a bridge technlogy declared as the structure simple_bridge_tech with the bridging core. It will no longer be considered when creating a new bridge.
Definition at line 95 of file bridging.c.
References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verbose(), ast_bridge_technology::name, option_verbose, and VERBOSE_PREFIX_2.
Referenced by unload_module().
{ struct ast_bridge_technology *current = NULL; AST_RWLIST_WRLOCK(&bridge_technologies); /* Ensure the bridge technology is registered before removing it */ AST_RWLIST_TRAVERSE_SAFE_BEGIN(&bridge_technologies, current, entry) { if (current == technology) { AST_RWLIST_REMOVE_CURRENT(entry); if (option_verbose > 1) { ast_verbose(VERBOSE_PREFIX_2 "Unregistered bridge technology %s\n", technology->name); } break; } } AST_RWLIST_TRAVERSE_SAFE_END; AST_RWLIST_UNLOCK(&bridge_technologies); return current ? 0 : -1; }
void ast_bridge_technology_unsuspend | ( | struct ast_bridge_technology * | technology | ) |
Unsuspend a bridge technology.
technology | The bridge technology to unsuspend |
Example usage:
ast_bridge_technology_unsuspend(&simple_bridge_tech);
This makes the bridge technology simple_bridge_tech considered when creating a new bridge again.
Definition at line 1234 of file bridging.c.
References ast_bridge_technology::suspended.
{ technology->suspended = 0; return; }
int ast_bridge_unsuspend | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) |
Unsuspend a channel from a bridge.
bridge | Bridge to unsuspend the channel from |
chan | Channel to unsuspend |
0 | on success |
-1 | on failure |
Example usage:
ast_bridge_unsuspend(bridge, chan);
This unsuspends the channel pointed to by chan from the bridge pointed to by bridge. The bridge will go back to handling the channel once this function returns.
Definition at line 1210 of file bridging.c.
References ao2_lock(), ao2_unlock(), bridge_channel_unsuspend(), and find_bridge_channel().
Referenced by leave_conference_bridge(), post_join_marked(), and post_join_unmarked().
{ struct ast_bridge_channel *bridge_channel; ao2_lock(bridge); if (!(bridge_channel = find_bridge_channel(bridge, chan))) { ao2_unlock(bridge); return -1; } bridge_channel_unsuspend(bridge, bridge_channel); ao2_unlock(bridge); return 0; }
static void bridge_array_add | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) | [static] |
Helper function to add a channel to the bridge array.
Definition at line 149 of file bridging.c.
References ast_bridge::array, ast_bridge::array_num, ast_bridge::array_size, ast_debug, ast_log(), ast_realloc, BRIDGE_ARRAY_GROW, bridge_poke(), chan, LOG_ERROR, ast_channel::name, and ast_bridge::waiting.
Referenced by ast_bridge_merge(), bridge_channel_join(), and bridge_channel_unsuspend().
{ /* We have to make sure the bridge thread is not using the bridge array before messing with it */ while (bridge->waiting) { bridge_poke(bridge); sched_yield(); } bridge->array[bridge->array_num++] = chan; ast_debug(1, "Added channel %s(%p) to bridge array on %p, new count is %d\n", chan->name, chan, bridge, (int)bridge->array_num); /* If the next addition of a channel will exceed our array size grow it out */ if (bridge->array_num == bridge->array_size) { struct ast_channel **tmp; ast_debug(1, "Growing bridge array on %p from %d to %d\n", bridge, (int)bridge->array_size, (int)bridge->array_size + BRIDGE_ARRAY_GROW); if (!(tmp = ast_realloc(bridge->array, (bridge->array_size + BRIDGE_ARRAY_GROW) * sizeof(struct ast_channel *)))) { ast_log(LOG_ERROR, "Failed to allocate more space for another channel on bridge '%p', this is not going to end well\n", bridge); return; } bridge->array = tmp; bridge->array_size += BRIDGE_ARRAY_GROW; } return; }
static void bridge_array_remove | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) | [static] |
Helper function to remove a channel from the bridge array.
Definition at line 180 of file bridging.c.
References ast_bridge::array, ast_bridge::array_num, ast_debug, bridge_poke(), and ast_bridge::waiting.
Referenced by ast_bridge_merge(), bridge_channel_join(), and bridge_channel_suspend().
{ int i; /* We have to make sure the bridge thread is not using the bridge array before messing with it */ while (bridge->waiting) { bridge_poke(bridge); sched_yield(); } for (i = 0; i < bridge->array_num; i++) { if (bridge->array[i] == chan) { bridge->array[i] = (bridge->array[(bridge->array_num - 1)] != chan ? bridge->array[(bridge->array_num - 1)] : NULL); bridge->array[(bridge->array_num - 1)] = NULL; bridge->array_num--; ast_debug(1, "Removed channel %p from bridge array on %p, new count is %d\n", chan, bridge, (int)bridge->array_num); break; } } return; }
static void bridge_channel_dtmf_stream | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Internal function that plays back DTMF on a bridge channel.
Definition at line 849 of file bridging.c.
References ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_WAIT, ast_copy_string(), ast_debug, ast_dtmf_stream(), ast_bridge_channel::chan, and ast_bridge_channel::dtmf_stream_q.
Referenced by bridge_channel_join().
{ char dtmf_q[8] = ""; ast_copy_string(dtmf_q, bridge_channel->dtmf_stream_q, sizeof(dtmf_q)); bridge_channel->dtmf_stream_q[0] = '\0'; ast_debug(1, "Playing DTMF stream '%s' out to bridge channel %p\n", dtmf_q, bridge_channel); ast_dtmf_stream(bridge_channel->chan, NULL, dtmf_q, 250, 0); ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT); return; }
static void bridge_channel_feature | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Internal function that executes a feature on a bridge channel.
Definition at line 783 of file bridging.c.
References ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_WAIT, ast_bridge_dtmf_stream(), ast_clear_flag, ast_debug, AST_FLAG_END_DTMF_ONLY, AST_LIST_TRAVERSE, ast_set_flag, ast_waitfordigit(), ast_bridge_features_hook::callback, ast_bridge_channel::chan, ast_bridge_features_hook::dtmf, ast_bridge_features_hook::entry, ast_bridge::features, ast_bridge_channel::features, ast_bridge_features_hook::hook_pvt, ast_bridge_features::hooks, and MAXIMUM_DTMF_FEATURE_STRING.
Referenced by bridge_channel_join().
{ struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features); struct ast_bridge_features_hook *hook = NULL; char dtmf[MAXIMUM_DTMF_FEATURE_STRING] = ""; int look_for_dtmf = 1, dtmf_len = 0; /* The channel is now under our control and we don't really want any begin frames to do our DTMF matching so disable 'em at the core level */ ast_set_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY); /* Wait for DTMF on the channel and put it into a buffer. If the buffer matches any feature hook execute the hook. */ while (look_for_dtmf) { int res = ast_waitfordigit(bridge_channel->chan, 3000); /* If the above timed out simply exit */ if (!res) { ast_debug(1, "DTMF feature string collection on bridge channel %p timed out\n", bridge_channel); break; } else if (res < 0) { ast_debug(1, "DTMF feature string collection failed on bridge channel %p for some reason\n", bridge_channel); break; } /* Add the above DTMF into the DTMF string so we can do our matching */ dtmf[dtmf_len++] = res; ast_debug(1, "DTMF feature string on bridge channel %p is now '%s'\n", bridge_channel, dtmf); /* Assume that we do not want to look for DTMF any longer */ look_for_dtmf = 0; /* See if a DTMF feature hook matches or can match */ AST_LIST_TRAVERSE(&features->hooks, hook, entry) { /* If this hook matches just break out now */ if (!strcmp(hook->dtmf, dtmf)) { ast_debug(1, "DTMF feature hook %p matched DTMF string '%s' on bridge channel %p\n", hook, dtmf, bridge_channel); break; } else if (!strncmp(hook->dtmf, dtmf, dtmf_len)) { ast_debug(1, "DTMF feature hook %p can match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel); look_for_dtmf = 1; } else { ast_debug(1, "DTMF feature hook %p does not match DTMF string '%s', it wants '%s', on bridge channel %p\n", hook, dtmf, hook->dtmf, bridge_channel); } } /* If we have reached the maximum length of a DTMF feature string bail out */ if (dtmf_len == MAXIMUM_DTMF_FEATURE_STRING) { break; } } /* Since we are done bringing DTMF in return to using both begin and end frames */ ast_clear_flag(bridge_channel->chan, AST_FLAG_END_DTMF_ONLY); /* If a hook was actually matched execute it on this channel, otherwise stream up the DTMF to the other channels */ if (hook) { hook->callback(bridge, bridge_channel, hook->hook_pvt); } else { ast_bridge_dtmf_stream(bridge, dtmf, bridge_channel->chan); ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_WAIT); } return; }
static enum ast_bridge_channel_state bridge_channel_join | ( | struct ast_bridge_channel * | bridge_channel | ) | [static] |
Join a channel to a bridge and handle anything the bridge may want us to do.
Definition at line 865 of file bridging.c.
References ao2_lock(), ao2_ref, ao2_unlock(), AST_BRIDGE_CAPABILITY_MULTITHREADED, AST_BRIDGE_CAPABILITY_THREAD, ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_DTMF, AST_BRIDGE_CHANNEL_STATE_END, AST_BRIDGE_CHANNEL_STATE_FEATURE, AST_BRIDGE_CHANNEL_STATE_HANGUP, AST_BRIDGE_CHANNEL_STATE_WAIT, AST_BRIDGE_FLAG_SMART, ast_debug, ast_getformatname(), AST_LIST_INSERT_TAIL, AST_LIST_REMOVE, ast_pthread_create, AST_PTHREADT_NULL, ast_set_read_format(), ast_set_write_format(), ast_test_flag, ast_channel::bridge, ast_bridge_channel::bridge, bridge_array_add(), bridge_array_remove(), bridge_channel_dtmf_stream(), bridge_channel_feature(), bridge_channel_join_multithreaded(), bridge_channel_join_singlethreaded(), bridge_channel_suspend(), bridge_channel_unsuspend(), bridge_check_dissolve(), bridge_make_compatible(), bridge_thread(), ast_bridge_technology::capabilities, ast_bridge_channel::chan, ast_bridge::channels, ast_bridge_channel::entry, ast_bridge_features_hook::entry, ast_bridge::feature_flags, find_bridge_channel(), ast_bridge_technology::join, ast_bridge_technology::leave, ast_bridge_technology::name, ast_bridge::num, ast_channel::readformat, smart_bridge_operation(), ast_bridge_channel::state, ast_bridge::stop, ast_bridge_channel::swap, ast_bridge::technology, ast_bridge::thread, ast_bridge_channel::thread, and ast_channel::writeformat.
Referenced by ast_bridge_join(), and bridge_channel_thread().
{ int formats[2] = { bridge_channel->chan->readformat, bridge_channel->chan->writeformat }; enum ast_bridge_channel_state state; /* Record the thread that will be the owner of us */ bridge_channel->thread = pthread_self(); ast_debug(1, "Joining bridge channel %p to bridge %p\n", bridge_channel, bridge_channel->bridge); ao2_lock(bridge_channel->bridge); state = bridge_channel->state; /* Add channel into the bridge */ AST_LIST_INSERT_TAIL(&bridge_channel->bridge->channels, bridge_channel, entry); bridge_channel->bridge->num++; bridge_array_add(bridge_channel->bridge, bridge_channel->chan); if (bridge_channel->swap) { struct ast_bridge_channel *bridge_channel2 = NULL; /* If we are performing a swap operation we do not need to execute the smart bridge operation as the actual number of channels involved will not have changed, we just need to tell the other channel to leave */ if ((bridge_channel2 = find_bridge_channel(bridge_channel->bridge, bridge_channel->swap))) { ast_debug(1, "Swapping bridge channel %p out from bridge %p so bridge channel %p can slip in\n", bridge_channel2, bridge_channel->bridge, bridge_channel); ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP); } bridge_channel->swap = NULL; } else if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) { /* Perform the smart bridge operation, basically see if we need to move around between technologies */ smart_bridge_operation(bridge_channel->bridge, bridge_channel, bridge_channel->bridge->num); } /* Make the channel compatible with the bridge */ bridge_make_compatible(bridge_channel->bridge, bridge_channel); /* Tell the bridge technology we are joining so they set us up */ if (bridge_channel->bridge->technology->join) { ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge); if (bridge_channel->bridge->technology->join(bridge_channel->bridge, bridge_channel)) { ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge); } } /* Actually execute the respective threading model, and keep our bridge thread alive */ while (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) { /* Update bridge pointer on channel */ bridge_channel->chan->bridge = bridge_channel->bridge; /* If the technology requires a thread and one is not running, start it up */ if (bridge_channel->bridge->thread == AST_PTHREADT_NULL && (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD)) { bridge_channel->bridge->stop = 0; ast_debug(1, "Starting a bridge thread for bridge %p\n", bridge_channel->bridge); ao2_ref(bridge_channel->bridge, +1); if (ast_pthread_create(&bridge_channel->bridge->thread, NULL, bridge_thread, bridge_channel->bridge)) { ast_debug(1, "Failed to create a bridge thread for bridge %p, giving it another go.\n", bridge_channel->bridge); ao2_ref(bridge_channel->bridge, -1); continue; } } /* Execute the threading model */ state = (bridge_channel->bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTITHREADED ? bridge_channel_join_multithreaded(bridge_channel) : bridge_channel_join_singlethreaded(bridge_channel)); /* Depending on the above state see what we need to do */ if (state == AST_BRIDGE_CHANNEL_STATE_FEATURE) { bridge_channel_suspend(bridge_channel->bridge, bridge_channel); bridge_channel_feature(bridge_channel->bridge, bridge_channel); bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel); } else if (state == AST_BRIDGE_CHANNEL_STATE_DTMF) { bridge_channel_suspend(bridge_channel->bridge, bridge_channel); bridge_channel_dtmf_stream(bridge_channel->bridge, bridge_channel); bridge_channel_unsuspend(bridge_channel->bridge, bridge_channel); } } bridge_channel->chan->bridge = NULL; /* See if we need to dissolve the bridge itself if they hung up */ if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_END) { bridge_check_dissolve(bridge_channel->bridge, bridge_channel); } /* Tell the bridge technology we are leaving so they tear us down */ if (bridge_channel->bridge->technology->leave) { ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge); if (bridge_channel->bridge->technology->leave(bridge_channel->bridge, bridge_channel)) { ast_debug(1, "Bridge technology %s failed to leave %p from bridge %p\n", bridge_channel->bridge->technology->name, bridge_channel, bridge_channel->bridge); } } /* Remove channel from the bridge */ bridge_channel->bridge->num--; AST_LIST_REMOVE(&bridge_channel->bridge->channels, bridge_channel, entry); bridge_array_remove(bridge_channel->bridge, bridge_channel->chan); /* Perform the smart bridge operation if needed since a channel has left */ if (ast_test_flag(&bridge_channel->bridge->feature_flags, AST_BRIDGE_FLAG_SMART)) { smart_bridge_operation(bridge_channel->bridge, NULL, bridge_channel->bridge->num); } ao2_unlock(bridge_channel->bridge); /* Restore original formats of the channel as they came in */ if (bridge_channel->chan->readformat != formats[0]) { ast_debug(1, "Bridge is returning %p to read format %s(%d)\n", bridge_channel, ast_getformatname(formats[0]), formats[0]); if (ast_set_read_format(bridge_channel->chan, formats[0])) { ast_debug(1, "Bridge failed to return channel %p to read format %s(%d)\n", bridge_channel, ast_getformatname(formats[0]), formats[0]); } } if (bridge_channel->chan->writeformat != formats[1]) { ast_debug(1, "Bridge is returning %p to write format %s(%d)\n", bridge_channel, ast_getformatname(formats[1]), formats[1]); if (ast_set_write_format(bridge_channel->chan, formats[1])) { ast_debug(1, "Bridge failed to return channel %p to write format %s(%d)\n", bridge_channel, ast_getformatname(formats[1]), formats[1]); } } return bridge_channel->state; }
static enum ast_bridge_channel_state bridge_channel_join_multithreaded | ( | struct ast_bridge_channel * | bridge_channel | ) | [static] |
Run in a multithreaded model. Each joined channel does writing/reading in their own thread. TODO: Improve.
Definition at line 703 of file bridging.c.
References ao2_lock(), ao2_unlock(), ast_bridge_handle_trip(), ast_cond_wait(), ast_debug, ast_mutex_lock(), ast_mutex_unlock(), ast_waitfor_nandfds(), ast_bridge_channel::bridge, ast_bridge_channel::chan, chan, ast_bridge_channel::cond, ast_bridge_technology::fd, ast_bridge_channel::fds, ast_bridge_channel::lock, ast_bridge_channel::state, ast_bridge_channel::suspended, and ast_bridge::technology.
Referenced by bridge_channel_join().
{ int fds[4] = { -1, }, nfds = 0, i = 0, outfd = -1, ms = -1; struct ast_channel *chan = NULL; /* Add any file descriptors we may want to monitor */ if (bridge_channel->bridge->technology->fd) { for (i = 0; i < 4; i ++) { if (bridge_channel->fds[i] >= 0) { fds[nfds++] = bridge_channel->fds[i]; } } } ao2_unlock(bridge_channel->bridge); /* Wait for data to either come from the channel or us to be signalled */ if (!bridge_channel->suspended) { ast_debug(1, "Going into a multithreaded waitfor for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge); chan = ast_waitfor_nandfds(&bridge_channel->chan, 1, fds, nfds, NULL, &outfd, &ms); } else { ast_mutex_lock(&bridge_channel->lock); ast_debug(1, "Going into a multithreaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge); ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock); ast_mutex_unlock(&bridge_channel->lock); } ao2_lock(bridge_channel->bridge); if (!bridge_channel->suspended) { ast_bridge_handle_trip(bridge_channel->bridge, bridge_channel, chan, outfd); } return bridge_channel->state; }
static enum ast_bridge_channel_state bridge_channel_join_singlethreaded | ( | struct ast_bridge_channel * | bridge_channel | ) | [static] |
Run in a singlethreaded model. Each joined channel yields itself to the main bridge thread. TODO: Improve.
Definition at line 740 of file bridging.c.
References ao2_lock(), ao2_unlock(), AST_BRIDGE_CHANNEL_STATE_WAIT, ast_cond_wait(), ast_debug, ast_mutex_lock(), ast_mutex_unlock(), ast_bridge_channel::bridge, ast_bridge_channel::cond, ast_bridge_channel::lock, and ast_bridge_channel::state.
Referenced by bridge_channel_join().
{ ao2_unlock(bridge_channel->bridge); ast_mutex_lock(&bridge_channel->lock); if (bridge_channel->state == AST_BRIDGE_CHANNEL_STATE_WAIT) { ast_debug(1, "Going into a single threaded signal wait for bridge channel %p of bridge %p\n", bridge_channel, bridge_channel->bridge); ast_cond_wait(&bridge_channel->cond, &bridge_channel->lock); } ast_mutex_unlock(&bridge_channel->lock); ao2_lock(bridge_channel->bridge); return bridge_channel->state; }
static void bridge_channel_suspend | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Internal function that suspends a channel from a bridge.
Definition at line 755 of file bridging.c.
References bridge_array_remove(), ast_bridge_channel::chan, ast_bridge_technology::suspend, ast_bridge_channel::suspended, and ast_bridge::technology.
Referenced by ast_bridge_suspend(), and bridge_channel_join().
{ bridge_channel->suspended = 1; bridge_array_remove(bridge, bridge_channel->chan); if (bridge->technology->suspend) { bridge->technology->suspend(bridge, bridge_channel); } return; }
static void* bridge_channel_thread | ( | void * | data | ) | [static] |
Thread responsible for imparted bridged channels.
Definition at line 1013 of file bridging.c.
References ao2_ref, AST_BRIDGE_CHANNEL_STATE_END, AST_BRIDGE_CHANNEL_STATE_HANGUP, ast_cond_destroy(), ast_free, ast_hangup(), ast_mutex_destroy(), ast_bridge_channel::bridge, bridge_channel_join(), ast_bridge_channel::chan, ast_bridge_channel::cond, ast_bridge_channel::lock, and ast_bridge_channel::state.
Referenced by ast_bridge_impart().
{ struct ast_bridge_channel *bridge_channel = data; enum ast_bridge_channel_state state; state = bridge_channel_join(bridge_channel); ao2_ref(bridge_channel->bridge, -1); /* If no other thread is going to take the channel then hang it up, or else we would have to service it until something else came along */ if (state == AST_BRIDGE_CHANNEL_STATE_END || state == AST_BRIDGE_CHANNEL_STATE_HANGUP) { ast_hangup(bridge_channel->chan); } /* Destroy elements of the bridge channel structure and the bridge channel structure itself */ ast_mutex_destroy(&bridge_channel->lock); ast_cond_destroy(&bridge_channel->cond); ast_free(bridge_channel); return NULL; }
static void bridge_channel_unsuspend | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Internal function that unsuspends a channel from a bridge.
Definition at line 769 of file bridging.c.
References bridge_array_add(), ast_bridge_channel::chan, ast_bridge_channel::suspended, ast_bridge::technology, and ast_bridge_technology::unsuspend.
Referenced by ast_bridge_unsuspend(), and bridge_channel_join().
{ bridge_channel->suspended =0; bridge_array_add(bridge, bridge_channel->chan); if (bridge->technology->unsuspend) { bridge->technology->unsuspend(bridge, bridge_channel); } return; }
static void bridge_check_dissolve | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Internal function to see whether a bridge should dissolve, and if so do it.
Definition at line 218 of file bridging.c.
References ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_DEPART, AST_BRIDGE_CHANNEL_STATE_END, AST_BRIDGE_CHANNEL_STATE_HANGUP, AST_BRIDGE_FLAG_DISSOLVE, ast_debug, AST_LIST_TRAVERSE, ast_test_flag, ast_bridge::channels, ast_bridge_channel::entry, ast_bridge_features::feature_flags, ast_bridge::feature_flags, ast_bridge_channel::features, ast_bridge_channel::state, ast_bridge::stop, and ast_bridge_features::usable.
Referenced by bridge_channel_join().
{ struct ast_bridge_channel *bridge_channel2 = NULL; if (!ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_DISSOLVE) && (!bridge_channel->features || !bridge_channel->features->usable || !ast_test_flag(&bridge_channel->features->feature_flags, AST_BRIDGE_FLAG_DISSOLVE))) { return; } ast_debug(1, "Dissolving bridge %p\n", bridge); AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) { if (bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_END && bridge_channel2->state != AST_BRIDGE_CHANNEL_STATE_DEPART) { ast_bridge_change_state(bridge_channel2, AST_BRIDGE_CHANNEL_STATE_HANGUP); } } /* Since all the channels are going away let's go ahead and stop our on thread */ bridge->stop = 1; return; }
static int bridge_drop_control_frame | ( | int | subclass | ) | [static] |
Internal function used to determine whether a control frame should be dropped or not.
Definition at line 265 of file bridging.c.
References AST_CONTROL_ANSWER.
Referenced by ast_bridge_handle_trip().
{ switch (subclass) { case AST_CONTROL_ANSWER: case -1: return 1; default: return 0; } }
static struct ast_frame* bridge_handle_dtmf | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel, | ||
struct ast_frame * | frame | ||
) | [static, read] |
Internal function to handle DTMF from a channel.
Definition at line 241 of file bridging.c.
References ast_bridge_change_state(), AST_BRIDGE_CHANNEL_STATE_FEATURE, ast_frfree, AST_LIST_TRAVERSE, ast_bridge_features_hook::dtmf, ast_bridge_features_hook::entry, ast_bridge::features, ast_bridge_channel::features, ast_bridge_features::hooks, ast_frame::subclass, and ast_bridge_features::usable.
Referenced by ast_bridge_handle_trip().
{ struct ast_bridge_features *features = (bridge_channel->features ? bridge_channel->features : &bridge->features); struct ast_bridge_features_hook *hook = NULL; /* If the features structure we grabbed is not usable immediately return the frame */ if (!features->usable) { return frame; } /* See if this DTMF matches the beginnings of any feature hooks, if so we switch to the feature state to either execute the feature or collect more DTMF */ AST_LIST_TRAVERSE(&features->hooks, hook, entry) { if (hook->dtmf[0] == frame->subclass) { ast_frfree(frame); frame = NULL; ast_bridge_change_state(bridge_channel, AST_BRIDGE_CHANNEL_STATE_FEATURE); break; } } return frame; }
static int bridge_make_compatible | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel | ||
) | [static] |
Definition at line 538 of file bridging.c.
References ast_best_codec(), ast_debug, ast_getformatname(), ast_getformatname_multiple(), ast_log(), ast_set_read_format(), ast_set_write_format(), ast_bridge_channel::chan, ast_bridge_technology::formats, LOG_WARNING, ast_channel::name, ast_bridge_technology::name, option_debug, ast_channel::readformat, ast_bridge::technology, and ast_channel::writeformat.
Referenced by ast_bridge_merge(), bridge_channel_join(), and smart_bridge_operation().
{ int formats[2] = {bridge_channel->chan->readformat, bridge_channel->chan->writeformat}; /* Are the formats currently in use something ths bridge can handle? */ if (!(bridge->technology->formats & bridge_channel->chan->readformat)) { int best_format = ast_best_codec(bridge->technology->formats); /* Read format is a no go... */ if (option_debug) { char codec_buf[512]; ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->formats); ast_debug(1, "Bridge technology %s wants to read any of formats %s(%d) but channel has %s(%d)\n", bridge->technology->name, codec_buf, bridge->technology->formats, ast_getformatname(formats[0]), formats[0]); } /* Switch read format to the best one chosen */ if (ast_set_read_format(bridge_channel->chan, best_format)) { ast_log(LOG_WARNING, "Failed to set channel %s to read format %s(%d)\n", bridge_channel->chan->name, ast_getformatname(best_format), best_format); return -1; } ast_debug(1, "Bridge %p put channel %s into read format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(best_format), best_format); } else { ast_debug(1, "Bridge %p is happy that channel %s already has read format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(formats[0]), formats[0]); } if (!(bridge->technology->formats & formats[1])) { int best_format = ast_best_codec(bridge->technology->formats); /* Write format is a no go... */ if (option_debug) { char codec_buf[512]; ast_getformatname_multiple(codec_buf, sizeof(codec_buf), bridge->technology->formats); ast_debug(1, "Bridge technology %s wants to write any of formats %s(%d) but channel has %s(%d)\n", bridge->technology->name, codec_buf, bridge->technology->formats, ast_getformatname(formats[1]), formats[1]); } /* Switch write format to the best one chosen */ if (ast_set_write_format(bridge_channel->chan, best_format)) { ast_log(LOG_WARNING, "Failed to set channel %s to write format %s(%d)\n", bridge_channel->chan->name, ast_getformatname(best_format), best_format); return -1; } ast_debug(1, "Bridge %p put channel %s into write format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(best_format), best_format); } else { ast_debug(1, "Bridge %p is happy that channel %s already has write format %s(%d)\n", bridge, bridge_channel->chan->name, ast_getformatname(formats[1]), formats[1]); } return 0; }
static void bridge_poke | ( | struct ast_bridge * | bridge | ) | [static] |
Helper function to poke the bridge thread.
Definition at line 135 of file bridging.c.
References AST_PTHREADT_NULL, AST_PTHREADT_STOP, and ast_bridge::thread.
Referenced by ast_bridge_destroy(), bridge_array_add(), bridge_array_remove(), and smart_bridge_operation().
{ /* Poke the thread just in case */ if (bridge->thread != AST_PTHREADT_NULL && bridge->thread != AST_PTHREADT_STOP) { pthread_kill(bridge->thread, SIGURG); } return; }
static void* bridge_thread | ( | void * | data | ) | [static] |
Bridge thread function.
Definition at line 353 of file bridging.c.
References ao2_lock(), ao2_ref, ao2_unlock(), ast_bridge::array_num, ast_debug, AST_PTHREADT_NULL, generic_thread_loop(), ast_bridge::refresh, ast_bridge::stop, ast_bridge::technology, ast_bridge::thread, and ast_bridge_technology::thread.
Referenced by bridge_channel_join(), and smart_bridge_operation().
{ struct ast_bridge *bridge = data; int res = 0; ao2_lock(bridge); ast_debug(1, "Started bridge thread for %p\n", bridge); /* Loop around until we are told to stop */ while (!bridge->stop && bridge->array_num && !res) { /* In case the refresh bit was set simply set it back to off */ bridge->refresh = 0; ast_debug(1, "Launching bridge thread function %p for bridge %p\n", (bridge->technology->thread ? bridge->technology->thread : &generic_thread_loop), bridge); /* Execute the appropriate thread function. If the technology does not provide one we use the generic one */ res = (bridge->technology->thread ? bridge->technology->thread(bridge) : generic_thread_loop(bridge)); } ast_debug(1, "Ending bridge thread for %p\n", bridge); /* Indicate the bridge thread is no longer active */ bridge->thread = AST_PTHREADT_NULL; ao2_unlock(bridge); ao2_ref(bridge, -1); return NULL; }
static void destroy_bridge | ( | void * | obj | ) | [static] |
Definition at line 420 of file bridging.c.
References ast_bridge::array, ast_bridge_features_cleanup(), ast_debug, ast_free, ast_module_unref(), ast_bridge_technology::destroy, ast_bridge::features, ast_bridge_technology::mod, ast_bridge_technology::name, and ast_bridge::technology.
Referenced by ast_bridge_new().
{ struct ast_bridge *bridge = obj; ast_debug(1, "Actually destroying bridge %p, nobody wants it anymore\n", bridge); /* Pass off the bridge to the technology to destroy if needed */ if (bridge->technology->destroy) { ast_debug(1, "Giving bridge technology %s the bridge structure %p to destroy\n", bridge->technology->name, bridge); if (bridge->technology->destroy(bridge)) { ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p... trying our best\n", bridge->technology->name, bridge); } } /* We are no longer using the bridge technology so decrement the module reference count on it */ if (bridge->technology->mod) { ast_module_unref(bridge->technology->mod); } /* Last but not least clean up the features configuration */ ast_bridge_features_cleanup(&bridge->features); /* Drop the array of channels */ ast_free(bridge->array); return; }
static struct ast_bridge_technology* find_best_technology | ( | int | capabilities | ) | [static, read] |
Helper function used to find the "best" bridge technology given a specified capabilities.
Definition at line 385 of file bridging.c.
References ast_debug, ast_module_ref(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_bridge_technology::capabilities, ast_bridge_technology::name, ast_bridge_technology::preference, and ast_bridge_technology::suspended.
Referenced by ast_bridge_check(), ast_bridge_new(), and smart_bridge_operation().
{ struct ast_bridge_technology *current = NULL, *best = NULL; AST_RWLIST_RDLOCK(&bridge_technologies); AST_RWLIST_TRAVERSE(&bridge_technologies, current, entry) { ast_debug(1, "Bridge technology %s has capabilities %d and we want %d\n", current->name, current->capabilities, capabilities); if (current->suspended) { ast_debug(1, "Bridge technology %s is suspended. Skipping.\n", current->name); continue; } if (!(current->capabilities & capabilities)) { ast_debug(1, "Bridge technology %s does not have the capabilities we need.\n", current->name); continue; } if (best && best->preference < current->preference) { ast_debug(1, "Bridge technology %s has preference %d while %s has preference %d. Skipping.\n", current->name, current->preference, best->name, best->preference); continue; } best = current; } if (best) { /* Increment it's module reference count if present so it does not get unloaded while in use */ if (best->mod) { ast_module_ref(best->mod); } ast_debug(1, "Chose bridge technology %s\n", best->name); } AST_RWLIST_UNLOCK(&bridge_technologies); return best; }
static struct ast_bridge_channel* find_bridge_channel | ( | struct ast_bridge * | bridge, |
struct ast_channel * | chan | ||
) | [static, read] |
Helper function to find a bridge channel given a channel.
Definition at line 204 of file bridging.c.
References AST_LIST_TRAVERSE, ast_bridge_channel::chan, ast_bridge::channels, and ast_bridge_channel::entry.
Referenced by ast_bridge_depart(), ast_bridge_handle_trip(), ast_bridge_remove(), ast_bridge_suspend(), ast_bridge_unsuspend(), and bridge_channel_join().
{ struct ast_bridge_channel *bridge_channel = NULL; AST_LIST_TRAVERSE(&bridge->channels, bridge_channel, entry) { if (bridge_channel->chan == chan) { break; } } return bridge_channel; }
static int generic_thread_loop | ( | struct ast_bridge * | bridge | ) | [static] |
Generic thread loop, TODO: Rethink this/improve it.
Definition at line 325 of file bridging.c.
References ao2_lock(), ao2_unlock(), ast_bridge::array, ast_bridge::array_num, ast_bridge_handle_trip(), ast_waitfor_n(), first, ast_bridge::refresh, ast_bridge::stop, and ast_bridge::waiting.
Referenced by bridge_thread().
{ while (!bridge->stop && !bridge->refresh && bridge->array_num) { struct ast_channel *winner = NULL; int to = -1; /* Move channels around for priority reasons if we have more than one channel in our array */ if (bridge->array_num > 1) { struct ast_channel *first = bridge->array[0]; memmove(bridge->array, bridge->array + 1, sizeof(struct ast_channel *) * (bridge->array_num - 1)); bridge->array[(bridge->array_num - 1)] = first; } /* Wait on the channels */ bridge->waiting = 1; ao2_unlock(bridge); winner = ast_waitfor_n(bridge->array, (int)bridge->array_num, &to); bridge->waiting = 0; ao2_lock(bridge); /* Process whatever they did */ ast_bridge_handle_trip(bridge, NULL, winner, -1); } return 0; }
static int smart_bridge_operation | ( | struct ast_bridge * | bridge, |
struct ast_bridge_channel * | bridge_channel, | ||
int | count | ||
) | [static] |
Perform the smart bridge operation. Basically sees if a new bridge technology should be used instead of the current one.
Definition at line 585 of file bridging.c.
References ao2_lock(), ao2_unlock(), AST_BRIDGE_CAPABILITY_1TO1MIX, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_CAPABILITY_THREAD, ast_cond_signal(), ast_debug, AST_LIST_TRAVERSE, ast_module_unref(), ast_mutex_lock(), ast_mutex_unlock(), AST_PTHREADT_NULL, bridge_make_compatible(), bridge_poke(), ast_bridge::bridge_pvt, bridge_thread(), ast_bridge_technology::capabilities, ast_bridge::channels, ast_bridge_channel::cond, ast_bridge_technology::create, ast_bridge_channel::entry, find_best_technology(), ast_bridge_technology::join, ast_bridge_channel::lock, ast_bridge_technology::name, ast_bridge::refresh, ast_bridge::stop, ast_bridge::technology, ast_bridge_channel::thread, and ast_bridge::thread.
Referenced by ast_bridge_merge(), and bridge_channel_join().
{ int new_capabilities = 0; struct ast_bridge_technology *new_technology = NULL, *old_technology = bridge->technology; struct ast_bridge temp_bridge = { .technology = bridge->technology, .bridge_pvt = bridge->bridge_pvt, }; struct ast_bridge_channel *bridge_channel2 = NULL; /* Based on current feature determine whether we want to change bridge technologies or not */ if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_1TO1MIX) { if (count <= 2) { ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name); return 0; } new_capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX; } else if (bridge->technology->capabilities & AST_BRIDGE_CAPABILITY_MULTIMIX) { if (count > 2) { ast_debug(1, "Bridge %p channel count (%d) is within limits for bridge technology %s, not performing smart bridge operation.\n", bridge, count, bridge->technology->name); return 0; } new_capabilities = AST_BRIDGE_CAPABILITY_1TO1MIX; } if (!new_capabilities) { ast_debug(1, "Bridge '%p' has no new capabilities, not performing smart bridge operation.\n", bridge); return 0; } /* Attempt to find a new bridge technology to satisfy the capabilities */ if (!(new_technology = find_best_technology(new_capabilities))) { ast_debug(1, "Smart bridge operation was unable to find new bridge technology with capabilities %d to satisfy bridge %p\n", new_capabilities, bridge); return -1; } ast_debug(1, "Performing smart bridge operation on bridge %p, moving from bridge technology %s to %s\n", bridge, old_technology->name, new_technology->name); /* If a thread is currently executing for the current technology tell it to stop */ if (bridge->thread != AST_PTHREADT_NULL) { /* If the new bridge technology also needs a thread simply tell the bridge thread to refresh itself. This has the benefit of not incurring the cost/time of tearing down and bringing up a new thread. */ if (new_technology->capabilities & AST_BRIDGE_CAPABILITY_THREAD) { ast_debug(1, "Telling current bridge thread for bridge %p to refresh\n", bridge); bridge->refresh = 1; bridge_poke(bridge); } else { pthread_t bridge_thread = bridge->thread; ast_debug(1, "Telling current bridge thread for bridge %p to stop\n", bridge); bridge->stop = 1; bridge_poke(bridge); ao2_unlock(bridge); pthread_join(bridge_thread, NULL); ao2_lock(bridge); } } /* Since we are soon going to pass this bridge to a new technology we need to NULL out the bridge_pvt pointer but don't worry as it still exists in temp_bridge, ditto for the old technology */ bridge->bridge_pvt = NULL; bridge->technology = new_technology; /* Pass the bridge to the new bridge technology so it can set it up */ if (new_technology->create) { ast_debug(1, "Giving bridge technology %s the bridge structure %p to setup\n", new_technology->name, bridge); if (new_technology->create(bridge)) { ast_debug(1, "Bridge technology %s failed to setup bridge structure %p\n", new_technology->name, bridge); } } /* Move existing channels over to the new technology, while taking them away from the old one */ AST_LIST_TRAVERSE(&bridge->channels, bridge_channel2, entry) { /* Skip over channel that initiated the smart bridge operation */ if (bridge_channel == bridge_channel2) { continue; } /* First we part them from the old technology */ if (old_technology->leave) { ast_debug(1, "Giving bridge technology %s notification that %p is leaving bridge %p (really %p)\n", old_technology->name, bridge_channel2, &temp_bridge, bridge); if (old_technology->leave(&temp_bridge, bridge_channel2)) { ast_debug(1, "Bridge technology %s failed to allow %p (really %p) to leave bridge %p\n", old_technology->name, bridge_channel2, &temp_bridge, bridge); } } /* Second we make them compatible again with the bridge */ bridge_make_compatible(bridge, bridge_channel2); /* Third we join them to the new technology */ if (new_technology->join) { ast_debug(1, "Giving bridge technology %s notification that %p is joining bridge %p\n", new_technology->name, bridge_channel2, bridge); if (new_technology->join(bridge, bridge_channel2)) { ast_debug(1, "Bridge technology %s failed to join %p to bridge %p\n", new_technology->name, bridge_channel2, bridge); } } /* Fourth we tell them to wake up so they become aware that they above has happened */ pthread_kill(bridge_channel2->thread, SIGURG); ast_mutex_lock(&bridge_channel2->lock); ast_cond_signal(&bridge_channel2->cond); ast_mutex_unlock(&bridge_channel2->lock); } /* Now that all the channels have been moved over we need to get rid of all the information the old technology may have left around */ if (old_technology->destroy) { ast_debug(1, "Giving bridge technology %s the bridge structure %p (really %p) to destroy\n", old_technology->name, &temp_bridge, bridge); if (old_technology->destroy(&temp_bridge)) { ast_debug(1, "Bridge technology %s failed to destroy bridge structure %p (really %p)... some memory may have leaked\n", old_technology->name, &temp_bridge, bridge); } } /* Finally if the old technology has module referencing remove our reference, we are no longer going to use it */ if (old_technology->mod) { ast_module_unref(old_technology->mod); } return 0; }
struct bridge_technologies bridge_technologies [static] |
char builtin_features_dtmf[AST_BRIDGE_BUILTIN_END][MAXIMUM_DTMF_FEATURE_STRING] [static] |
Default DTMF keys for built in features
Definition at line 54 of file bridging.c.
void* builtin_features_handlers[AST_BRIDGE_BUILTIN_END] [static] |
Function handlers for the built in features
Definition at line 57 of file bridging.c.