Stasis application control support. More...

#include "asterisk.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_app.h"
#include "asterisk/causes.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 <signal.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.

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

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.

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

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

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

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.

static void	control_dtor (void *obj)

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

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

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.

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

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

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.

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

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

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

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.

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

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.

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

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.

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.

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

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.

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

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.

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

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.

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.

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

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.

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

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

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

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.

int	stasis_app_control_is_failed (const struct stasis_app_control *control)
	Check if a control object is marked as "failed".

void	stasis_app_control_mark_failed (struct stasis_app_control *control)
	Set the failed flag on a control structure.

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)

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

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.

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.

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.

int	stasis_app_control_progress (struct stasis_app_control *control)
	Indicate progress to the channel associated with this control.

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

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

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

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.

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.

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

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

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

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.

int	stasis_app_control_set_channel_var_reportable (struct stasis_app_control control, const char variable, const char *value, int report_events)
	Set a variable on the channel associated with this control to value with option of including in events.

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

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

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

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

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.

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.

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.

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

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.

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

static void	timeout_datastore_data_destructor (void *data)
	Dial timeout datastore.

Variables
static struct ast_bridge *	dial_bridge
	Singleton dial bridge.

static ast_mutex_t	dial_bridge_lock = AST_MUTEX_INIT_VALUE

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

struct ast_datastore_info	timeout_datastore

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 273 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 1103 of file control.c.

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

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

◆ 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 323 of file control.c.

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

References ast_channel_add_bridge_role(), and stasis_app_command::data.

Referenced by stasis_app_control_add_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 253 of file control.c.

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

References stasis_app_control::add_rules, and app_control_check_rules().

Referenced by stasis_app_control_add_channel_to_bridge().

◆ 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 259 of file control.c.

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

References app_control_check_rules(), and stasis_app_control::remove_rules.

Referenced by stasis_app_control_remove_channel_from_bridge().

◆ 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 211 of file control.c.

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

References AST_LIST_TRAVERSE, and stasis_app_control_rule::next.

Referenced by app_control_can_add_channel_to_bridge(), and app_control_can_remove_channel_from_bridge().

◆ 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 345 of file control.c.

{
    ast_channel_clear_bridge_roles(chan);
 
    return 0;
}

References ast_channel_clear_bridge_roles().

Referenced by stasis_app_control_clear_roles().

◆ app_control_continue()

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

static

Definition at line 394 of file control.c.

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

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

◆ app_control_dial()

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

static

Definition at line 1701 of file control.c.

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

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

Referenced by stasis_app_control_dial().

◆ app_control_dtmf()

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

static

Definition at line 573 of file control.c.

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

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

◆ app_control_hold()

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

static

Definition at line 802 of file control.c.

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

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

Referenced by stasis_app_control_hold().

◆ 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 828 of file control.c.

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

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

Referenced by stasis_app_control_moh_start().

◆ 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 853 of file control.c.

{
    ast_moh_stop(chan);
    return 0;
}

References ast_moh_stop().

Referenced by stasis_app_control_moh_stop().

◆ app_control_move()

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

static

Definition at line 440 of file control.c.

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

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, stasis_app_control::next_app, and stasis_app_control::next_app_args.

Referenced by stasis_app_control_move().

◆ app_control_mute()

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

static

Definition at line 660 of file control.c.

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

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

◆ app_control_progress()

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

static

Definition at line 640 of file control.c.

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

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

Referenced by stasis_app_control_progress().

◆ app_control_redirect()

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

static

Definition at line 507 of file control.c.

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

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

Referenced by stasis_app_control_redirect().

◆ 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 170 of file control.c.

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

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

◆ 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 1467 of file control.c.

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

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

◆ app_control_ring()

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

static

Definition at line 610 of file control.c.

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

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

Referenced by stasis_app_control_ring().

◆ 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 625 of file control.c.

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

References ast_indicate(), and stasis_app_control::channel.

Referenced by stasis_app_control_ring_stop().

◆ 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 744 of file control.c.

{
    struct chanvar *var = data;
    /*
     * Save the current inhibit state then enable it.
     */
    int inhibited = ast_thread_inhibit_escalations_swap(1);
 
    if (ast_channel_set_ari_var_reportable(control->channel, var->name, var->report_events)) {
        return -1;
    }
 
    pbx_builtin_setvar_helper(control->channel, var->name, var->value);
    /*
     * Re-enable it if it was originally enabled.
     */
    if (inhibited > 0) {
        ast_thread_inhibit_escalations();
    }
 
    return 0;
}

