control.c File Reference

Stasis application control support. More...

#include "asterisk.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_app.h"
#include "command.h"
#include "control.h"
#include "app.h"
#include "asterisk/dial.h"
#include "asterisk/bridge.h"
#include "asterisk/bridge_after.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/bridge_features.h"
#include "asterisk/frame.h"
#include "asterisk/pbx.h"
#include "asterisk/musiconhold.h"
#include "asterisk/app.h"
#include <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. More...
static int	app_control_add_role (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_can_add_channel_to_bridge (struct stasis_app_control *control)
static int	app_control_can_remove_channel_from_bridge (struct stasis_app_control *control)
static enum stasis_app_control_channel_result	app_control_check_rules (const struct stasis_app_control *control, struct app_control_rules *list)
static int	app_control_clear_roles (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_continue (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_dial (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_dtmf (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_hold (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_moh_start (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_moh_stop (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_move (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_mute (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_redirect (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static void	app_control_register_rule (struct stasis_app_control *control, struct app_control_rules *list, struct stasis_app_control_rule *obj)
static int	app_control_remove_channel_from_bridge (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_ring (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_ring_stop (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_set_channel_var (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_silence_start (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_silence_stop (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_unhold (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	app_control_unmute (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static void	app_control_unregister_rule (struct stasis_app_control *control, struct app_control_rules *list, struct stasis_app_control_rule *obj)
static int	app_send_command_on_condition (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor, app_command_can_exec_cb can_exec_fn)
static void	bridge_after_cb (struct ast_channel *chan, void *data)
static void	bridge_after_cb_failed (enum ast_bridge_after_cb_reason reason, void *data)
static int	bridge_channel_depart (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static int	bridge_timeout (struct ast_bridge_channel *bridge_channel, void *ignore)
	Dial timeout. More...
int	control_add_channel_to_bridge (struct stasis_app_control *control, struct ast_channel *chan, void *data)
	Command callback for adding a channel to a bridge. More...
struct stasis_app *	control_app (struct stasis_app_control *control)
	Returns the pointer (non-reffed) to the app associated with this control. More...
int	control_command_count (struct stasis_app_control *control)
	Returns the count of items in a control's command queue. More...
struct stasis_app_control *	control_create (struct ast_channel *channel, struct stasis_app *app)
	Create a control object. More...
static struct control_dial_args *	control_dial_args_alloc (const char *dialstring, unsigned int timeout)
static void	control_dial_args_destroy (void *data)
int	control_dispatch_all (struct stasis_app_control *control, struct ast_channel *chan)
	Dispatch all commands enqueued to this control. More...
static void	control_dtor (void *obj)
void	control_flush_queue (struct stasis_app_control *control)
	Flush the control command queue. More...
int	control_is_done (struct stasis_app_control *control)
	Returns true if control_continue() has been called on this control. More...
void	control_mark_done (struct stasis_app_control *control)
void	control_move_cleanup (struct stasis_app_control *control)
	Free any memory that was allocated for switching applications via /channels/{channelId}/move. More...
char *	control_next_app (struct stasis_app_control *control)
	Returns the name of the application we are moving to. More...
char **	control_next_app_args (struct stasis_app_control *control)
	Returns the list of arguments to pass to the application we are moving to. More...
int	control_next_app_args_size (struct stasis_app_control *control)
	Returns the number of arguments to be passed to the application we are moving to. More...
int	control_prestart_dispatch_all (struct stasis_app_control *control, struct ast_channel *chan)
	Dispatch all queued prestart commands. More...
void	control_set_app (struct stasis_app_control *control, struct stasis_app *app)
	Set the application the control object belongs to. More...
void	control_silence_stop_now (struct stasis_app_control *control)
	Stop playing silence to a channel right now. More...
int	control_swap_channel_in_bridge (struct stasis_app_control *control, struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap)
	Command for swapping a channel in a bridge. More...
void	control_wait (struct stasis_app_control *control)
	Blocks until control's command queue has a command available. More...
static int	depart_channel (struct stasis_app_control *control, struct ast_channel *chan)
	Depart a channel from a bridge, and potentially add it back to the dial bridge. More...
static void	dial_bridge_after_cb (struct ast_channel *chan, void *data)
	after bridge callback for the dial bridge More...
static void	dial_bridge_after_cb_failed (enum ast_bridge_after_cb_reason reason, void *data)
static void	dtmf_in_bridge (struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
static void	dtmf_no_bridge (struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
static struct stasis_app_command *	exec_command (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
static struct stasis_app_command *	exec_command_on_condition (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor, app_command_can_exec_cb can_exec_fn)
static void	free_chanvar (void *data)
static struct ast_bridge *	get_dial_bridge (void)
	Retrieve a reference to the dial bridge. More...
static int	hangup_channel (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static void	internal_bridge_after_cb (struct ast_channel *chan, void *data, enum ast_bridge_after_cb_reason reason)
static int	noop_cb (struct stasis_app_control *control, struct ast_channel *chan, void *data)
static void	set_interval_hook (struct ast_channel *chan)
	Set a dial timeout interval hook on the channel. More...
static int	set_timeout (struct ast_channel *chan, unsigned int timeout)
	Set dial timeout on a channel to be dialed. More...
void	stasis_app_control_absorb_dtmf_in_bridge (struct stasis_app_control *control, int absorb)
	Set whether DTMF from the channel is absorbed instead of passing through to the bridge. More...
int	stasis_app_control_add_channel_to_bridge (struct stasis_app_control *control, struct ast_bridge *bridge)
	Add a channel to the bridge. More...
int	stasis_app_control_add_role (struct stasis_app_control *control, const char *role)
	Apply a bridge role to a channel controlled by a stasis app control. More...
int	stasis_app_control_bridge_features_init (struct stasis_app_control *control)
	Initialize bridge features into a channel control. More...
void	stasis_app_control_clear_roles (struct stasis_app_control *control)
	Clear bridge roles currently applied to a channel controlled by a stasis app control. More...
int	stasis_app_control_continue (struct stasis_app_control *control, const char *context, const char *extension, int priority)
	Exit res_stasis and continue execution in the dialplan. More...
int	stasis_app_control_dial (struct stasis_app_control *control, const char *dialstring, unsigned int timeout)
	Dial a channel. More...
int	stasis_app_control_dtmf (struct stasis_app_control *control, const char *dtmf, int before, int between, unsigned int duration, int after)
	Send DTMF to the channel associated with this control. More...
const char *	stasis_app_control_get_channel_id (const struct stasis_app_control *control)
	Returns the uniqueid of the channel associated with this control. More...
struct ast_channel_snapshot *	stasis_app_control_get_snapshot (const struct stasis_app_control *control)
	Returns the most recent snapshot for the associated channel. More...
void	stasis_app_control_hold (struct stasis_app_control *control)
	Place the channel associated with the control on hold. More...
void	stasis_app_control_inhibit_colp_in_bridge (struct stasis_app_control *control, int inhibit_colp)
	Set whether COLP frames should be generated when joining the bridge. More...
void	stasis_app_control_moh_start (struct stasis_app_control *control, const char *moh_class)
	Play music on hold to a channel (does not affect hold status) More...
void	stasis_app_control_moh_stop (struct stasis_app_control *control)
	Stop playing music on hold to a channel (does not affect hold status) More...
int	stasis_app_control_move (struct stasis_app_control *control, const char *app_name, const char *app_args)
	Exit res_stasis and move to another Stasis application. More...
int	stasis_app_control_mute (struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
	Mute the channel associated with this control. More...
void	stasis_app_control_mute_in_bridge (struct stasis_app_control *control, int mute)
	Set whether audio from the channel is muted instead of passing through to the bridge. More...
void	stasis_app_control_publish (struct stasis_app_control *control, struct stasis_message *message)
	Publish a message to the control's channel's topic. More...
int	stasis_app_control_queue_control (struct stasis_app_control *control, enum ast_control_frame_type frame_type)
	Queue a control frame without payload. More...
int	stasis_app_control_redirect (struct stasis_app_control *control, const char *endpoint)
	Redirect a channel in res_stasis to a particular endpoint. More...
void	stasis_app_control_register_add_rule (struct stasis_app_control *control, struct stasis_app_control_rule *rule)
	Registers an add channel to bridge rule. More...
void	stasis_app_control_register_remove_rule (struct stasis_app_control *control, struct stasis_app_control_rule *rule)
	Registers a remove channel from bridge rule. More...
int	stasis_app_control_remove_channel_from_bridge (struct stasis_app_control *control, struct ast_bridge *bridge)
	Remove a channel from the bridge. More...
int	stasis_app_control_ring (struct stasis_app_control *control)
	Indicate ringing to the channel associated with this control. More...
int	stasis_app_control_ring_stop (struct stasis_app_control *control)
	Stop locally generated ringing on the channel associated with this control. More...
int	stasis_app_control_set_channel_var (struct stasis_app_control *control, const char *variable, const char *value)
	Set a variable on the channel associated with this control to value. More...
void	stasis_app_control_shutdown (void)
	Let Stasis app internals shut down. More...
void	stasis_app_control_silence_start (struct stasis_app_control *control)
	Start playing silence to a channel. More...
void	stasis_app_control_silence_stop (struct stasis_app_control *control)
	Stop playing silence to a channel. More...
void	stasis_app_control_unhold (struct stasis_app_control *control)
	Remove the channel associated with the control from hold. More...
int	stasis_app_control_unmute (struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
	Unmute the channel associated with this control. More...
void	stasis_app_control_unregister_add_rule (struct stasis_app_control *control, struct stasis_app_control_rule *rule)
	UnRegister an add channel to bridge rule. More...
void	stasis_app_control_unregister_remove_rule (struct stasis_app_control *control, struct stasis_app_control_rule *rule)
	Unregisters a remove channel from bridge rule. More...
struct ast_bridge *	stasis_app_get_bridge (struct stasis_app_control *control)
	Gets the bridge currently associated with a control object. More...
int	stasis_app_send_command (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
	Invokes a command on a control's channel. More...
int	stasis_app_send_command_async (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
	Asynchronous version of stasis_app_send_command(). More...

Variables
static struct ast_bridge *	dial_bridge
	Singleton dial bridge. More...
static ast_mutex_t	dial_bridge_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
static int	shutting_down
	Indicates if the Stasis app internals are being shut down. More...
struct ast_datastore_info	timeout_datastore
	Dial timeout datastore. More...

Detailed Description

Stasis application control support.

Author

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

Definition in file control.c.

Typedef Documentation

app_command_can_exec_cb

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

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

Definition at line 267 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 1050 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 317 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 247 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 253 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 205 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 339 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 377 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 1637 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 556 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 749 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 775 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 800 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 423 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 628 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_redirect()

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

static

Definition at line 490 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 164 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 1403 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 593 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 608 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 710 of file control.c.

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

References stasis_app_control::channel, pbx_builtin_setvar_helper(), and var.

Referenced by stasis_app_control_set_channel_var().

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 812 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 857 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 762 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 656 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 173 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 875 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 1172 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 1179 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 1094 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 1224 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 1387 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 1572 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 352 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 125 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 1582 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 1599 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 1504 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 107 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 1491 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 357 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 363 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 1711 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 1706 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 1719 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 1724 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 1544 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 1700 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 846 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 1293 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 1524 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 1078 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 1018 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 1034 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 530 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 543 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 310 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 269 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, 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 701 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().

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

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

References 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 1117 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 259 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 1263 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 1612 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 1473 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 1392 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 325 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 1460 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 347 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 398 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(), voicemailpwcheck::context, 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().

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 1675 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 574 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 1439 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 869 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 757 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 1485 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_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 789 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 807 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 460 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 640 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 1479 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_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 1445 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 1454 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 509 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 219 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 233 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 1429 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 601 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 616 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

Returns

0 for success.

-1 for error.

Definition at line 720 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;
        }
    }
 
    stasis_app_send_command_async(control, app_control_set_channel_var, var, free_chanvar);
 
    return 0;
}

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

Referenced by ast_ari_channels_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 1689 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 841 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 864 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 770 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 668 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 226 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 240 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 940 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 907 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(), and stasis_app_control_answer().

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

Referenced by bridge_timeout(), dial_bridge_after_cb(), internal_bridge_after_cb(), stasis_app_control_add_role(), stasis_app_control_clear_roles(), stasis_app_control_continue(), stasis_app_control_dial(), stasis_app_control_dtmf(), stasis_app_control_hold(), stasis_app_control_moh_start(), stasis_app_control_moh_stop(), stasis_app_control_move(), stasis_app_control_mute(), stasis_app_control_play_uri(), stasis_app_control_record(), stasis_app_control_redirect(), stasis_app_control_ring(), stasis_app_control_ring_stop(), stasis_app_control_set_channel_var(), stasis_app_control_silence_start(), stasis_app_control_silence_stop(), stasis_app_control_unhold(), and stasis_app_control_unmute().

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

Referenced by get_dial_bridge(), and stasis_app_control_shutdown().

dial_bridge_lock

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

static

Definition at line 968 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 51 of file control.c.

Referenced by get_dial_bridge(), and stasis_app_control_shutdown().

timeout_datastore

struct ast_datastore_info timeout_datastore

Initial value:

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

Dial timeout datastore.

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

Definition at line 1201 of file control.c.

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