Stasis application control support. More...

#include "asterisk.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_app.h"
#include "command.h"
#include "control.h"
#include "app.h"
#include "asterisk/dial.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_after.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/bridge_features.h"
#include "asterisk/frame.h"
#include "asterisk/pbx.h"
#include "asterisk/musiconhold.h"
#include "asterisk/app.h"

Include dependency graph for control.c:

Go to the source code of this file.

Data Structures
struct	app_control_rules

struct	chanvar
	structure for queuing ARI channel variable setting More...

struct	control_dial_args

struct	stasis_app_control

struct	stasis_app_control_continue_data

struct	stasis_app_control_dtmf_data

struct	stasis_app_control_move_data

struct	stasis_app_control_mute_data

Typedefs
typedef int(*	app_command_can_exec_cb) (struct stasis_app_control *control)

Functions
static int	add_to_dial_bridge (struct stasis_app_control control, struct ast_channel chan)
	Add a channel to the singleton dial bridge. More...

static int	app_control_add_role (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_can_add_channel_to_bridge (struct stasis_app_control *control)

static int	app_control_can_remove_channel_from_bridge (struct stasis_app_control *control)

static enum stasis_app_control_channel_result	app_control_check_rules (const struct stasis_app_control control, struct app_control_rules list)

static int	app_control_clear_roles (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_continue (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_dial (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_dtmf (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_hold (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_moh_start (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_moh_stop (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_move (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_mute (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_redirect (struct stasis_app_control control, struct ast_channel chan, void *data)

static void	app_control_register_rule (struct stasis_app_control control, struct app_control_rules list, struct stasis_app_control_rule *obj)

static int	app_control_remove_channel_from_bridge (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_ring (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_ring_stop (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_set_channel_var (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_silence_start (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_silence_stop (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_unhold (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	app_control_unmute (struct stasis_app_control control, struct ast_channel chan, void *data)

static void	app_control_unregister_rule (struct stasis_app_control control, struct app_control_rules list, struct stasis_app_control_rule *obj)

static int	app_send_command_on_condition (struct stasis_app_control control, stasis_app_command_cb command_fn, void data, command_data_destructor_fn data_destructor, app_command_can_exec_cb can_exec_fn)

static void	bridge_after_cb (struct ast_channel chan, void data)

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

static int	bridge_channel_depart (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	bridge_timeout (struct ast_bridge_channel bridge_channel, void ignore)
	Dial timeout. More...

int	control_add_channel_to_bridge (struct stasis_app_control control, struct ast_channel chan, void *data)
	Command callback for adding a channel to a bridge. More...

struct stasis_app *	control_app (struct stasis_app_control *control)
	Returns the pointer (non-reffed) to the app associated with this control. More...

int	control_command_count (struct stasis_app_control *control)
	Returns the count of items in a control's command queue. More...

struct stasis_app_control *	control_create (struct ast_channel channel, struct stasis_app app)
	Create a control object. More...

static struct control_dial_args *	control_dial_args_alloc (const char *dialstring, unsigned int timeout)

static void	control_dial_args_destroy (void *data)

int	control_dispatch_all (struct stasis_app_control control, struct ast_channel chan)
	Dispatch all commands enqueued to this control. More...

static void	control_dtor (void *obj)

void	control_flush_queue (struct stasis_app_control *control)
	Flush the control command queue. More...

int	control_is_done (struct stasis_app_control *control)
	Returns true if control_continue() has been called on this control. More...

void	control_mark_done (struct stasis_app_control *control)

void	control_move_cleanup (struct stasis_app_control *control)
	Free any memory that was allocated for switching applications via /channels/{channelId}/move. More...

char *	control_next_app (struct stasis_app_control *control)
	Returns the name of the application we are moving to. More...

char **	control_next_app_args (struct stasis_app_control *control)
	Returns the list of arguments to pass to the application we are moving to. More...

int	control_next_app_args_size (struct stasis_app_control *control)
	Returns the number of arguments to be passed to the application we are moving to. More...

int	control_prestart_dispatch_all (struct stasis_app_control control, struct ast_channel chan)
	Dispatch all queued prestart commands. More...

void	control_set_app (struct stasis_app_control control, struct stasis_app app)
	Set the application the control object belongs to. More...

void	control_silence_stop_now (struct stasis_app_control *control)
	Stop playing silence to a channel right now. More...

int	control_swap_channel_in_bridge (struct stasis_app_control control, struct ast_bridge bridge, struct ast_channel chan, struct ast_channel swap)
	Command for swapping a channel in a bridge. More...

void	control_wait (struct stasis_app_control *control)
	Blocks until control's command queue has a command available. More...

static int	depart_channel (struct stasis_app_control control, struct ast_channel chan)
	Depart a channel from a bridge, and potentially add it back to the dial bridge. More...

static void	dial_bridge_after_cb (struct ast_channel chan, void data)
	after bridge callback for the dial bridge More...

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

static void	dtmf_in_bridge (struct ast_channel chan, struct stasis_app_control_dtmf_data dtmf_data)

static void	dtmf_no_bridge (struct ast_channel chan, struct stasis_app_control_dtmf_data dtmf_data)

static struct stasis_app_command *	exec_command (struct stasis_app_control control, stasis_app_command_cb command_fn, void data, command_data_destructor_fn data_destructor)

static struct stasis_app_command *	exec_command_on_condition (struct stasis_app_control control, stasis_app_command_cb command_fn, void data, command_data_destructor_fn data_destructor, app_command_can_exec_cb can_exec_fn)

static void	free_chanvar (void *data)

static struct ast_bridge *	get_dial_bridge (void)
	Retrieve a reference to the dial bridge. More...

static int	hangup_channel (struct stasis_app_control control, struct ast_channel chan, void *data)

static void	internal_bridge_after_cb (struct ast_channel chan, void data, enum ast_bridge_after_cb_reason reason)

static int	noop_cb (struct stasis_app_control control, struct ast_channel chan, void *data)

static void	set_interval_hook (struct ast_channel *chan)
	Set a dial timeout interval hook on the channel. More...

static int	set_timeout (struct ast_channel *chan, unsigned int timeout)
	Set dial timeout on a channel to be dialed. More...

void	stasis_app_control_absorb_dtmf_in_bridge (struct stasis_app_control *control, int absorb)
	Set whether DTMF from the channel is absorbed instead of passing through to the bridge. More...

int	stasis_app_control_add_channel_to_bridge (struct stasis_app_control control, struct ast_bridge bridge)
	Add a channel to the bridge. More...

int	stasis_app_control_add_role (struct stasis_app_control control, const char role)
	Apply a bridge role to a channel controlled by a stasis app control. More...

int	stasis_app_control_bridge_features_init (struct stasis_app_control *control)
	Initialize bridge features into a channel control. More...

void	stasis_app_control_clear_roles (struct stasis_app_control *control)
	Clear bridge roles currently applied to a channel controlled by a stasis app control. More...

int	stasis_app_control_continue (struct stasis_app_control control, const char context, const char *extension, int priority)
	Exit `res_stasis` and continue execution in the dialplan. More...

int	stasis_app_control_dial (struct stasis_app_control control, const char dialstring, unsigned int timeout)
	Dial a channel. More...

int	stasis_app_control_dtmf (struct stasis_app_control control, const char dtmf, int before, int between, unsigned int duration, int after)
	Send DTMF to the channel associated with this control. More...

const char *	stasis_app_control_get_channel_id (const struct stasis_app_control *control)
	Returns the uniqueid of the channel associated with this control. More...

struct ast_channel_snapshot *	stasis_app_control_get_snapshot (const struct stasis_app_control *control)
	Returns the most recent snapshot for the associated channel. More...

void	stasis_app_control_hold (struct stasis_app_control *control)
	Place the channel associated with the control on hold. More...

void	stasis_app_control_inhibit_colp_in_bridge (struct stasis_app_control *control, int inhibit_colp)
	Set whether COLP frames should be generated when joining the bridge. More...

void	stasis_app_control_moh_start (struct stasis_app_control control, const char moh_class)
	Play music on hold to a channel (does not affect hold status) More...

void	stasis_app_control_moh_stop (struct stasis_app_control *control)
	Stop playing music on hold to a channel (does not affect hold status) More...

int	stasis_app_control_move (struct stasis_app_control control, const char app_name, const char *app_args)
	Exit `res_stasis` and move to another Stasis application. More...

int	stasis_app_control_mute (struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
	Mute the channel associated with this control. More...

void	stasis_app_control_mute_in_bridge (struct stasis_app_control *control, int mute)
	Set whether audio from the channel is muted instead of passing through to the bridge. More...

void	stasis_app_control_publish (struct stasis_app_control control, struct stasis_message message)
	Publish a message to the control's channel's topic. More...

int	stasis_app_control_queue_control (struct stasis_app_control *control, enum ast_control_frame_type frame_type)
	Queue a control frame without payload. More...

int	stasis_app_control_redirect (struct stasis_app_control control, const char endpoint)
	Redirect a channel in `res_stasis` to a particular endpoint. More...

void	stasis_app_control_register_add_rule (struct stasis_app_control control, struct stasis_app_control_rule rule)
	Registers an add channel to bridge rule. More...

void	stasis_app_control_register_remove_rule (struct stasis_app_control control, struct stasis_app_control_rule rule)
	Registers a remove channel from bridge rule. More...

int	stasis_app_control_remove_channel_from_bridge (struct stasis_app_control control, struct ast_bridge bridge)
	Remove a channel from the bridge. More...

int	stasis_app_control_ring (struct stasis_app_control *control)
	Indicate ringing to the channel associated with this control. More...

int	stasis_app_control_ring_stop (struct stasis_app_control *control)
	Stop locally generated ringing on the channel associated with this control. More...

int	stasis_app_control_set_channel_var (struct stasis_app_control control, const char variable, const char *value)
	Set a variable on the channel associated with this control to value. More...

void	stasis_app_control_shutdown (void)
	Let Stasis app internals shut down. More...

void	stasis_app_control_silence_start (struct stasis_app_control *control)
	Start playing silence to a channel. More...

void	stasis_app_control_silence_stop (struct stasis_app_control *control)
	Stop playing silence to a channel. More...

void	stasis_app_control_unhold (struct stasis_app_control *control)
	Remove the channel associated with the control from hold. More...

int	stasis_app_control_unmute (struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
	Unmute the channel associated with this control. More...

void	stasis_app_control_unregister_add_rule (struct stasis_app_control control, struct stasis_app_control_rule rule)
	UnRegister an add channel to bridge rule. More...

void	stasis_app_control_unregister_remove_rule (struct stasis_app_control control, struct stasis_app_control_rule rule)
	Unregisters a remove channel from bridge rule. More...

struct ast_bridge *	stasis_app_get_bridge (struct stasis_app_control *control)
	Gets the bridge currently associated with a control object. More...

int	stasis_app_send_command (struct stasis_app_control control, stasis_app_command_cb command_fn, void data, command_data_destructor_fn data_destructor)
	Invokes a command on a control's channel. More...

int	stasis_app_send_command_async (struct stasis_app_control control, stasis_app_command_cb command_fn, void data, command_data_destructor_fn data_destructor)
	Asynchronous version of stasis_app_send_command(). More...

Variables
static struct ast_bridge *	dial_bridge
	Singleton dial bridge. More...

static ast_mutex_t	dial_bridge_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static int	shutting_down
	Indicates if the Stasis app internals are being shut down. More...

struct ast_datastore_info	timeout_datastore
	Dial timeout datastore. More...

Detailed Description

Stasis application control support.

Author: David M. Lee, II dlee@.nosp@m.digi.nosp@m.um.co.nosp@m.m

Definition in file control.c.

Typedef Documentation

◆ app_command_can_exec_cb

typedef int(* app_command_can_exec_cb) (struct stasis_app_control *control)

Callback type to see if the command can execute note: command_queue is locked during callback

Definition at line 265 of file control.c.

Function Documentation

◆ add_to_dial_bridge()

static int add_to_dial_bridge	(	struct stasis_app_control *	control,
		struct ast_channel *	chan
	)

static

Add a channel to the singleton dial bridge.

Parameters

control	The Stasis control structure
chan	The channel to add to the bridge

Return values

-1	Failed
0	Success

Definition at line 1041 of file control.c.

References ao2_ref, ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, ast_bridge_set_after_callback(), stasis_app_control::bridge, dial_bridge_after_cb(), dial_bridge_after_cb_failed(), get_dial_bridge(), and NULL.

Referenced by app_control_dial(), and depart_channel().

 {
    struct ast_bridge *bridge;
 
    bridge = get_dial_bridge();
    if (!bridge) {
       return -1;
    }
 
    control->bridge = bridge;
    ast_bridge_set_after_callback(chan, dial_bridge_after_cb, dial_bridge_after_cb_failed, control);
    if (ast_bridge_impart(bridge, chan, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE)) {
       control->bridge = NULL;
       ao2_ref(bridge, -1);
       return -1;
    }
 
    ao2_ref(bridge, -1);
 
    return 0;
 }

◆ app_control_add_role()

static int app_control_add_role	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 308 of file control.c.

References ast_channel_add_bridge_role(), and stasis_app_command::data.

Referenced by stasis_app_control_add_role().

 {
    char *role = data;
 
    return ast_channel_add_bridge_role(chan, role);
 }

◆ app_control_can_add_channel_to_bridge()

static int app_control_can_add_channel_to_bridge ( struct stasis_app_control * control )

static

Definition at line 245 of file control.c.

References stasis_app_control::add_rules, and app_control_check_rules().

Referenced by stasis_app_control_add_channel_to_bridge().

 {
    return app_control_check_rules(control, &control->add_rules);
 }

◆ app_control_can_remove_channel_from_bridge()

static int app_control_can_remove_channel_from_bridge ( struct stasis_app_control * control )

static

Definition at line 251 of file control.c.

References app_control_check_rules(), and stasis_app_control::remove_rules.

Referenced by stasis_app_control_remove_channel_from_bridge().

 {
    return app_control_check_rules(control, &control->remove_rules);
 }

◆ app_control_check_rules()

static enum stasis_app_control_channel_result app_control_check_rules	(	const struct stasis_app_control *	control,
		struct app_control_rules *	list
	)

static

Definition at line 203 of file control.c.

References AST_LIST_TRAVERSE, stasis_app_control_rule::check_rule, and stasis_app_control_rule::next.

Referenced by app_control_can_add_channel_to_bridge(), and app_control_can_remove_channel_from_bridge().

 {
    int res = 0;
    struct stasis_app_control_rule *rule;
    AST_LIST_TRAVERSE(list, rule, next) {
       if ((res = rule->check_rule(control))) {
          return res;
       }
    }
    return res;
 }

◆ app_control_clear_roles()

static int app_control_clear_roles	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 330 of file control.c.

References ast_channel_clear_bridge_roles().

Referenced by stasis_app_control_clear_roles().

 {
    ast_channel_clear_bridge_roles(chan);
 
    return 0;
 }

◆ app_control_continue()

static int app_control_continue	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 368 of file control.c.

References ast_assert, ast_bridge_depart(), ast_explicit_goto(), stasis_app_control::channel, stasis_app_control_continue_data::context, control_mark_done(), stasis_app_control_continue_data::extension, NULL, stasis_app_control_continue_data::priority, and stasis_app_get_bridge().

Referenced by stasis_app_control_continue().

 {
    struct stasis_app_control_continue_data *continue_data = data;
 
    ast_assert(control->channel != NULL);
 
    /* If we're in a Stasis bridge, depart it before going back to the
     * dialplan */
    if (stasis_app_get_bridge(control)) {
       ast_bridge_depart(control->channel);
    }
 
    /* Called from stasis_app_exec thread; no lock needed */
    ast_explicit_goto(control->channel, continue_data->context, continue_data->extension, continue_data->priority);
 
    control_mark_done(control);
 
    return 0;
 }

◆ app_control_dial()

static int app_control_dial	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 1628 of file control.c.

References add_to_dial_bridge(), args, ast_bridge_setup_after_goto(), ast_call(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_publish_dial(), ast_channel_unlock, AST_SOFTHANGUP_ASYNCGOTO, AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), control_dial_args::dialstring, NULL, set_timeout(), and control_dial_args::timeout.

Referenced by stasis_app_control_dial().

 {
    struct control_dial_args *args = data;
    int bridged;
 
    ast_channel_lock(chan);
    bridged = ast_channel_is_bridged(chan);
    ast_channel_unlock(chan);
 
    if (!bridged && add_to_dial_bridge(control, chan)) {
       return -1;
    }
 
    if (args->timeout && set_timeout(chan, args->timeout)) {
       return -1;
    }
 
    if (ast_call(chan, args->dialstring, 0)) {
       /* If call fails normally this channel would then just be normally hung up and destroyed.
        * In this case though the channel is being handled by the ARI control thread and dial
        * bridge which needs to be notified that the channel should be hung up. To do this we
        * queue a soft hangup which will cause each to wake up, see that the channel has been
        * hung up, and then destroy it.
        */
       int hangup_flag;
       hangup_flag = ast_bridge_setup_after_goto(chan) ? AST_SOFTHANGUP_DEV : AST_SOFTHANGUP_ASYNCGOTO;
       ast_channel_lock(chan);
       ast_softhangup_nolock(chan, hangup_flag);
       ast_channel_unlock(chan);
       return -1;
    }
 
    ast_channel_publish_dial(NULL, chan, args->dialstring, NULL);
 
    return 0;
 }

◆ app_control_dtmf()

static int app_control_dtmf	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 547 of file control.c.

References AST_CONTROL_PROGRESS, ast_indicate(), AST_STATE_UP, dtmf_in_bridge(), dtmf_no_bridge(), and stasis_app_get_bridge().

Referenced by stasis_app_control_dtmf().

 {
    struct stasis_app_control_dtmf_data *dtmf_data = data;
 
    if (ast_channel_state(chan) != AST_STATE_UP) {
       ast_indicate(chan, AST_CONTROL_PROGRESS);
    }
 
    if (stasis_app_get_bridge(control)) {
       dtmf_in_bridge(chan, dtmf_data);
    } else {
       dtmf_no_bridge(chan, dtmf_data);
    }
 
    return 0;
 }

◆ app_control_hold()

static int app_control_hold	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 740 of file control.c.

References AST_CONTROL_HOLD, ast_indicate(), and stasis_app_control::channel.

Referenced by stasis_app_control_hold().

 {
    ast_indicate(control->channel, AST_CONTROL_HOLD);
 
    return 0;
 }

◆ app_control_moh_start()

static int app_control_moh_start	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 766 of file control.c.

References AST_CONTROL_PROGRESS, ast_indicate(), ast_moh_start(), AST_STATE_UP, and NULL.

Referenced by stasis_app_control_moh_start().

 {
    char *moh_class = data;
 
    if (ast_channel_state(chan) != AST_STATE_UP) {
       ast_indicate(chan, AST_CONTROL_PROGRESS);
    }
 
    ast_moh_start(chan, moh_class, NULL);
 
    return 0;
 }

◆ app_control_moh_stop()

static int app_control_moh_stop	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 791 of file control.c.

References ast_moh_stop().

Referenced by stasis_app_control_moh_stop().

 {
    ast_moh_stop(chan);
    return 0;
 }

◆ app_control_move()

static int app_control_move	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 414 of file control.c.

References stasis_app_control_move_data::app_args, stasis_app_control_move_data::app_name, ast_free, ast_log, ast_strdup, AST_VECTOR_APPEND, control_move_cleanup(), LOG_ERROR, and stasis_app_control::next_app.

Referenced by stasis_app_control_move().

 {
    struct stasis_app_control_move_data *move_data = data;
 
    control->next_app = ast_strdup(move_data->app_name);
    if (!control->next_app) {
       ast_log(LOG_ERROR, "Allocation failed for next app\n");
       return -1;
    }
 
    if (move_data->app_args) {
       char *token;
 
       while ((token = strtok_r(move_data->app_args, ",", &move_data->app_args))) {
          int res;
          char *arg;
 
          if (!(arg = ast_strdup(token))) {
             ast_log(LOG_ERROR, "Allocation failed for next app arg\n");
             control_move_cleanup(control);
             return -1;
          }
 
          res = AST_VECTOR_APPEND(&control->next_app_args, arg);
          if (res) {
             ast_log(LOG_ERROR, "Failed to append arg to next app args\n");
             ast_free(arg);
             control_move_cleanup(control);
             return -1;
          }
       }
    }
 
    return 0;
 }

◆ app_control_mute()

static int app_control_mute	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 619 of file control.c.

References ast_channel_lock, ast_channel_suppress(), ast_channel_unlock, stasis_app_control::channel, stasis_app_control_mute_data::direction, and stasis_app_control_mute_data::frametype.

Referenced by stasis_app_control_mute().

 {
    struct stasis_app_control_mute_data *mute_data = data;
 
    ast_channel_lock(chan);
    ast_channel_suppress(control->channel, mute_data->direction, mute_data->frametype);
    ast_channel_unlock(chan);
 
    return 0;
 }

◆ app_control_redirect()

static int app_control_redirect	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 481 of file control.c.

References ast_assert, ast_channel_name(), ast_log, ast_transfer(), stasis_app_control::channel, LOG_NOTICE, and NULL.

Referenced by stasis_app_control_redirect().

 {
    char *endpoint = data;
    int res;
 
    ast_assert(control->channel != NULL);
    ast_assert(endpoint != NULL);
 
    res = ast_transfer(control->channel, endpoint);
    if (!res) {
       ast_log(LOG_NOTICE, "Unsupported transfer requested on channel '%s'\n",
          ast_channel_name(control->channel));
       return 0;
    }
 
    return 0;
 }

◆ app_control_register_rule()

static void app_control_register_rule	(	struct stasis_app_control *	control,
		struct app_control_rules *	list,
		struct stasis_app_control_rule *	obj
	)

static

Definition at line 162 of file control.c.

References ao2_lock, ao2_unlock, AST_LIST_INSERT_TAIL, and stasis_app_control::command_queue.

Referenced by stasis_app_control_register_add_rule(), and stasis_app_control_register_remove_rule().

 {
    ao2_lock(control->command_queue);
    AST_LIST_INSERT_TAIL(list, obj, next);
    ao2_unlock(control->command_queue);
 }

◆ app_control_remove_channel_from_bridge()

static int app_control_remove_channel_from_bridge	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 1394 of file control.c.

References ast_debug, ast_log, stasis_app_control::bridge, depart_channel(), LOG_WARNING, stasis_app_control_get_channel_id(), stasis_app_get_bridge(), and ast_bridge::uniqueid.

Referenced by stasis_app_control_remove_channel_from_bridge().

 {
    struct ast_bridge *bridge = data;
 
    if (!control) {
       return -1;
    }
 
    /* We should only depart from our own bridge */
    ast_debug(3, "%s: Departing bridge %s\n",
       stasis_app_control_get_channel_id(control),
       bridge->uniqueid);
 
    if (bridge != stasis_app_get_bridge(control)) {
       ast_log(LOG_WARNING, "%s: Not in bridge %s; not removing\n",
          stasis_app_control_get_channel_id(control),
          bridge->uniqueid);
       return -1;
    }
 
    depart_channel(control, chan);
    return 0;
 }

◆ app_control_ring()

static int app_control_ring	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 584 of file control.c.

References AST_CONTROL_RINGING, ast_indicate(), and stasis_app_control::channel.

Referenced by stasis_app_control_ring().

 {
    ast_indicate(control->channel, AST_CONTROL_RINGING);
 
    return 0;
 }

◆ app_control_ring_stop()

static int app_control_ring_stop	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 599 of file control.c.

References ast_indicate(), and stasis_app_control::channel.

Referenced by stasis_app_control_ring_stop().

 {
    ast_indicate(control->channel, -1);
 
    return 0;
 }

◆ app_control_set_channel_var()

static int app_control_set_channel_var	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 701 of file control.c.

References stasis_app_control::channel, chanvar::name, pbx_builtin_setvar_helper(), chanvar::value, and var.

Referenced by stasis_app_control_set_channel_var().

 {
    struct chanvar *var = data;
 
    pbx_builtin_setvar_helper(control->channel, var->name, var->value);
 
    return 0;
 }

◆ app_control_silence_start()

static int app_control_silence_start	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 803 of file control.c.

References ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), AST_CONTROL_PROGRESS, ast_debug, ast_indicate(), ast_log, AST_STATE_UP, stasis_app_control::channel, LOG_WARNING, stasis_app_control::silgen, and stasis_app_control_get_channel_id().

Referenced by stasis_app_control_silence_start().

 {
    if (ast_channel_state(chan) != AST_STATE_UP) {
       ast_indicate(chan, AST_CONTROL_PROGRESS);
    }
 
    if (control->silgen) {
       /* We have a silence generator, but it may have been implicitly
        * disabled by media actions (music on hold, playing media,
        * etc.) Just stop it and restart a new one.
        */
       ast_channel_stop_silence_generator(
          control->channel, control->silgen);
    }
 
    ast_debug(3, "%s: Starting silence generator\n",
       stasis_app_control_get_channel_id(control));
    control->silgen = ast_channel_start_silence_generator(control->channel);
 
    if (!control->silgen) {
       ast_log(LOG_WARNING,
          "%s: Failed to start silence generator.\n",
          stasis_app_control_get_channel_id(control));
    }
 
    return 0;
 }

◆ app_control_silence_stop()

static int app_control_silence_stop	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 848 of file control.c.

References control_silence_stop_now().

Referenced by stasis_app_control_silence_stop().

 {
    control_silence_stop_now(control);
    return 0;
 }

◆ app_control_unhold()

static int app_control_unhold	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 753 of file control.c.

References AST_CONTROL_UNHOLD, ast_indicate(), and stasis_app_control::channel.

Referenced by stasis_app_control_unhold().

 {
    ast_indicate(control->channel, AST_CONTROL_UNHOLD);
 
    return 0;
 }

◆ app_control_unmute()

static int app_control_unmute	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 647 of file control.c.

References ast_channel_lock, ast_channel_unlock, ast_channel_unsuppress(), stasis_app_control::channel, stasis_app_control_mute_data::direction, and stasis_app_control_mute_data::frametype.

Referenced by stasis_app_control_unmute().

 {
    struct stasis_app_control_mute_data *mute_data = data;
 
    ast_channel_lock(chan);
    ast_channel_unsuppress(control->channel, mute_data->direction, mute_data->frametype);
    ast_channel_unlock(chan);
 
    return 0;
 }

◆ app_control_unregister_rule()

static void app_control_unregister_rule	(	struct stasis_app_control *	control,
		struct app_control_rules *	list,
		struct stasis_app_control_rule *	obj
	)

static

Definition at line 171 of file control.c.

References ao2_lock, ao2_unlock, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, stasis_app_control::command_queue, and stasis_app_control_rule::next.

Referenced by stasis_app_control_unregister_add_rule(), and stasis_app_control_unregister_remove_rule().

 {
    struct stasis_app_control_rule *rule;
 
    ao2_lock(control->command_queue);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(list, rule, next) {
       if (rule == obj) {
          AST_RWLIST_REMOVE_CURRENT(next);
          break;
       }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    ao2_unlock(control->command_queue);
 }

◆ app_send_command_on_condition()

static int app_send_command_on_condition	(	struct stasis_app_control *	control,
		stasis_app_command_cb	command_fn,
		void *	data,
		command_data_destructor_fn	data_destructor,
		app_command_can_exec_cb	can_exec_fn
	)

static

Definition at line 866 of file control.c.

References ao2_ref, command_join(), stasis_app_command::data_destructor, exec_command_on_condition(), and NULL.

Referenced by stasis_app_control_add_channel_to_bridge(), stasis_app_control_remove_channel_from_bridge(), and stasis_app_send_command().

 {
    int ret;
    struct stasis_app_command *command;
 
    if (control == NULL || control->is_done) {
       /* If exec_command_on_condition fails, it calls the data_destructor.
        * In order to provide consistent behavior, we'll also call the data_destructor
        * on this error path. This way, callers never have to call the
        * data_destructor themselves.
        */
       if (data_destructor) {
          data_destructor(data);
       }
       return -1;
    }
 
    command = exec_command_on_condition(
       control, command_fn, data, data_destructor, can_exec_fn);
    if (!command) {
       return -1;
    }
 
    ret = command_join(command);
    ao2_ref(command, -1);
 
    return ret;
 }

◆ bridge_after_cb()

static void bridge_after_cb	(	struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 1163 of file control.c.

References AST_BRIDGE_AFTER_CB_REASON_DEPART, stasis_app_control::channel, and internal_bridge_after_cb().

Referenced by control_swap_channel_in_bridge().

 {
    struct stasis_app_control *control = data;
 
    internal_bridge_after_cb(control->channel, data, AST_BRIDGE_AFTER_CB_REASON_DEPART);
 }

◆ bridge_after_cb_failed()

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

static

Definition at line 1170 of file control.c.

References ast_bridge_after_cb_reason_string(), ast_debug, stasis_app_control::channel, and internal_bridge_after_cb().

Referenced by control_swap_channel_in_bridge().

 {
    struct stasis_app_control *control = data;
 
    internal_bridge_after_cb(control->channel, data, reason);
 
    ast_debug(3, "  reason: %s\n",
       ast_bridge_after_cb_reason_string(reason));
 }

◆ bridge_channel_depart()

static int bridge_channel_depart	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 1085 of file control.c.

References ast_channel_internal_bridge_channel(), ast_channel_lock, ast_channel_uniqueid(), ast_channel_unlock, ast_debug, and depart_channel().

Referenced by dial_bridge_after_cb(), get_dial_bridge(), and internal_bridge_after_cb().

 {
    struct ast_bridge_channel *bridge_channel;
 
    ast_channel_lock(chan);
    bridge_channel = ast_channel_internal_bridge_channel(chan);
    ast_channel_unlock(chan);
 
    if (bridge_channel != data) {
       ast_debug(3, "%s: Channel is no longer in departable state\n",
          ast_channel_uniqueid(chan));
       return -1;
    }
 
    ast_debug(3, "%s: Channel departing bridge\n",
       ast_channel_uniqueid(chan));
 
    depart_channel(control, chan);
 
    return 0;
 }

◆ bridge_timeout()

static int bridge_timeout	(	struct ast_bridge_channel *	bridge_channel,
		void *	ignore
	)

static

Dial timeout.

This is a bridge interval hook callback. The interval hook triggering means that the dial timeout has been reached. If the channel has not been answered by the time this callback is called, then the channel is hung up

Parameters

bridge_channel	Bridge channel on which interval hook has been called
ignore	Ignored

Returns: -1 (i.e. remove the interval hook)

Definition at line 1215 of file control.c.

References ao2_cleanup, ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_unlock, ast_datastore_free(), AST_STATE_UP, ast_bridge_channel::chan, hangup_channel(), NULL, RAII_VAR, stasis_app_control_find_by_channel(), and stasis_app_send_command_async().

Referenced by set_interval_hook().

 {
    struct ast_datastore *datastore;
    RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
 
    control = stasis_app_control_find_by_channel(bridge_channel->chan);
 
    ast_channel_lock(bridge_channel->chan);
    if (ast_channel_state(bridge_channel->chan) != AST_STATE_UP) {
       /* Don't bother removing the datastore because it will happen when the channel is hung up */
       ast_channel_unlock(bridge_channel->chan);
       stasis_app_send_command_async(control, hangup_channel, NULL, NULL);
       return -1;
    }
 
    datastore = ast_channel_datastore_find(bridge_channel->chan, &timeout_datastore, NULL);
    if (!datastore) {
       ast_channel_unlock(bridge_channel->chan);
       return -1;
    }
    ast_channel_datastore_remove(bridge_channel->chan, datastore);
    ast_channel_unlock(bridge_channel->chan);
    ast_datastore_free(datastore);
 
    return -1;
 }

◆ control_add_channel_to_bridge()

int control_add_channel_to_bridge	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

Command callback for adding a channel to a bridge.

Parameters

control	The control for chan
chan	The channel on which commands should be executed
data	Bridge to be passed to the callback

Definition at line 1378 of file control.c.

References control_swap_channel_in_bridge(), and NULL.

Referenced by stasis_app_control_add_channel_to_bridge().

 {
    return control_swap_channel_in_bridge(control, data, chan, NULL);
 }

◆ control_app()

struct stasis_app* control_app ( struct stasis_app_control * control )

Returns the pointer (non-reffed) to the app associated with this control.

Parameters

control Control to query.

Returns: A pointer to the associated stasis_app

Definition at line 1563 of file control.c.

References stasis_app_control::app.

Referenced by bridge_stasis_moving(), bridge_stasis_push_peek(), channel_replaced_cb(), channel_stolen_cb(), and stasis_app_exec().

 {
    return control->app;
 }

◆ control_command_count()

int control_command_count ( struct stasis_app_control * control )

Returns the count of items in a control's command queue.

Parameters

control Control to count commands on

Return values

number of commands in the command que

Definition at line 343 of file control.c.

References ao2_container_count(), and stasis_app_control::command_queue.

Referenced by stasis_app_control_execute_until_exhausted().

 {
    return ao2_container_count(control->command_queue);
 }

◆ control_create()

struct stasis_app_control* control_create	(	struct ast_channel *	channel,
		struct stasis_app *	app
	)

Create a control object.

Parameters

channel	Channel to control.
app	stasis_app for which this control is being created.

Returns: New control object.; NULL on error.

Definition at line 123 of file control.c.

References stasis_app_control::add_rules, ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_bump, ao2_container_alloc_list, ao2_ref, stasis_app_control::app, ast_channel_ref, ast_cond_init, AST_LIST_HEAD_INIT, ast_log, AST_VECTOR_INIT, stasis_app_control::channel, stasis_app_control::command_queue, control_dtor(), errno, LOG_ERROR, stasis_app_control::next_app, NULL, stasis_app_control::remove_rules, and stasis_app_control::wait_cond.

Referenced by stasis_app_control_create(), and stasis_app_exec().

 {
    struct stasis_app_control *control;
    int res;
 
    control = ao2_alloc(sizeof(*control), control_dtor);
    if (!control) {
       return NULL;
    }
 
    AST_LIST_HEAD_INIT(&control->add_rules);
    AST_LIST_HEAD_INIT(&control->remove_rules);
 
    res = ast_cond_init(&control->wait_cond, NULL);
    if (res != 0) {
       ast_log(LOG_ERROR, "Error initializing ast_cond_t: %s\n",
          strerror(errno));
       ao2_ref(control, -1);
       return NULL;
    }
 
    control->app = ao2_bump(app);
 
    ast_channel_ref(channel);
    control->channel = channel;
 
    control->command_queue = ao2_container_alloc_list(
       AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
    if (!control->command_queue) {
       ao2_ref(control, -1);
       return NULL;
    }
 
    control->next_app = NULL;
    AST_VECTOR_INIT(&control->next_app_args, 0);
 
    return control;
 }

◆ control_dial_args_alloc()

static struct control_dial_args* control_dial_args_alloc	(	const char *	dialstring,
		unsigned int	timeout
	)

static

Definition at line 1573 of file control.c.

References args, ast_malloc, control_dial_args::dialstring, NULL, timeout, and control_dial_args::timeout.

Referenced by stasis_app_control_dial().

 {
    struct control_dial_args *args;
 
    args = ast_malloc(sizeof(*args) + strlen(dialstring) + 1);
    if (!args) {
       return NULL;
    }
 
    args->timeout = timeout;
    /* Safe */
    strcpy(args->dialstring, dialstring);
 
    return args;
 }

◆ control_dial_args_destroy()

static void control_dial_args_destroy ( void * data )

static

Definition at line 1590 of file control.c.

References args, and ast_free.

Referenced by stasis_app_control_dial().

 {
    struct control_dial_args *args = data;
 
    ast_free(args);
 }

◆ control_dispatch_all()

int control_dispatch_all	(	struct stasis_app_control *	control,
		struct ast_channel *	chan
	)

Dispatch all commands enqueued to this control.

Parameters

control	Control object to dispatch.
chan	Associated channel.

Returns: Number of commands executed

Definition at line 1495 of file control.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, AO2_ITERATOR_UNLINK, ao2_ref, ast_assert, stasis_app_control::channel, command_invoke(), and stasis_app_control::command_queue.

Referenced by stasis_app_control_execute_until_exhausted(), and stasis_app_exec().

 {
    int count = 0;
    struct ao2_iterator iter;
    struct stasis_app_command *command;
 
    ast_assert(control->channel == chan);
 
    iter = ao2_iterator_init(control->command_queue, AO2_ITERATOR_UNLINK);
    while ((command = ao2_iterator_next(&iter))) {
       command_invoke(command, control, chan);
       ao2_ref(command, -1);
       ++count;
    }
    ao2_iterator_destroy(&iter);
 
    return count;
 }

◆ control_dtor()

static void control_dtor ( void * obj )

static

Definition at line 105 of file control.c.

References stasis_app_control::add_rules, ao2_cleanup, stasis_app_control::app, ast_bridge_features_destroy(), ast_channel_cleanup, ast_cond_destroy, AST_LIST_HEAD_DESTROY, stasis_app_control::bridge_features, stasis_app_control::channel, stasis_app_control::command_queue, control_move_cleanup(), stasis_app_control::remove_rules, and stasis_app_control::wait_cond.

Referenced by control_create().

 {
    struct stasis_app_control *control = obj;
 
    ao2_cleanup(control->command_queue);
 
    ast_channel_cleanup(control->channel);
    ao2_cleanup(control->app);
 
    control_move_cleanup(control);
 
    ast_cond_destroy(&control->wait_cond);
    AST_LIST_HEAD_DESTROY(&control->add_rules);
    AST_LIST_HEAD_DESTROY(&control->remove_rules);
    ast_bridge_features_destroy(control->bridge_features);
 
 }

◆ control_flush_queue()

void control_flush_queue ( struct stasis_app_control * control )

Flush the control command queue.

Since: 13.9.0

Parameters

control Control object to flush command queue.

Returns: Nothing

Definition at line 1482 of file control.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, AO2_ITERATOR_UNLINK, ao2_ref, command_complete(), and stasis_app_control::command_queue.

Referenced by stasis_app_control_flush_queue(), and stasis_app_exec().

 {
    struct ao2_iterator iter;
    struct stasis_app_command *command;
 
    iter = ao2_iterator_init(control->command_queue, AO2_ITERATOR_UNLINK);
    while ((command = ao2_iterator_next(&iter))) {
       command_complete(command, -1);
       ao2_ref(command, -1);
    }
    ao2_iterator_destroy(&iter);
 }

◆ control_is_done()

int control_is_done ( struct stasis_app_control * control )

Returns true if control_continue() has been called on this control.

Parameters

control Control to query.

Returns: True (non-zero) if control_continue() has been called.; False (zero) otherwise.

Definition at line 348 of file control.c.

Referenced by stasis_app_control_execute_until_exhausted(), stasis_app_control_is_done(), and stasis_app_exec().

 {
    /* Called from stasis_app_exec thread; no lock needed */
    return control->is_done;
 }

◆ control_mark_done()

void control_mark_done ( struct stasis_app_control * control )

Definition at line 354 of file control.c.

References ao2_lock, ao2_unlock, and stasis_app_control::command_queue.

Referenced by app_control_continue(), stasis_app_control_execute_until_exhausted(), and stasis_app_exec().

 {
    /* Locking necessary to sync with other threads adding commands to the queue. */
    ao2_lock(control->command_queue);
    control->is_done = 1;
    ao2_unlock(control->command_queue);
 }

◆ control_move_cleanup()

void control_move_cleanup ( struct stasis_app_control * control )

Free any memory that was allocated for switching applications via /channels/{channelId}/move.

Parameters

control The control for the channel

Definition at line 1702 of file control.c.

References ast_free, ast_free_ptr(), AST_VECTOR_RESET, stasis_app_control::next_app, and NULL.

Referenced by app_control_move(), control_dtor(), and stasis_app_exec().

 {
    ast_free(control->next_app);
    control->next_app = NULL;
 
    AST_VECTOR_RESET(&control->next_app_args, ast_free_ptr);
 }

◆ control_next_app()

char* control_next_app ( struct stasis_app_control * control )

Returns the name of the application we are moving to.

Parameters

control The control for the channel

Returns: The name of the application we are moving to

Definition at line 1697 of file control.c.

References stasis_app_control::next_app.

Referenced by stasis_app_exec().

 {
    return control->next_app;
 }

◆ control_next_app_args()

char** control_next_app_args ( struct stasis_app_control * control )

Returns the list of arguments to pass to the application we are moving to.

Note: If you wish to get the size of the list, control_next_app_args_size should be called before this, as this function will steal the elements from the string vector and set the size to 0.

Parameters

control The control for the channel

Returns: The arguments to pass to the application we are moving to

Definition at line 1710 of file control.c.

References AST_VECTOR_STEAL_ELEMENTS.

Referenced by stasis_app_exec().

 {
    return AST_VECTOR_STEAL_ELEMENTS(&control->next_app_args);
 }

◆ control_next_app_args_size()

int control_next_app_args_size ( struct stasis_app_control * control )

Returns the number of arguments to be passed to the application we are moving to.

Note: This should always be called before control_next_app_args, as calling that function will steal all elements from the string vector and set the size to 0.

Parameters

control The control for the channel

Returns: The number of arguments to be passed to the application we are moving to

Definition at line 1715 of file control.c.

References AST_VECTOR_SIZE.

Referenced by stasis_app_exec().

 {
    return AST_VECTOR_SIZE(&control->next_app_args);
 }

◆ control_prestart_dispatch_all()

int control_prestart_dispatch_all	(	struct stasis_app_control *	control,
		struct ast_channel *	chan
	)

Dispatch all queued prestart commands.

Parameters

control	The control for chan
channel	The channel on which commands should be executed

Returns: The number of commands executed

Definition at line 1535 of file control.c.

References ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, AO2_ITERATOR_UNLINK, ast_channel_lock, ast_channel_unlock, command_invoke(), command_prestart_get_container(), and stasis_app_control::command_queue.

Referenced by stasis_app_exec().

 {
    struct ao2_container *command_queue;
    int count = 0;
    struct ao2_iterator iter;
    struct stasis_app_command *command;
 
    ast_channel_lock(chan);
    command_queue = command_prestart_get_container(chan);
    ast_channel_unlock(chan);
    if (!command_queue) {
       return 0;
    }
 
    iter = ao2_iterator_init(command_queue, AO2_ITERATOR_UNLINK);
 
    while ((command = ao2_iterator_next(&iter))) {
       command_invoke(command, control, chan);
       ao2_cleanup(command);
       ++count;
    }
 
    ao2_iterator_destroy(&iter);
    ao2_cleanup(command_queue);
    return count;
 }

◆ control_set_app()

void control_set_app	(	struct stasis_app_control *	control,
		struct stasis_app *	app
	)

Set the application the control object belongs to.

Parameters

control	The control for the channel
app	The application this control will now belong to

Note: This will unref control's previous app by 1, and bump app by 1

Definition at line 1691 of file control.c.

References ao2_bump, ao2_cleanup, and stasis_app_control::app.

Referenced by stasis_app_exec().

 {
    ao2_cleanup(control->app);
    control->app = ao2_bump(app);
 }

◆ control_silence_stop_now()

void control_silence_stop_now ( struct stasis_app_control * control )

Stop playing silence to a channel right now.

Since: 13.9.0

Parameters

control The control for chan

Definition at line 837 of file control.c.

References ast_channel_stop_silence_generator(), ast_debug, stasis_app_control::channel, NULL, stasis_app_control::silgen, and stasis_app_control_get_channel_id().

Referenced by app_control_silence_stop(), and stasis_app_exec().

 {
    if (control->silgen) {
       ast_debug(3, "%s: Stopping silence generator\n",
          stasis_app_control_get_channel_id(control));
       ast_channel_stop_silence_generator(
          control->channel, control->silgen);
       control->silgen = NULL;
    }
 }

◆ control_swap_channel_in_bridge()

int control_swap_channel_in_bridge	(	struct stasis_app_control *	control,
		struct ast_bridge *	bridge,
		struct ast_channel *	chan,
		struct ast_channel *	swap
	)

Command for swapping a channel in a bridge.

Parameters

control	The control for chan
chan	The channel on which commands should be executed
bridge	Bridge to be passed to the callback
swap	Channel to swap with when joining the bridge

Definition at line 1284 of file control.c.

References ao2_lock, ao2_unlock, stasis_app_control::app, app_subscribe_bridge(), ast_assert, ast_bridge_depart(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_DEPARTABLE, AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP, ast_bridge_set_after_callback(), ast_channel_lock, ast_channel_pbx(), ast_channel_pbx_set(), ast_channel_unlock, ast_debug, ast_log, stasis_app_control::bridge, bridge_after_cb(), bridge_after_cb_failed(), stasis_app_control::bridge_features, ast_bridge_features::inhibit_colp, LOG_ERROR, NULL, stasis_app_control::pbx, set_interval_hook(), stasis_app_control_get_channel_id(), stasis_app_get_bridge(), and ast_bridge::uniqueid.

Referenced by control_add_channel_to_bridge(), and defer_bridge_add().

 {
    int res;
    struct ast_bridge_features *features;
    int flags = AST_BRIDGE_IMPART_CHAN_DEPARTABLE;
 
    if (!control || !bridge) {
       return -1;
    }
 
    ast_debug(3, "%s: Adding to bridge %s\n",
       stasis_app_control_get_channel_id(control),
       bridge->uniqueid);
 
    ast_assert(chan != NULL);
 
    /* Depart whatever Stasis bridge we're currently in. */
    if (stasis_app_get_bridge(control)) {
       /* Note that it looks like there's a race condition here, since
        * we don't have control locked. But this happens from the
        * control callback thread, so there won't be any other
        * concurrent attempts to bridge.
        */
       ast_bridge_depart(chan);
    }
 
 
    res = ast_bridge_set_after_callback(chan, bridge_after_cb,
       bridge_after_cb_failed, control);
    if (res != 0) {
       ast_log(LOG_ERROR, "Error setting after-bridge callback\n");
       return -1;
    }
 
    ao2_lock(control);
 
    /* Ensure the controlling application is subscribed early enough
     * to receive the ChannelEnteredBridge message. This works in concert
     * with the subscription handled in the Stasis application execution
     * loop */
    app_subscribe_bridge(control->app, bridge);
 
    /* Save off the channel's PBX */
    ast_assert(control->pbx == NULL);
    if (!control->pbx) {
       control->pbx = ast_channel_pbx(chan);
       ast_channel_pbx_set(chan, NULL);
    }
 
    /* Pull bridge features from the control */
    features = control->bridge_features;
    control->bridge_features = NULL;
    if (features && features->inhibit_colp) {
       flags |= AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP;
    }
 
    ast_assert(stasis_app_get_bridge(control) == NULL);
    /* We need to set control->bridge here since bridge_after_cb may be run
     * before ast_bridge_impart returns.  bridge_after_cb gets a reason
     * code so it can tell if the bridge is actually valid or not.
     */
    control->bridge = bridge;
 
    /* We can't be holding the control lock while impart is running
     * or we could create a deadlock with bridge_after_cb which also
     * tries to lock control.
     */
    ao2_unlock(control);
    res = ast_bridge_impart(bridge,
       chan,
       swap,
       features, /* features */
       flags);
    if (res != 0) {
       /* ast_bridge_impart failed before it could spawn the depart
        * thread.  The callbacks aren't called in this case.
        * The impart could still fail even if ast_bridge_impart returned
        * ok but that's handled by bridge_after_cb.
        */
       ast_log(LOG_ERROR, "Error adding channel to bridge\n");
       ao2_lock(control);
       ast_channel_pbx_set(chan, control->pbx);
       control->pbx = NULL;
       control->bridge = NULL;
       ao2_unlock(control);
    } else {
       ast_channel_lock(chan);
       set_interval_hook(chan);
       ast_channel_unlock(chan);
    }
 
    return res;
 }

◆ control_wait()

void control_wait ( struct stasis_app_control * control )

Blocks until control's command queue has a command available.

Parameters

control Control to block on.

Definition at line 1515 of file control.c.

References ao2_container_count(), ao2_lock, ao2_object_get_lockaddr(), ao2_unlock, ast_assert, ast_cond_wait, ast_log, stasis_app_control::command_queue, LOG_ERROR, NULL, and stasis_app_control::wait_cond.

Referenced by stasis_app_exec().

 {
    if (!control) {
       return;
    }
 
    ast_assert(control->command_queue != NULL);
 
    ao2_lock(control->command_queue);
    while (ao2_container_count(control->command_queue) == 0) {
       int res = ast_cond_wait(&control->wait_cond,
          ao2_object_get_lockaddr(control->command_queue));
       if (res < 0) {
          ast_log(LOG_ERROR, "Error waiting on command queue\n");
          break;
       }
    }
    ao2_unlock(control->command_queue);
 }

◆ depart_channel()

static int depart_channel	(	struct stasis_app_control *	control,
		struct ast_channel *	chan
	)

static

Depart a channel from a bridge, and potentially add it back to the dial bridge.

Parameters

control	Take a guess
chan	Take another guess

Definition at line 1069 of file control.c.

References add_to_dial_bridge(), ast_bridge_depart(), ast_channel_pbx(), ast_check_hangup(), and AST_STATE_UP.

Referenced by app_control_remove_channel_from_bridge(), and bridge_channel_depart().

 {
    ast_bridge_depart(chan);
 
    /* Channels which have a PBX are not ones that have been created and dialed from ARI. They
     * have externally come in from the dialplan, and thus should not be placed into the dial
     * bridge. Only channels which are created and dialed in ARI should go into the dial bridge.
     */
    if (!ast_check_hangup(chan) && ast_channel_state(chan) != AST_STATE_UP && !ast_channel_pbx(chan)) {
       /* Channel is still being dialed, so put it back in the dialing bridge */
       add_to_dial_bridge(control, chan);
    }
 
    return 0;
 }

◆ dial_bridge_after_cb()

static void dial_bridge_after_cb	(	struct ast_channel *	chan,
		void *	data
	)

static

after bridge callback for the dial bridge

The only purpose of this callback is to ensure that the control structure's bridge pointer is NULLed

Definition at line 1009 of file control.c.

References __ao2_cleanup(), ast_channel_get_bridge_channel(), ast_channel_hangupcause(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_debug, stasis_app_control::bridge, bridge_channel_depart(), stasis_app_control::channel, NULL, and stasis_app_send_command_async().

Referenced by add_to_dial_bridge(), and dial_bridge_after_cb_failed().

 {
    struct stasis_app_control *control = data;
    struct ast_bridge_channel *bridge_channel;
 
    ast_channel_lock(chan);
    bridge_channel = ast_channel_get_bridge_channel(chan);
    ast_channel_unlock(chan);
 
    ast_debug(3, "Channel: <%s>  Reason: %d\n", ast_channel_name(control->channel), ast_channel_hangupcause(chan));
 
    stasis_app_send_command_async(control, bridge_channel_depart, bridge_channel, __ao2_cleanup);
 
    control->bridge = NULL;
 }

◆ dial_bridge_after_cb_failed()

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

static

Definition at line 1025 of file control.c.

References ast_channel_name(), ast_debug, stasis_app_control::channel, and dial_bridge_after_cb().

Referenced by add_to_dial_bridge().

 {
    struct stasis_app_control *control = data;
 
    ast_debug(3, "Channel: <%s>  Reason: %d\n", ast_channel_name(control->channel), reason);
    dial_bridge_after_cb(control->channel, data);
 }

◆ dtmf_in_bridge()

static void dtmf_in_bridge	(	struct ast_channel *	chan,
		struct stasis_app_control_dtmf_data *	dtmf_data
	)

static

Definition at line 521 of file control.c.

References stasis_app_control_dtmf_data::after, ast_dtmf_stream_external(), stasis_app_control_dtmf_data::before, stasis_app_control_dtmf_data::between, stasis_app_control_dtmf_data::dtmf, and stasis_app_control_dtmf_data::duration.

Referenced by app_control_dtmf().

 {
    if (dtmf_data->before) {
       usleep(dtmf_data->before * 1000);
    }
 
    ast_dtmf_stream_external(chan, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
 
    if (dtmf_data->after) {
       usleep(dtmf_data->after * 1000);
    }
 }

◆ dtmf_no_bridge()

static void dtmf_no_bridge	(	struct ast_channel *	chan,
		struct stasis_app_control_dtmf_data *	dtmf_data
	)

static

Definition at line 534 of file control.c.

References stasis_app_control_dtmf_data::after, ast_dtmf_stream(), ast_safe_sleep(), stasis_app_control_dtmf_data::before, stasis_app_control_dtmf_data::between, stasis_app_control_dtmf_data::dtmf, stasis_app_control_dtmf_data::duration, and NULL.

Referenced by app_control_dtmf().

 {
    if (dtmf_data->before) {
       ast_safe_sleep(chan, dtmf_data->before);
    }
 
    ast_dtmf_stream(chan, NULL, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
 
    if (dtmf_data->after) {
       ast_safe_sleep(chan, dtmf_data->after);
    }
 }

◆ exec_command()

static struct stasis_app_command* exec_command	(	struct stasis_app_control *	control,
		stasis_app_command_cb	command_fn,
		void *	data,
		command_data_destructor_fn	data_destructor
	)

static

Definition at line 301 of file control.c.

References exec_command_on_condition(), and NULL.

Referenced by stasis_app_send_command_async().

 {
    return exec_command_on_condition(control, command_fn, data, data_destructor, NULL);
 }

◆ exec_command_on_condition()

static struct stasis_app_command* exec_command_on_condition	(	struct stasis_app_control *	control,
		stasis_app_command_cb	command_fn,
		void *	data,
		command_data_destructor_fn	data_destructor,
		app_command_can_exec_cb	can_exec_fn
	)

static

Definition at line 267 of file control.c.

References ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_cond_signal, command_complete(), command_create(), stasis_app_control::command_queue, noop_cb(), NULL, OBJ_NOLOCK, retval, and stasis_app_control::wait_cond.

Referenced by app_send_command_on_condition(), and exec_command().

 {
    int retval;
    struct stasis_app_command *command;
 
    command_fn = command_fn ? : noop_cb;
 
    command = command_create(command_fn, data, data_destructor);
    if (!command) {
       return NULL;
    }
 
    ao2_lock(control->command_queue);
    if (control->is_done) {
       ao2_unlock(control->command_queue);
       ao2_ref(command, -1);
       return NULL;
    }
    if (can_exec_fn && (retval = can_exec_fn(control))) {
       ao2_unlock(control->command_queue);
       command_complete(command, retval);
       return command;
    }
 
    ao2_link_flags(control->command_queue, command, OBJ_NOLOCK);
    ast_cond_signal(&control->wait_cond);
    ao2_unlock(control->command_queue);
 
    return command;
 }

◆ free_chanvar()

static void free_chanvar ( void * data )

static

Definition at line 692 of file control.c.

References ast_free, chanvar::name, chanvar::value, and var.

Referenced by stasis_app_control_set_channel_var().

 {
    struct chanvar *var = data;
 
    ast_free(var->name);
    ast_free(var->value);
    ast_free(var);
 }

◆ get_dial_bridge()

static struct ast_bridge* get_dial_bridge ( void )

static

Retrieve a reference to the dial bridge.

If the dial bridge has not been created yet, it will be created, otherwise, a reference to the existing bridge will be returned.

The caller will need to unreference the dial bridge once they are finished with it.

Return values

NULL	Unable to find/create the dial bridge
non-NULL	A reference to the dial bridge

Definition at line 974 of file control.c.

References ao2_bump, ast_mutex_lock, ast_mutex_unlock, bridge_channel_depart(), dial_bridge_lock, end, NULL, shutting_down, and stasis_app_bridge_create_invisible().

Referenced by add_to_dial_bridge().

 {
    struct ast_bridge *ret_bridge = NULL;
 
    ast_mutex_lock(&dial_bridge_lock);
 
    if (shutting_down) {
       goto end;
    }
 
    if (dial_bridge) {
       ret_bridge = ao2_bump(dial_bridge);
       goto end;
    }
 
    dial_bridge = stasis_app_bridge_create_invisible("holding", "dial_bridge", NULL);
    if (!dial_bridge) {
       goto end;
    }
    ret_bridge = ao2_bump(dial_bridge);
 
 end:
    ast_mutex_unlock(&dial_bridge_lock);
    return ret_bridge;
 }

◆ hangup_channel()

static int hangup_channel	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 1196 of file control.c.

References ast_softhangup(), and AST_SOFTHANGUP_EXPLICIT.

Referenced by bridge_timeout().

 {
    ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
    return 0;
 }

◆ internal_bridge_after_cb()

static void internal_bridge_after_cb	(	struct ast_channel *	chan,
		void *	data,
		enum ast_bridge_after_cb_reason	reason
	)

static

Definition at line 1108 of file control.c.

References __ao2_cleanup(), ao2_lock, ao2_unlock, stasis_app_control::app, app_unsubscribe_bridge(), ast_assert, AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED, ast_bridge_after_cb_reason_string(), ast_bridge_setup_after_goto(), ast_channel_get_bridge_channel(), ast_channel_lock, ast_channel_pbx_set(), ast_channel_uniqueid(), ast_channel_unlock, ast_debug, AST_SOFTHANGUP_ASYNCGOTO, AST_SOFTHANGUP_DEV, ast_softhangup_nolock(), stasis_app_control::bridge, bridge_channel_depart(), stasis_app_control::channel, NULL, stasis_app_control::pbx, stasis_app_channel_is_stasis_end_published(), stasis_app_send_command_async(), and ast_bridge::uniqueid.

Referenced by bridge_after_cb(), and bridge_after_cb_failed().

 {
    struct stasis_app_control *control = data;
    struct ast_bridge_channel *bridge_channel;
 
    ao2_lock(control);
    ast_debug(3, "%s, %s: %s\n",
       ast_channel_uniqueid(chan), control->bridge ? control->bridge->uniqueid : "unknown",
          ast_bridge_after_cb_reason_string(reason));
 
    if (reason == AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED) {
       /* The impart actually failed so control->bridge isn't valid. */
       control->bridge = NULL;
    }
 
    ast_assert(chan == control->channel);
 
    /* Restore the channel's PBX */
    ast_channel_pbx_set(control->channel, control->pbx);
    control->pbx = NULL;
 
    if (control->bridge) {
       app_unsubscribe_bridge(control->app, control->bridge);
 
       /* No longer in the bridge */
       control->bridge = NULL;
 
       /* Get the bridge channel so we don't depart from the wrong bridge */
       ast_channel_lock(chan);
       bridge_channel = ast_channel_get_bridge_channel(chan);
       ast_channel_unlock(chan);
 
       /* Depart this channel from the bridge using the command queue if possible */
       stasis_app_send_command_async(control, bridge_channel_depart, bridge_channel, __ao2_cleanup);
    }
 
    if (stasis_app_channel_is_stasis_end_published(chan)) {
       /* The channel has had a StasisEnd published on it, but until now had remained in
        * the bridging system. This means that the channel moved from a Stasis bridge to a
        * non-Stasis bridge and is now exiting the bridging system. Because of this, the
        * channel needs to exit the Stasis application and go to wherever the non-Stasis
        * bridge has directed it to go. If the non-Stasis bridge has not set up an after
        * bridge destination, then the channel should be hung up.
        */
       int hangup_flag;
 
       hangup_flag = ast_bridge_setup_after_goto(chan) ? AST_SOFTHANGUP_DEV : AST_SOFTHANGUP_ASYNCGOTO;
       ast_channel_lock(chan);
       ast_softhangup_nolock(chan, hangup_flag);
       ast_channel_unlock(chan);
    }
    ao2_unlock(control);
 }

◆ noop_cb()

static int noop_cb	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 257 of file control.c.

Referenced by exec_command_on_condition().

 {
    return 0;
 }

◆ set_interval_hook()

static void set_interval_hook ( struct ast_channel * chan )

static

Set a dial timeout interval hook on the channel.

The absolute time that the timeout should occur is stored on a datastore on the channel. This time is converted into a relative number of milliseconds in the future. Then an interval hook is set to trigger in that number of milliseconds.

Precondition: chan is locked

Parameters

chan	The channel on which to set the interval hook

Definition at line 1254 of file control.c.

References ao2_ref, ast_bridge_interval_hook(), ast_channel_datastore_find(), ast_channel_get_bridge_channel(), ast_null_frame, ast_queue_frame(), ast_tvdiff_ms(), ast_tvnow(), bridge_timeout(), ast_bridge_channel::chan, ast_datastore::data, ast_bridge_channel::features, and NULL.

Referenced by control_swap_channel_in_bridge(), and set_timeout().

 {
    struct ast_datastore *datastore;
    struct timeval *hangup_time;
    int64_t ms;
    struct ast_bridge_channel *bridge_channel;
 
    datastore = ast_channel_datastore_find(chan, &timeout_datastore, NULL);
    if (!datastore) {
       return;
    }
 
    hangup_time = datastore->data;
 
    ms = ast_tvdiff_ms(*hangup_time, ast_tvnow());
    bridge_channel = ast_channel_get_bridge_channel(chan);
    if (!bridge_channel) {
       return;
    }
 
    if (ast_bridge_interval_hook(bridge_channel->features, 0, ms > 0 ? ms : 1,
          bridge_timeout, NULL, NULL, 0)) {
       ao2_ref(bridge_channel, -1);
       return;
    }
 
    ast_queue_frame(bridge_channel->chan, &ast_null_frame);
    ao2_ref(bridge_channel, -1);
 }

◆ set_timeout()

static int set_timeout	(	struct ast_channel *	chan,
		unsigned int	timeout
	)

static

Set dial timeout on a channel to be dialed.

Parameters

chan	The channel on which to set the dial timeout
timeout	The timeout in seconds

Definition at line 1603 of file control.c.

References ast_channel_datastore_add(), ast_channel_is_bridged(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_malloc, ast_samp2tv(), ast_tvadd(), ast_tvnow(), ast_datastore::data, NULL, and set_interval_hook().

Referenced by app_control_dial().

 {
    struct ast_datastore *datastore;
    struct timeval *hangup_time;
 
    hangup_time = ast_malloc(sizeof(struct timeval));
 
    datastore = ast_datastore_alloc(&timeout_datastore, NULL);
    if (!datastore) {
       return -1;
    }
    *hangup_time = ast_tvadd(ast_tvnow(), ast_samp2tv(timeout, 1));
    datastore->data = hangup_time;
 
    ast_channel_lock(chan);
    ast_channel_datastore_add(chan, datastore);
 
    if (ast_channel_is_bridged(chan)) {
       set_interval_hook(chan);
    }
    ast_channel_unlock(chan);
 
    return 0;
 }

◆ stasis_app_control_absorb_dtmf_in_bridge()

void stasis_app_control_absorb_dtmf_in_bridge	(	struct stasis_app_control *	control,
		int	absorb
	)

Set whether DTMF from the channel is absorbed instead of passing through to the bridge.

Parameters

control	Control whose channel should have its DTMF absorbed when bridged
absorb	Whether DTMF should be absorbed (1) instead of passed through (0).

Definition at line 1464 of file control.c.

References stasis_app_control::bridge_features, and ast_bridge_features::dtmf_passthrough.

Referenced by ast_ari_bridges_add_channel().

 {
    control->bridge_features->dtmf_passthrough = !absorb;
 }

◆ stasis_app_control_add_channel_to_bridge()

int stasis_app_control_add_channel_to_bridge	(	struct stasis_app_control *	control,
		struct ast_bridge *	bridge
	)

Add a channel to the bridge.

Parameters

control	Control whose channel should be added to the bridge
bridge	Pointer to the bridge

Returns: non-zero on failure; zero on success

Definition at line 1383 of file control.c.

References app_control_can_add_channel_to_bridge(), app_send_command_on_condition(), ast_debug, control_add_channel_to_bridge(), NULL, and stasis_app_control_get_channel_id().

Referenced by ast_ari_bridges_add_channel().

 {
    ast_debug(3, "%s: Sending channel add_to_bridge command\n",
          stasis_app_control_get_channel_id(control));
 
    return app_send_command_on_condition(
       control, control_add_channel_to_bridge, bridge, NULL,
       app_control_can_add_channel_to_bridge);
 }

◆ stasis_app_control_add_role()

int stasis_app_control_add_role	(	struct stasis_app_control *	control,
		const char *	role
	)

Apply a bridge role to a channel controlled by a stasis app control.

Parameters

control	Control for `res_stasis`
role	Role to apply

Returns: 0 for success; -1 for error.

Definition at line 316 of file control.c.

References app_control_add_role(), ast_free_ptr(), ast_strdup, and stasis_app_send_command_async().

Referenced by ast_ari_bridges_add_channel().

 {
    char *role_dup;
 
    role_dup = ast_strdup(role);
    if (!role_dup) {
       return -1;
    }
 
    stasis_app_send_command_async(control, app_control_add_role, role_dup, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_bridge_features_init()

int stasis_app_control_bridge_features_init ( struct stasis_app_control * control )

Initialize bridge features into a channel control.

Note: Bridge features on a control are destroyed after each bridge session, so new features need to be initialized before each bridge add.

Parameters

control Control in which to store the features

Returns: non-zero on failure; zero on success

Definition at line 1451 of file control.c.

References ast_bridge_features_new(), and stasis_app_control::bridge_features.

Referenced by ast_ari_bridges_add_channel().

 {
    struct ast_bridge_features *features;
 
    features = ast_bridge_features_new();
    if (!features) {
       return 1;
    }
    control->bridge_features = features;
    return 0;
 }

◆ stasis_app_control_clear_roles()

void stasis_app_control_clear_roles ( struct stasis_app_control * control )

Clear bridge roles currently applied to a channel controlled by a stasis app control.

Parameters

control Control for res_stasis

Definition at line 338 of file control.c.

References app_control_clear_roles(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_bridges_add_channel().

 {
    stasis_app_send_command_async(control, app_control_clear_roles, NULL, NULL);
 }

◆ stasis_app_control_continue()

int stasis_app_control_continue	(	struct stasis_app_control *	control,
		const char *	context,
		const char *	extension,
		int	priority
	)

Exit res_stasis and continue execution in the dialplan.

If the channel is no longer in res_stasis, this function does nothing.

Parameters

control	Control for `res_stasis`
context	An optional context to continue to
extension	An optional extension to continue to
priority	An optional priority to continue to

Returns: 0 for success; -1 for error.

Definition at line 389 of file control.c.

References app_control_continue(), ast_calloc, ast_copy_string(), ast_free_ptr(), stasis_app_control_continue_data::context, stasis_app_control_continue_data::extension, priority, stasis_app_control_continue_data::priority, S_OR, and stasis_app_send_command_async().

Referenced by ast_ari_channels_continue_in_dialplan().

 {
    struct stasis_app_control_continue_data *continue_data;
 
    if (!(continue_data = ast_calloc(1, sizeof(*continue_data)))) {
       return -1;
    }
    ast_copy_string(continue_data->context, S_OR(context, ""), sizeof(continue_data->context));
    ast_copy_string(continue_data->extension, S_OR(extension, ""), sizeof(continue_data->extension));
    if (priority > 0) {
       continue_data->priority = priority;
    } else {
       continue_data->priority = -1;
    }
 
    stasis_app_send_command_async(control, app_control_continue, continue_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_dial()

int stasis_app_control_dial	(	struct stasis_app_control *	control,
		const char *	dialstring,
		unsigned int	timeout
	)

Dial a channel.

Parameters

control	Control for `res_stasis`.
dialstring	The dialstring to pass to the channel driver
timeout	Optional timeout in milliseconds

Definition at line 1666 of file control.c.

References app_control_dial(), args, control_dial_args_alloc(), control_dial_args_destroy(), and stasis_app_send_command_async().

Referenced by ast_ari_channels_dial().

 {
    struct control_dial_args *args;
 
    args = control_dial_args_alloc(dialstring, timeout);
    if (!args) {
       return -1;
    }
 
    return stasis_app_send_command_async(control, app_control_dial,
       args, control_dial_args_destroy);
 }

◆ stasis_app_control_dtmf()

int stasis_app_control_dtmf	(	struct stasis_app_control *	control,
		const char *	dtmf,
		int	before,
		int	between,
		unsigned int	duration,
		int	after
	)

Send DTMF to the channel associated with this control.

Parameters

control	Control for `res_stasis`.
dtmf	DTMF string.
before	Amount of time to wait before sending DTMF digits.
between	Amount of time between each DTMF digit.
duration	Amount of time each DTMF digit lasts for.
after	Amount of time to wait after sending DTMF digits.

Returns: 0 for success.; -1 for error.

Definition at line 565 of file control.c.

References stasis_app_control_dtmf_data::after, app_control_dtmf(), ast_calloc, ast_free_ptr(), stasis_app_control_dtmf_data::before, stasis_app_control_dtmf_data::between, stasis_app_control_dtmf_data::dtmf, stasis_app_control_dtmf_data::duration, and stasis_app_send_command_async().

Referenced by ast_ari_channels_send_dtmf().

 {
    struct stasis_app_control_dtmf_data *dtmf_data;
 
    if (!(dtmf_data = ast_calloc(1, sizeof(*dtmf_data) + strlen(dtmf) + 1))) {
       return -1;
    }
 
    dtmf_data->before = before;
    dtmf_data->between = between;
    dtmf_data->duration = duration;
    dtmf_data->after = after;
    strcpy(dtmf_data->dtmf, dtmf);
 
    stasis_app_send_command_async(control, app_control_dtmf, dtmf_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_get_channel_id()

const char* stasis_app_control_get_channel_id ( const struct stasis_app_control * control )

Returns the uniqueid of the channel associated with this control.

Parameters

control Control object.

Returns: Uniqueid of the associate channel.; NULL if control is NULL.

Definition at line 1430 of file control.c.

References ast_channel_uniqueid(), and stasis_app_control::channel.

Referenced by app_control_answer(), app_control_remove_channel_from_bridge(), app_control_silence_start(), check_add_remove_channel(), control_compare(), control_hash(), control_silence_stop_now(), control_swap_channel_in_bridge(), masq_match_cb(), playback_publish(), recording_publish(), stasis_app_control_add_channel_to_bridge(), stasis_app_control_answer(), stasis_app_control_get_snapshot(), stasis_app_control_play_uri(), stasis_app_control_record(), and stasis_app_control_remove_channel_from_bridge().

 {
    return ast_channel_uniqueid(control->channel);
 }

◆ stasis_app_control_get_snapshot()

struct ast_channel_snapshot* stasis_app_control_get_snapshot ( const struct stasis_app_control * control )

Returns the most recent snapshot for the associated channel.

The returned pointer is AO2 managed, so ao2_cleanup() when you're done.

Parameters

control Control for res_stasis.

Returns: Most recent snapshot. ao2_cleanup() when done.; NULL if channel isn't in cache.

Definition at line 860 of file control.c.

References ast_channel_snapshot_get_latest(), and stasis_app_control_get_channel_id().

Referenced by ari_bridges_play_helper(), ari_channels_handle_play(), ast_ari_channels_continue_in_dialplan(), and channel_state_invalid().

 {
    return ast_channel_snapshot_get_latest(stasis_app_control_get_channel_id(control));
 }

◆ stasis_app_control_hold()

void stasis_app_control_hold ( struct stasis_app_control * control )

Place the channel associated with the control on hold.

Parameters

control Control for res_stasis.

Definition at line 748 of file control.c.

References app_control_hold(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_hold().

 {
    stasis_app_send_command_async(control, app_control_hold, NULL, NULL);
 }

◆ stasis_app_control_inhibit_colp_in_bridge()

void stasis_app_control_inhibit_colp_in_bridge	(	struct stasis_app_control *	control,
		int	inhibit_colp
	)

Set whether COLP frames should be generated when joining the bridge.

Since: 18

Parameters

control	Control whose channel should have its COLP frames inhibited when bridged
mute	Whether COLP frames should be generated (0) or not (1).

Definition at line 1476 of file control.c.

References stasis_app_control::bridge_features, and ast_bridge_features::inhibit_colp.

Referenced by ast_ari_bridges_add_channel().

 {
    control->bridge_features->inhibit_colp = inhibit_colp;
 }

◆ stasis_app_control_moh_start()

void stasis_app_control_moh_start	(	struct stasis_app_control *	control,
		const char *	moh_class
	)

Play music on hold to a channel (does not affect hold status)

Parameters

control	Control for `res_stasis`.
moh_class	class of music on hold to play (NULL allowed)

Definition at line 780 of file control.c.

References app_control_moh_start(), ast_free_ptr(), ast_strdup, ast_strlen_zero, NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_start_moh().

 {
    char *data = NULL;
 
    if (!ast_strlen_zero(moh_class)) {
       data = ast_strdup(moh_class);
    }
 
    stasis_app_send_command_async(control, app_control_moh_start, data, ast_free_ptr);
 }

◆ stasis_app_control_moh_stop()

void stasis_app_control_moh_stop ( struct stasis_app_control * control )

Stop playing music on hold to a channel (does not affect hold status)

Parameters

control Control for res_stasis.

Definition at line 798 of file control.c.

References app_control_moh_stop(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_stop_moh().

 {
    stasis_app_send_command_async(control, app_control_moh_stop, NULL, NULL);
 }

◆ stasis_app_control_move()

int stasis_app_control_move	(	struct stasis_app_control *	control,
		const char *	app_name,
		const char *	app_args
	)

Exit res_stasis and move to another Stasis application.

If the channel is no longer in res_stasis, this function does nothing.

Parameters

control	Control for `res_stasis`
app_name	The name of the application to switch to
app_args	The list of arguments to pass to the application

Returns: 0 for success; -1 for error

Definition at line 451 of file control.c.

References stasis_app_control_move_data::app_args, app_control_move(), stasis_app_control_move_data::app_name, ast_calloc, ast_free_ptr(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_move().

 {
    struct stasis_app_control_move_data *move_data;
    size_t size;
 
    size = sizeof(*move_data) + strlen(app_name) + 1;
    if (app_args) {
       /* Application arguments are optional */
       size += strlen(app_args) + 1;
    }
 
    if (!(move_data = ast_calloc(1, size))) {
       return -1;
    }
 
    move_data->app_name = (char *)move_data + sizeof(*move_data);
    strcpy(move_data->app_name, app_name); /* Safe */
 
    if (app_args) {
       move_data->app_args = move_data->app_name + strlen(app_name) + 1;
       strcpy(move_data->app_args, app_args); /* Safe */
    } else {
       move_data->app_args = NULL;
    }
 
    stasis_app_send_command_async(control, app_control_move, move_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_mute()

int stasis_app_control_mute	(	struct stasis_app_control *	control,
		unsigned int	direction,
		enum ast_frame_type	frametype
	)

Mute the channel associated with this control.

Parameters

control	Control for `res_stasis`.
direction	The direction in which the audio should be muted.
frametype	The type of stream that should be muted.

Returns: 0 for success; -1 for error.

Definition at line 631 of file control.c.

References app_control_mute(), ast_calloc, ast_free_ptr(), stasis_app_control_mute_data::direction, stasis_app_control_mute_data::frametype, and stasis_app_send_command_async().

Referenced by ast_ari_channels_mute().

 {
    struct stasis_app_control_mute_data *mute_data;
 
    if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
       return -1;
    }
 
    mute_data->direction = direction;
    mute_data->frametype = frametype;
 
    stasis_app_send_command_async(control, app_control_mute, mute_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_mute_in_bridge()

void stasis_app_control_mute_in_bridge	(	struct stasis_app_control *	control,
		int	mute
	)

Set whether audio from the channel is muted instead of passing through to the bridge.

Parameters

control	Control whose channel should have its audio muted when bridged
mute	Whether audio should be muted (1) instead of passed through (0).

Definition at line 1470 of file control.c.

References stasis_app_control::bridge_features, mute, and ast_bridge_features::mute.

Referenced by ast_ari_bridges_add_channel().

 {
    control->bridge_features->mute = mute;
 }

◆ stasis_app_control_publish()

void stasis_app_control_publish	(	struct stasis_app_control *	control,
		struct stasis_message *	message
	)

Publish a message to the control's channel's topic.

Parameters

control	Control to publish to
message	Message to publish

Definition at line 1436 of file control.c.

References ast_channel_topic(), stasis_app_control::channel, and stasis_publish().

Referenced by playback_publish(), and recording_publish().

 {
    if (!control || !control->channel || !message) {
       return;
    }
    stasis_publish(ast_channel_topic(control->channel), message);
 }

◆ stasis_app_control_queue_control()

int stasis_app_control_queue_control	(	struct stasis_app_control *	control,
		enum ast_control_frame_type	frame_type
	)

Queue a control frame without payload.

Parameters

control	Control to publish to.
frame_type	type of control frame.

Returns: zero on success; non-zero on failure

Definition at line 1445 of file control.c.

References ast_queue_control(), and stasis_app_control::channel.

Referenced by playback_forward(), playback_pause(), playback_restart(), playback_reverse(), playback_stop(), playback_unpause(), recording_cancel(), recording_mute(), recording_pause(), recording_stop(), recording_unmute(), and recording_unpause().

 {
    return ast_queue_control(control->channel, frame_type);
 }

◆ stasis_app_control_redirect()

int stasis_app_control_redirect	(	struct stasis_app_control *	control,
		const char *	endpoint
	)

Redirect a channel in res_stasis to a particular endpoint.

Parameters

control	Control for `res_stasis`
endpoint	The endpoint transfer string where the channel should be sent to

Returns: 0 for success; -1 for error

Definition at line 500 of file control.c.

References app_control_redirect(), ast_free_ptr(), ast_strdup, and stasis_app_send_command_async().

Referenced by ast_ari_channels_redirect().

 {
    char *endpoint_data = ast_strdup(endpoint);
 
    if (!endpoint_data) {
       return -1;
    }
 
    stasis_app_send_command_async(control, app_control_redirect, endpoint_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_register_add_rule()

void stasis_app_control_register_add_rule	(	struct stasis_app_control *	control,
		struct stasis_app_control_rule *	rule
	)

Registers an add channel to bridge rule.

Parameters

control	Control object
rule	The rule to register

Definition at line 217 of file control.c.

References stasis_app_control::add_rules, and app_control_register_rule().

Referenced by stasis_app_control_record().

 {
    return app_control_register_rule(control, &control->add_rules, rule);
 }

◆ stasis_app_control_register_remove_rule()

void stasis_app_control_register_remove_rule	(	struct stasis_app_control *	control,
		struct stasis_app_control_rule *	rule
	)

Registers a remove channel from bridge rule.

Parameters

control	Control object
rule	The rule to register

Definition at line 231 of file control.c.

References app_control_register_rule(), and stasis_app_control::remove_rules.

 {
    return app_control_register_rule(control, &control->remove_rules, rule);
 }

◆ stasis_app_control_remove_channel_from_bridge()

int stasis_app_control_remove_channel_from_bridge	(	struct stasis_app_control *	control,
		struct ast_bridge *	bridge
	)

Remove a channel from the bridge.

Parameters

control	Control whose channel should be removed from the bridge
bridge	Pointer to the bridge

Returns: non-zero on failure; zero on success

Definition at line 1420 of file control.c.

References app_control_can_remove_channel_from_bridge(), app_control_remove_channel_from_bridge(), app_send_command_on_condition(), ast_debug, NULL, and stasis_app_control_get_channel_id().

Referenced by ast_ari_bridges_remove_channel().

 {
    ast_debug(3, "%s: Sending channel remove_from_bridge command\n",
          stasis_app_control_get_channel_id(control));
    return app_send_command_on_condition(
       control, app_control_remove_channel_from_bridge, bridge, NULL,
       app_control_can_remove_channel_from_bridge);
 }

◆ stasis_app_control_ring()

int stasis_app_control_ring ( struct stasis_app_control * control )

Indicate ringing to the channel associated with this control.

Parameters

control Control for res_stasis.

Returns: 0 for success.; -1 for error.

Definition at line 592 of file control.c.

References app_control_ring(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_ring().

 {
    stasis_app_send_command_async(control, app_control_ring, NULL, NULL);
 
    return 0;
 }

◆ stasis_app_control_ring_stop()

int stasis_app_control_ring_stop ( struct stasis_app_control * control )

Stop locally generated ringing on the channel associated with this control.

Parameters

control Control for res_stasis.

Returns: 0 for success.; -1 for error.

Definition at line 607 of file control.c.

References app_control_ring_stop(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_ring_stop().

 {
    stasis_app_send_command_async(control, app_control_ring_stop, NULL, NULL);
 
    return 0;
 }

◆ stasis_app_control_set_channel_var()

int stasis_app_control_set_channel_var	(	struct stasis_app_control *	control,
		const char *	variable,
		const char *	value
	)

Set a variable on the channel associated with this control to value.

Parameters

control	Control for `res_stasis`.
variable	The name of the variable
value	The value to set the variable to

Returns: 0 for success.; -1 for error.

Definition at line 711 of file control.c.

References app_control_set_channel_var(), ast_calloc, ast_strdup, free_chanvar(), chanvar::name, stasis_app_send_command_async(), chanvar::value, and var.

Referenced by ast_ari_channels_set_channel_var().

 {
    struct chanvar *var;
 
    var = ast_calloc(1, sizeof(*var));
    if (!var) {
       return -1;
    }
 
    var->name = ast_strdup(variable);
    if (!var->name) {
       free_chanvar(var);
       return -1;
    }
 
    /* It's kosher for value to be NULL. It means the variable is being unset */
    if (value) {
       var->value = ast_strdup(value);
       if (!var->value) {
          free_chanvar(var);
          return -1;
       }
    }
 
    stasis_app_send_command_async(control, app_control_set_channel_var, var, free_chanvar);
 
    return 0;
 }

◆ stasis_app_control_shutdown()

void stasis_app_control_shutdown ( void )

Let Stasis app internals shut down.

This is called when res_stasis is unloaded. It ensures that the Stasis app internals can free any resources they may have allocated during the time that res_stasis was loaded.

Definition at line 1680 of file control.c.

References ast_bridge_destroy(), ast_mutex_lock, ast_mutex_unlock, dial_bridge_lock, NULL, and shutting_down.

Referenced by unload_module().

 {
    ast_mutex_lock(&dial_bridge_lock);
    shutting_down = 1;
    if (dial_bridge) {
       ast_bridge_destroy(dial_bridge, 0);
       dial_bridge = NULL;
    }
    ast_mutex_unlock(&dial_bridge_lock);
 }

◆ stasis_app_control_silence_start()

void stasis_app_control_silence_start ( struct stasis_app_control * control )

Start playing silence to a channel.

Parameters

control Control for res_stasis.

Definition at line 832 of file control.c.

References app_control_silence_start(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_start_silence().

 {
    stasis_app_send_command_async(control, app_control_silence_start, NULL, NULL);
 }

◆ stasis_app_control_silence_stop()

void stasis_app_control_silence_stop ( struct stasis_app_control * control )

Stop playing silence to a channel.

Parameters

control Control for res_stasis.

Definition at line 855 of file control.c.

References app_control_silence_stop(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_stop_silence().

 {
    stasis_app_send_command_async(control, app_control_silence_stop, NULL, NULL);
 }

◆ stasis_app_control_unhold()

void stasis_app_control_unhold ( struct stasis_app_control * control )

Remove the channel associated with the control from hold.

Parameters

control Control for res_stasis.

Definition at line 761 of file control.c.

References app_control_unhold(), NULL, and stasis_app_send_command_async().

Referenced by ast_ari_channels_unhold().

 {
    stasis_app_send_command_async(control, app_control_unhold, NULL, NULL);
 }

◆ stasis_app_control_unmute()

int stasis_app_control_unmute	(	struct stasis_app_control *	control,
		unsigned int	direction,
		enum ast_frame_type	frametype
	)

Unmute the channel associated with this control.

Parameters

control	Control for `res_stasis`.
direction	The direction in which the audio should be unmuted.
frametype	The type of stream that should be unmuted.

Returns: 0 for success; -1 for error.

Definition at line 659 of file control.c.

References app_control_unmute(), ast_calloc, ast_free_ptr(), stasis_app_control_mute_data::direction, stasis_app_control_mute_data::frametype, and stasis_app_send_command_async().

Referenced by ast_ari_channels_unmute().

 {
    struct stasis_app_control_mute_data *mute_data;
 
    if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
       return -1;
    }
 
    mute_data->direction = direction;
    mute_data->frametype = frametype;
 
    stasis_app_send_command_async(control, app_control_unmute, mute_data, ast_free_ptr);
 
    return 0;
 }

◆ stasis_app_control_unregister_add_rule()

void stasis_app_control_unregister_add_rule	(	struct stasis_app_control *	control,
		struct stasis_app_control_rule *	rule
	)

UnRegister an add channel to bridge rule.

Parameters

control	Control object
rule	The rule to unregister

Definition at line 224 of file control.c.

References stasis_app_control::add_rules, and app_control_unregister_rule().

Referenced by record_file(), and recording_fail().

 {
    app_control_unregister_rule(control, &control->add_rules, rule);
 }

◆ stasis_app_control_unregister_remove_rule()

void stasis_app_control_unregister_remove_rule	(	struct stasis_app_control *	control,
		struct stasis_app_control_rule *	rule
	)

Unregisters a remove channel from bridge rule.

Parameters

control	Control object
rule	The rule to unregister

Definition at line 238 of file control.c.

References app_control_unregister_rule(), and stasis_app_control::remove_rules.

 {
    app_control_unregister_rule(control, &control->remove_rules, rule);
 }

◆ stasis_app_get_bridge()

struct ast_bridge* stasis_app_get_bridge ( struct stasis_app_control * control )

Gets the bridge currently associated with a control object.

Since: 12

Note: If the bridge returned by this function is to be held for any length of time, its refcount should be incremented until the caller is finished with it.

Parameters

control Control object for the channel to query.

Returns: Associated ast_bridge.; NULL if not associated with a bridge.

Definition at line 931 of file control.c.

References ao2_lock, ao2_unlock, stasis_app_control::bridge, and NULL.

Referenced by app_control_continue(), app_control_dtmf(), app_control_remove_channel_from_bridge(), ast_ari_bridges_remove_channel(), ast_ari_bridges_set_video_source(), control_swap_channel_in_bridge(), play_uri(), record_file(), and stasis_app_exec().

 {
    struct ast_bridge *ret;
 
    if (!control) {
       return NULL;
    }
 
    ao2_lock(control);
    ret = control->bridge;
    ao2_unlock(control);
 
    return ret;
 }

◆ stasis_app_send_command()

int stasis_app_send_command	(	struct stasis_app_control *	control,
		stasis_app_command_cb	command,
		void *	data,
		command_data_destructor_fn	data_destructor
	)

Invokes a command on a control's channel.

Since: 12 This function dispatches the command to be executed in the context of stasis_app_exec(), so this command will block waiting for the results of the command.

Parameters

control	Control object for the channel to send the command to.
command	Command function to execute.
data	Optional data to pass along with the control function.
data_destructor	Optional function which will be called on the data in either the event of command completion or failure to schedule or complete the command

Returns: zero on success.; error code otherwise.

Definition at line 898 of file control.c.

References app_send_command_on_condition(), and NULL.

Referenced by ast_ari_bridges_set_video_source(), and stasis_app_control_answer().

 {
    return app_send_command_on_condition(control, command_fn, data, data_destructor, NULL);
 }

◆ stasis_app_send_command_async()

int stasis_app_send_command_async	(	struct stasis_app_control *	control,
		stasis_app_command_cb	command,
		void *	data,
		command_data_destructor_fn	data_destructor
	)

Asynchronous version of stasis_app_send_command().

Since: 12 This function enqueues a command for execution, but returns immediately without waiting for the response.

Parameters

control	Control object for the channel to send the command to.
command	Command function to execute.
data	Optional data to pass along with the control function.
data_destructor	Optional function which will be called on the data in either the event of command completion or failure to schedule or complete the command

Returns: 0 on success.; Non-zero on error.

Definition at line 904 of file control.c.

References ao2_ref, stasis_app_command::data_destructor, exec_command(), and NULL.

 {
    struct stasis_app_command *command;
 
    if (control == NULL || control->is_done) {
       /* If exec_command fails, it calls the data_destructor. In order to
        * provide consistent behavior, we'll also call the data_destructor
        * on this error path. This way, callers never have to call the
        * data_destructor themselves.
        */
       if (data_destructor) {
          data_destructor(data);
       }
       return -1;
    }
 
    command = exec_command(control, command_fn, data, data_destructor);
    if (!command) {
       return -1;
    }
    ao2_ref(command, -1);
 
    return 0;
 }

Variable Documentation

◆ dial_bridge

struct ast_bridge* dial_bridge

static

Singleton dial bridge.

The dial bridge is a holding bridge used to hold all outbound dialed channels that are not in any "real" ARI-created bridge. The dial bridge is invisible, meaning that it does not show up in channel snapshots, AMI or ARI output, and no events get raised for it.

This is used to keep dialed channels confined to the bridging system and unify the threading model used for dialing outbound channels.

Definition at line 958 of file control.c.

◆ dial_bridge_lock

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

static

Definition at line 959 of file control.c.

Referenced by get_dial_bridge(), and stasis_app_control_shutdown().

◆ shutting_down

int shutting_down

static

Indicates if the Stasis app internals are being shut down.

Definition at line 49 of file control.c.

Referenced by get_dial_bridge(), and stasis_app_control_shutdown().

◆ timeout_datastore

struct ast_datastore_info timeout_datastore

Initial value:

= {
   .type = "ARI dial timeout",
}

Dial timeout datastore.

A datastore is used because a channel may change bridges during the course of a dial attempt. This may be because the channel changes from the dial bridge to a standard bridge, or it may move between standard bridges. In order to keep the dial timeout, we need to keep the timeout information local to the channel. That is what this datastore is for

Definition at line 1192 of file control.c.

Data Structures

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ app_command_can_exec_cb

Function Documentation

◆ add_to_dial_bridge()

◆ app_control_add_role()

◆ app_control_can_add_channel_to_bridge()

◆ app_control_can_remove_channel_from_bridge()

◆ app_control_check_rules()

◆ app_control_clear_roles()

◆ app_control_continue()

◆ app_control_dial()

◆ app_control_dtmf()

◆ app_control_hold()

◆ app_control_moh_start()

◆ app_control_moh_stop()

◆ app_control_move()

◆ app_control_mute()

◆ app_control_redirect()

◆ app_control_register_rule()

◆ app_control_remove_channel_from_bridge()

◆ app_control_ring()

◆ app_control_ring_stop()

◆ app_control_set_channel_var()

◆ app_control_silence_start()

◆ app_control_silence_stop()

◆ app_control_unhold()

◆ app_control_unmute()

◆ app_control_unregister_rule()

◆ app_send_command_on_condition()

◆ bridge_after_cb()

◆ bridge_after_cb_failed()

◆ bridge_channel_depart()

◆ bridge_timeout()

◆ control_add_channel_to_bridge()

◆ control_app()

◆ control_command_count()

◆ control_create()

◆ control_dial_args_alloc()

◆ control_dial_args_destroy()

◆ control_dispatch_all()

◆ control_dtor()

◆ control_flush_queue()

◆ control_is_done()

◆ control_mark_done()

◆ control_move_cleanup()

◆ control_next_app()

◆ control_next_app_args()

◆ control_next_app_args_size()

◆ control_prestart_dispatch_all()

◆ control_set_app()

◆ control_silence_stop_now()

◆ control_swap_channel_in_bridge()

◆ control_wait()

◆ depart_channel()

◆ dial_bridge_after_cb()

◆ dial_bridge_after_cb_failed()

◆ dtmf_in_bridge()

◆ dtmf_no_bridge()

◆ exec_command()

◆ exec_command_on_condition()

◆ free_chanvar()

◆ get_dial_bridge()

◆ hangup_channel()

◆ internal_bridge_after_cb()

◆ noop_cb()

◆ set_interval_hook()

◆ set_timeout()

◆ stasis_app_control_absorb_dtmf_in_bridge()

◆ stasis_app_control_add_channel_to_bridge()

◆ stasis_app_control_add_role()

◆ stasis_app_control_bridge_features_init()

◆ stasis_app_control_clear_roles()

◆ stasis_app_control_continue()

◆ stasis_app_control_dial()

◆ stasis_app_control_dtmf()