References ast_channel_set_ari_var_reportable(), ast_thread_inhibit_escalations(), ast_thread_inhibit_escalations_swap(), stasis_app_control::channel, pbx_builtin_setvar_helper(), and var.

Referenced by stasis_app_control_set_channel_var_reportable().

◆ 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 865 of file control.c.

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

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

◆ 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 910 of file control.c.

{
    control_silence_stop_now(control);
    return 0;
}

References control_silence_stop_now().

Referenced by stasis_app_control_silence_stop().

◆ app_control_unhold()

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

static

Definition at line 815 of file control.c.

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

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

Referenced by stasis_app_control_unhold().

◆ app_control_unmute()

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

static

Definition at line 688 of file control.c.

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

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

◆ 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 179 of file control.c.

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

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

◆ 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 928 of file control.c.

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

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

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

◆ bridge_after_cb()

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

static

Definition at line 1225 of file control.c.

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

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

Referenced by control_swap_channel_in_bridge().

◆ bridge_after_cb_failed()

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

static

Definition at line 1232 of file control.c.

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

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

◆ bridge_channel_depart()

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

static

Definition at line 1147 of file control.c.

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

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

Referenced by dial_bridge_after_cb(), and internal_bridge_after_cb().

◆ 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 1288 of file control.c.

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

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

Referenced by set_interval_hook().

◆ 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 1451 of file control.c.

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

References control_swap_channel_in_bridge(), and NULL.

Referenced by stasis_app_control_add_channel_to_bridge().

◆ 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 1636 of file control.c.

{
    return control->app;
}

References stasis_app_control::app.

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

◆ 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

Returns: number of commands in the command que

Definition at line 358 of file control.c.

{
    return ao2_container_count(control->command_queue);
}

References ao2_container_count(), and stasis_app_control::command_queue.

Referenced by stasis_app_control_execute_until_exhausted().

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

Return values

NULL on error.

Definition at line 131 of file control.c.

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

References stasis_app_control::add_rules, ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_bump, ao2_container_alloc_list, ao2_ref, app, 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, stasis_app_control::next_app_args, NULL, stasis_app_control::remove_rules, and stasis_app_control::wait_cond.

Referenced by stasis_app_control_create(), and stasis_app_exec().

◆ control_dial_args_alloc()

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

static

Definition at line 1646 of file control.c.

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

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

Referenced by stasis_app_control_dial().

◆ control_dial_args_destroy()

static void control_dial_args_destroy ( void * data )

static

Definition at line 1663 of file control.c.

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

References args, and ast_free.

Referenced by stasis_app_control_dial().

◆ 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 1568 of file control.c.

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

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

◆ control_dtor()

static void control_dtor ( void * obj )

static

Definition at line 113 of file control.c.

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

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

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

Definition at line 1555 of file control.c.

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

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

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

Return values

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

Definition at line 363 of file control.c.

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

References stasis_app_control::is_done.

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

◆ control_mark_done()

void control_mark_done ( struct stasis_app_control * control )

Definition at line 369 of file control.c.

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

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

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

◆ 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 1775 of file control.c.

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

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

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

◆ 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 1770 of file control.c.

{
    return control->next_app;
}

References stasis_app_control::next_app.

Referenced by stasis_app_exec().

◆ 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 1783 of file control.c.

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

References AST_VECTOR_STEAL_ELEMENTS, and stasis_app_control::next_app_args.

Referenced by stasis_app_exec().

◆ 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 1788 of file control.c.

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

References AST_VECTOR_SIZE, and stasis_app_control::next_app_args.

Referenced by stasis_app_exec().

◆ 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
chan	The channel on which commands should be executed

Returns: The number of commands executed

Definition at line 1608 of file control.c.

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

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

Referenced by stasis_app_exec().

◆ 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 1764 of file control.c.

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

References ao2_bump, ao2_cleanup, app, and stasis_app_control::app.

Referenced by stasis_app_exec().

◆ 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 899 of file control.c.

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

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

◆ 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 1357 of file control.c.

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

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

◆ 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 1588 of file control.c.

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

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

◆ 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 1131 of file control.c.

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

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

◆ 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 1071 of file control.c.

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

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(), ast_bridge_channel::chan, stasis_app_control::channel, NULL, and stasis_app_send_command_async().

Referenced by add_to_dial_bridge(), and dial_bridge_after_cb_failed().

◆ 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 1087 of file control.c.

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

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

Referenced by add_to_dial_bridge().

◆ dtmf_in_bridge()

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

static

Definition at line 547 of file control.c.

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

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

◆ dtmf_no_bridge()

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

static

Definition at line 560 of file control.c.

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

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

◆ 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 316 of file control.c.

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

References stasis_app_command::data, stasis_app_command::data_destructor, exec_command_on_condition(), and NULL.

Referenced by stasis_app_send_command_async().

◆ 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 275 of file control.c.

{
    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);
 
    if (control->channel) {
        /* Queue a null frame so that if and when the channel is waited on,
           return immediately to process the new command */
        ast_queue_frame(control->channel, &ast_null_frame);
    }
 
    ao2_unlock(control->command_queue);
 
    return command;
}

References ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_cond_signal, ast_null_frame, ast_queue_frame(), stasis_app_control::channel, command_complete(), command_create(), stasis_app_control::command_queue, stasis_app_command::data, stasis_app_command::data_destructor, stasis_app_control::is_done, noop_cb(), NULL, OBJ_NOLOCK, stasis_app_command::retval, and stasis_app_control::wait_cond.

Referenced by app_send_command_on_condition(), and exec_command().

◆ free_chanvar()

static void free_chanvar ( void * data )

static

Definition at line 735 of file control.c.

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

References ast_free, and var.

Referenced by stasis_app_control_set_channel_var_reportable().

◆ 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 1036 of file control.c.

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

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

Referenced by add_to_dial_bridge().

◆ hangup_channel()

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

static

Definition at line 1265 of file control.c.

{
    /* Set cause code to No Answer to be consistent with other dial timeout operations */
    ast_channel_lock(chan);
    ast_channel_hangupcause_set(chan, AST_CAUSE_NO_ANSWER);
    ast_channel_unlock(chan);
    ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
    return 0;
}

References AST_CAUSE_NO_ANSWER, ast_channel_hangupcause_set(), ast_channel_lock, ast_channel_unlock, ast_softhangup(), and AST_SOFTHANGUP_EXPLICIT.

Referenced by bridge_timeout().

◆ 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 1170 of file control.c.

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

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

◆ noop_cb()

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

static

Definition at line 265 of file control.c.

{
    return 0;
}

Referenced by exec_command_on_condition().

◆ 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 1327 of file control.c.

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

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, NULL, and timeout_datastore.

Referenced by control_swap_channel_in_bridge(), and set_timeout().

◆ 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 1676 of file control.c.

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

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

Referenced by app_control_dial().

◆ 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 1537 of file control.c.

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

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

Referenced by ast_ari_bridges_add_channel().

◆ 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 1456 of file control.c.

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

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

◆ 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 331 of file control.c.

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

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

Referenced by ast_ari_bridges_add_channel().

◆ 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 1524 of file control.c.

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

References ast_bridge_features_new(), and stasis_app_control::bridge_features.

Referenced by ast_ari_bridges_add_channel().

◆ 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 353 of file control.c.

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

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

Referenced by ast_ari_bridges_add_channel().

◆ 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 415 of file control.c.

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

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

◆ 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 1739 of file control.c.

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

References app_control_dial(), args, control_dial_args_alloc(), control_dial_args_destroy(), control_dial_args::dialstring, stasis_app_send_command_async(), and control_dial_args::timeout.

Referenced by ast_ari_channels_dial().

◆ 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 591 of file control.c.

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

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

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

Return values

NULL	if control is `NULL`.

Definition at line 1503 of file control.c.

{
    return ast_channel_uniqueid(control->channel);
}

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

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

Return values

NULL	if channel isn't in cache.

Definition at line 922 of file control.c.

{
    return ast_channel_snapshot_get_latest(stasis_app_control_get_channel_id(control));
}

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

◆ 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 810 of file control.c.

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

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

Referenced by ast_ari_channels_hold().

◆ 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
inhibit_colp	Whether COLP frames should be generated (0) or not (1).

Definition at line 1549 of file control.c.

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

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

Referenced by ast_ari_bridges_add_channel().

◆ stasis_app_control_is_failed()

int stasis_app_control_is_failed ( const struct stasis_app_control * control )

Check if a control object is marked as "failed".

Parameters

control Control object to check

Definition at line 382 of file control.c.

{
    return control->failed;
}

References stasis_app_control::failed.

Referenced by stasis_app_exec().

◆ stasis_app_control_mark_failed()

void stasis_app_control_mark_failed ( struct stasis_app_control * control )

Set the failed flag on a control structure.

Parameters

control Control object to be updated

Definition at line 377 of file control.c.

{
    control->failed = 1;
}

References stasis_app_control::failed.

Referenced by outbound_session_handler_thread().

◆ 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 842 of file control.c.

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

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

◆ 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 860 of file control.c.

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

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

Referenced by ast_ari_channels_stop_moh().

◆ 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 477 of file control.c.

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

References stasis_app_control_move_data::app_args, app_control_move(), app_name(), 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().

◆ 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 672 of file control.c.

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

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

◆ 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 1543 of file control.c.

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

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

Referenced by ast_ari_bridges_add_channel().

◆ stasis_app_control_progress()

int stasis_app_control_progress ( struct stasis_app_control * control )

Indicate progress to the channel associated with this control.

Parameters

control Control for res_stasis.

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

Definition at line 648 of file control.c.

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

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

Referenced by ast_ari_channels_progress().

◆ 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 1509 of file control.c.

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

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

Referenced by playback_publish(), and recording_publish().

◆ 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 1518 of file control.c.

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

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_pause(), recording_stop(), recording_unpause(), and toggle_recording_mute().

◆ 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 526 of file control.c.

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

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

Referenced by ast_ari_channels_redirect().

◆ 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 225 of file control.c.

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

References stasis_app_control::add_rules, and app_control_register_rule().

Referenced by stasis_app_control_record().

◆ 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 239 of file control.c.

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

References app_control_register_rule(), and stasis_app_control::remove_rules.

◆ 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 1493 of file control.c.

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

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

◆ 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 618 of file control.c.

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

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

Referenced by ast_ari_channels_ring().

◆ 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 633 of file control.c.

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

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

Referenced by ast_ari_channels_ring_stop().

◆ 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

Note: The thread that actually does the set will have the inhibit_escalations flag set before the call to pbx_builtin_setvar_helper to prevent dangerous dialplan function execution from ARI. The flag will be reset to its original state when pbx_builtin_setvar_helper returns.

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

Definition at line 768 of file control.c.

{
    return stasis_app_control_set_channel_var_reportable(control, variable, value, 0);
}

References stasis_app_control_set_channel_var_reportable(), and value.

◆ stasis_app_control_set_channel_var_reportable()

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

Set a variable on the channel associated with this control to value with option of including in events.

Parameters

control	Control for `res_stasis`.
variable	The name of the variable
value	The value to set the variable to
report_events	Whether to include this variable in channel events.

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

Definition at line 773 of file control.c.

{
    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;
        }
    }
 
    var->report_events = report_events ? 1 : 0;
 
    return stasis_app_send_command(control, app_control_set_channel_var, var, free_chanvar);
}

References app_control_set_channel_var(), ast_calloc, ast_strdup, free_chanvar(), chanvar::report_events, stasis_app_send_command(), value, and var.

Referenced by ast_ari_channels_set_channel_var(), ast_ari_channels_set_channel_vars(), and stasis_app_control_set_channel_var().

◆ 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 1753 of file control.c.

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

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

Referenced by unload_module().

◆ 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 894 of file control.c.

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

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

Referenced by ast_ari_channels_start_silence().

◆ 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 917 of file control.c.

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

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

Referenced by ast_ari_channels_stop_silence().

◆ 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 823 of file control.c.

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

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

Referenced by ast_ari_channels_unhold().

◆ 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 700 of file control.c.

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

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

◆ 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 232 of file control.c.

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

References stasis_app_control::add_rules, and app_control_unregister_rule().

Referenced by record_file(), and recording_fail().

◆ 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 246 of file control.c.

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

References app_control_unregister_rule(), and stasis_app_control::remove_rules.

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

Return values

NULL	if not associated with a bridge.

Definition at line 993 of file control.c.

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

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

◆ 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 960 of file control.c.

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

References app_send_command_on_condition(), stasis_app_command::data, stasis_app_command::data_destructor, and NULL.

Referenced by ast_ari_bridges_set_video_source(), stasis_app_control_answer(), and stasis_app_control_set_channel_var_reportable().

◆ 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 966 of file control.c.

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

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

◆ timeout_datastore_data_destructor()

static void timeout_datastore_data_destructor ( void * data )

static

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 1255 of file control.c.

{
    ast_free(data);
}

References ast_free.

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 1020 of file control.c.

Referenced by get_dial_bridge(), and stasis_app_control_shutdown().

◆ dial_bridge_lock

ast_mutex_t dial_bridge_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 1021 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 52 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",
    .destroy = timeout_datastore_data_destructor,
}

Definition at line 1260 of file control.c.

                                              {
    .type = "ARI dial timeout",
    .destroy = timeout_datastore_data_destructor,
};

Referenced by bridge_timeout(), set_interval_hook(), and set_timeout().

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

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