Asterisk - The Open Source Telephony Project GIT-master-d5a0626
Data Structures | Typedefs | Functions | Variables
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_appcontrol_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_controlcontrol_create (struct ast_channel *channel, struct stasis_app *app)
 Create a control object. More...
 
static struct control_dial_argscontrol_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_commandexec_command (struct stasis_app_control *control, stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
 
static struct stasis_app_commandexec_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_bridgeget_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_snapshotstasis_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_bridgestasis_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_bridgedial_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
controlThe Stasis control structure
chanThe channel to add to the bridge
Return values
-1Failed
0Success

Definition at line 1050 of file control.c.

1051{
1052 struct ast_bridge *bridge;
1053
1054 bridge = get_dial_bridge();
1055 if (!bridge) {
1056 return -1;
1057 }
1058
1059 control->bridge = bridge;
1062 control->bridge = NULL;
1063 ao2_ref(bridge, -1);
1064 return -1;
1065 }
1066
1067 ao2_ref(bridge, -1);
1068
1069 return 0;
1070}
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
int ast_bridge_impart(struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap, struct ast_bridge_features *features, enum ast_bridge_impart_flags flags) attribute_warn_unused_result
Impart a channel to a bridge (non-blocking)
Definition: bridge.c:1878
@ AST_BRIDGE_IMPART_CHAN_DEPARTABLE
Definition: bridge.h:588
int ast_bridge_set_after_callback(struct ast_channel *chan, ast_bridge_after_cb callback, ast_bridge_after_cb_failed failed, void *data)
Setup an after bridge callback for when the channel leaves the bridging system.
Definition: bridge_after.c:251
static void dial_bridge_after_cb(struct ast_channel *chan, void *data)
after bridge callback for the dial bridge
Definition: control.c:1018
static struct ast_bridge * get_dial_bridge(void)
Retrieve a reference to the dial bridge.
Definition: control.c:983
static void dial_bridge_after_cb_failed(enum ast_bridge_after_cb_reason reason, void *data)
Definition: control.c:1034
#define NULL
Definition: resample.c:96
Structure that contains information about a bridge.
Definition: bridge.h:349
struct ast_bridge * bridge
Definition: control.c:66

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.

319{
320 char *role = data;
321
322 return ast_channel_add_bridge_role(chan, role);
323}
int ast_channel_add_bridge_role(struct ast_channel *chan, const char *role_name)
Adds a bridge role to a channel.
Definition: bridge_roles.c:313

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.

249{
250 return app_control_check_rules(control, &control->add_rules);
251}
static enum stasis_app_control_channel_result app_control_check_rules(const struct stasis_app_control *control, struct app_control_rules *list)
Definition: control.c:205
struct app_control_rules add_rules
Definition: control.c:78

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.

255{
256 return app_control_check_rules(control, &control->remove_rules);
257}
struct app_control_rules remove_rules
Definition: control.c:82

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.

208{
209 int res = 0;
211 AST_LIST_TRAVERSE(list, rule, next) {
212 if ((res = rule->check_rule(control))) {
213 return res;
214 }
215 }
216 return res;
217}
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
Rule to check to see if an operation is allowed.
Definition: stasis_app.h:345
struct stasis_app_control_rule * next
Definition: stasis_app.h:355

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.

341{
343
344 return 0;
345}
void ast_channel_clear_bridge_roles(struct ast_channel *chan)
Removes all bridge roles currently on a channel.
Definition: bridge_roles.c:356

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.

379{
380 struct stasis_app_control_continue_data *continue_data = data;
381
382 ast_assert(control->channel != NULL);
383
384 /* If we're in a Stasis bridge, depart it before going back to the
385 * dialplan */
386 if (stasis_app_get_bridge(control)) {
387 ast_bridge_depart(control->channel);
388 }
389
390 /* Called from stasis_app_exec thread; no lock needed */
391 ast_explicit_goto(control->channel, continue_data->context, continue_data->extension, continue_data->priority);
392
393 control_mark_done(control);
394
395 return 0;
396}
int ast_bridge_depart(struct ast_channel *chan)
Depart a channel from a bridge.
Definition: bridge.c:1906
struct ast_bridge * stasis_app_get_bridge(struct stasis_app_control *control)
Gets the bridge currently associated with a control object.
Definition: control.c:940
void control_mark_done(struct stasis_app_control *control)
Definition: control.c:363
int ast_explicit_goto(struct ast_channel *chan, const char *context, const char *exten, int priority)
Definition: pbx.c:6945
char extension[AST_MAX_EXTENSION]
Definition: control.c:373
char context[AST_MAX_CONTEXT]
Definition: control.c:372
struct ast_channel * channel
Definition: control.c:62
#define ast_assert(a)
Definition: utils.h:739

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.

1639{
1640 struct control_dial_args *args = data;
1641 int bridged;
1642
1643 ast_channel_lock(chan);
1644 bridged = ast_channel_is_bridged(chan);
1645 ast_channel_unlock(chan);
1646
1647 if (!bridged && add_to_dial_bridge(control, chan)) {
1648 return -1;
1649 }
1650
1651 if (args->timeout && set_timeout(chan, args->timeout)) {
1652 return -1;
1653 }
1654
1655 if (ast_call(chan, args->dialstring, 0)) {
1656 /* If call fails normally this channel would then just be normally hung up and destroyed.
1657 * In this case though the channel is being handled by the ARI control thread and dial
1658 * bridge which needs to be notified that the channel should be hung up. To do this we
1659 * queue a soft hangup which will cause each to wake up, see that the channel has been
1660 * hung up, and then destroy it.
1661 */
1662 int hangup_flag;
1664 ast_channel_lock(chan);
1665 ast_softhangup_nolock(chan, hangup_flag);
1666 ast_channel_unlock(chan);
1667 return -1;
1668 }
1669
1670 ast_channel_publish_dial(NULL, chan, args->dialstring, NULL);
1671
1672 return 0;
1673}
int ast_bridge_setup_after_goto(struct ast_channel *chan)
Setup any after bridge goto location to begin execution.
Definition: bridge_after.c:435
int ast_call(struct ast_channel *chan, const char *addr, int timeout)
Make a call.
Definition: channel.c:6480
#define ast_channel_lock(chan)
Definition: channel.h:2968
int ast_channel_is_bridged(const struct ast_channel *chan)
Determine if a channel is in a bridge.
Definition: channel.c:10567
@ AST_SOFTHANGUP_ASYNCGOTO
Definition: channel.h:1146
@ AST_SOFTHANGUP_DEV
Definition: channel.h:1141
int ast_softhangup_nolock(struct ast_channel *chan, int cause)
Softly hangup up a channel (no channel lock)
Definition: channel.c:2477
#define ast_channel_unlock(chan)
Definition: channel.h:2969
static int set_timeout(struct ast_channel *chan, unsigned int timeout)
Set dial timeout on a channel to be dialed.
Definition: control.c:1612
static int add_to_dial_bridge(struct stasis_app_control *control, struct ast_channel *chan)
Add a channel to the singleton dial bridge.
Definition: control.c:1050
void ast_channel_publish_dial(struct ast_channel *caller, struct ast_channel *peer, const char *dialstring, const char *dialstatus)
Publish in the ast_channel_topic or ast_channel_topic_all topics a stasis message for the channels in...
const char * args

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.

558{
559 struct stasis_app_control_dtmf_data *dtmf_data = data;
560
561 if (ast_channel_state(chan) != AST_STATE_UP) {
563 }
564
565 if (stasis_app_get_bridge(control)) {
566 dtmf_in_bridge(chan, dtmf_data);
567 } else {
568 dtmf_no_bridge(chan, dtmf_data);
569 }
570
571 return 0;
572}
int ast_indicate(struct ast_channel *chan, int condition)
Indicates condition of channel.
Definition: channel.c:4296
ast_channel_state
ast_channel states
Definition: channelstate.h:35
@ AST_STATE_UP
Definition: channelstate.h:42
static void dtmf_no_bridge(struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
Definition: control.c:543
static void dtmf_in_bridge(struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
Definition: control.c:530
@ AST_CONTROL_PROGRESS

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.

751{
753
754 return 0;
755}
@ AST_CONTROL_HOLD

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.

777{
778 char *moh_class = data;
779
780 if (ast_channel_state(chan) != AST_STATE_UP) {
782 }
783
784 ast_moh_start(chan, moh_class, NULL);
785
786 return 0;
787}
int ast_moh_start(struct ast_channel *chan, const char *mclass, const char *interpclass)
Turn on music on hold on a given channel.
Definition: channel.c:7788

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.

802{
803 ast_moh_stop(chan);
804 return 0;
805}
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition: channel.c:7798

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.

425{
426 struct stasis_app_control_move_data *move_data = data;
427
428 control->next_app = ast_strdup(move_data->app_name);
429 if (!control->next_app) {
430 ast_log(LOG_ERROR, "Allocation failed for next app\n");
431 return -1;
432 }
433
434 if (move_data->app_args) {
435 char *token;
436
437 while ((token = strtok_r(move_data->app_args, ",", &move_data->app_args))) {
438 int res;
439 char *arg;
440
441 if (!(arg = ast_strdup(token))) {
442 ast_log(LOG_ERROR, "Allocation failed for next app arg\n");
443 control_move_cleanup(control);
444 return -1;
445 }
446
447 res = AST_VECTOR_APPEND(&control->next_app_args, arg);
448 if (res) {
449 ast_log(LOG_ERROR, "Failed to append arg to next app args\n");
450 ast_free(arg);
451 control_move_cleanup(control);
452 return -1;
453 }
454 }
455 }
456
457 return 0;
458}
#define ast_free(a)
Definition: astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_log
Definition: astobj2.c:42
void control_move_cleanup(struct stasis_app_control *control)
Free any memory that was allocated for switching applications via /channels/{channelId}/move.
Definition: control.c:1711
#define LOG_ERROR
struct stasis_app_control::@489 next_app_args
char * next_app
Definition: control.c:96
#define AST_VECTOR_APPEND(vec, elem)
Append an element to a vector, growing the vector if needed.
Definition: vector.h:256

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.

630{
631 struct stasis_app_control_mute_data *mute_data = data;
632
633 ast_channel_lock(chan);
634 ast_channel_suppress(control->channel, mute_data->direction, mute_data->frametype);
635 ast_channel_unlock(chan);
636
637 return 0;
638}
int ast_channel_suppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
Suppress passing of a frame type on a channel.
Definition: channel.c:10799
enum ast_frame_type frametype
Definition: control.c:624

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.

492{
493 char *endpoint = data;
494 int res;
495
496 ast_assert(control->channel != NULL);
497 ast_assert(endpoint != NULL);
498
499 res = ast_transfer(control->channel, endpoint);
500 if (!res) {
501 ast_log(LOG_NOTICE, "Unsupported transfer requested on channel '%s'\n",
502 ast_channel_name(control->channel));
503 return 0;
504 }
505
506 return 0;
507}
const char * ast_channel_name(const struct ast_channel *chan)
int ast_transfer(struct ast_channel *chan, char *dest)
Transfer a channel (if supported).
Definition: channel.c:6504
#define LOG_NOTICE

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.

167{
168 ao2_lock(control->command_queue);
169 AST_LIST_INSERT_TAIL(list, obj, next);
170 ao2_unlock(control->command_queue);
171}
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731
struct ao2_container * command_queue
Definition: control.c:56

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.

1406{
1407 struct ast_bridge *bridge = data;
1408
1409 if (!control) {
1410 return -1;
1411 }
1412
1413 /* We should only depart from our own bridge */
1414 ast_debug(3, "%s: Departing bridge %s\n",
1416 bridge->uniqueid);
1417
1418 if (bridge != stasis_app_get_bridge(control)) {
1419 ast_log(LOG_WARNING, "%s: Not in bridge %s; not removing\n",
1421 bridge->uniqueid);
1422 return -1;
1423 }
1424
1425 depart_channel(control, chan);
1426 return 0;
1427}
const char * stasis_app_control_get_channel_id(const struct stasis_app_control *control)
Returns the uniqueid of the channel associated with this control.
Definition: control.c:1439
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.
Definition: control.c:1078
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_WARNING
const ast_string_field uniqueid
Definition: bridge.h:401

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.

595{
597
598 return 0;
599}
@ AST_CONTROL_RINGING

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.

610{
611 ast_indicate(control->channel, -1);
612
613 return 0;
614}

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.

712{
713 struct chanvar *var = data;
714
715 pbx_builtin_setvar_helper(control->channel, var->name, var->value);
716
717 return 0;
718}
#define var
Definition: ast_expr2f.c:605
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
structure for queuing ARI channel variable setting
Definition: control.c:694

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.

814{
815 if (ast_channel_state(chan) != AST_STATE_UP) {
817 }
818
819 if (control->silgen) {
820 /* We have a silence generator, but it may have been implicitly
821 * disabled by media actions (music on hold, playing media,
822 * etc.) Just stop it and restart a new one.
823 */
825 control->channel, control->silgen);
826 }
827
828 ast_debug(3, "%s: Starting silence generator\n",
831
832 if (!control->silgen) {
834 "%s: Failed to start silence generator.\n",
836 }
837
838 return 0;
839}
struct ast_silence_generator * ast_channel_start_silence_generator(struct ast_channel *chan)
Starts a silence generator on the given channel.
Definition: channel.c:8186
void ast_channel_stop_silence_generator(struct ast_channel *chan, struct ast_silence_generator *state)
Stops a previously-started silence generator on the given channel.
Definition: channel.c:8232
struct ast_silence_generator * silgen
Definition: control.c:86

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.

859{
861 return 0;
862}
void control_silence_stop_now(struct stasis_app_control *control)
Stop playing silence to a channel right now.
Definition: control.c:846

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.

764{
766
767 return 0;
768}
@ AST_CONTROL_UNHOLD

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.

658{
659 struct stasis_app_control_mute_data *mute_data = data;
660
661 ast_channel_lock(chan);
662 ast_channel_unsuppress(control->channel, mute_data->direction, mute_data->frametype);
663 ast_channel_unlock(chan);
664
665 return 0;
666}
int ast_channel_unsuppress(struct ast_channel *chan, unsigned int direction, enum ast_frame_type frametype)
Stop suppressing of a frame type on a channel.
Definition: channel.c:10861

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

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

879{
880 int ret;
881 struct stasis_app_command *command;
882
883 if (control == NULL || control->is_done) {
884 /* If exec_command_on_condition fails, it calls the data_destructor.
885 * In order to provide consistent behavior, we'll also call the data_destructor
886 * on this error path. This way, callers never have to call the
887 * data_destructor themselves.
888 */
889 if (data_destructor) {
891 }
892 return -1;
893 }
894
896 control, command_fn, data, data_destructor, can_exec_fn);
897 if (!command) {
898 return -1;
899 }
900
901 ret = command_join(command);
902 ao2_ref(command, -1);
903
904 return ret;
905}
int command_join(struct stasis_app_command *command)
Definition: command.c:86
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)
Definition: control.c:269
command_data_destructor_fn data_destructor
Definition: command.c:38
unsigned int is_done
Definition: control.c:104

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.

1173{
1174 struct stasis_app_control *control = data;
1175
1177}
@ AST_BRIDGE_AFTER_CB_REASON_DEPART
Definition: bridge_after.h:45
static void internal_bridge_after_cb(struct ast_channel *chan, void *data, enum ast_bridge_after_cb_reason reason)
Definition: control.c:1117

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.

1181{
1182 struct stasis_app_control *control = data;
1183
1184 internal_bridge_after_cb(control->channel, data, reason);
1185
1186 ast_debug(3, " reason: %s\n",
1188}
const char * ast_bridge_after_cb_reason_string(enum ast_bridge_after_cb_reason reason)
Get a string representation of an after bridge callback reason.
Definition: bridge_after.c:288

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.

1096{
1097 struct ast_bridge_channel *bridge_channel;
1098
1100 bridge_channel = ast_channel_internal_bridge_channel(chan);
1102
1103 if (bridge_channel != data) {
1104 ast_debug(3, "%s: Channel is no longer in departable state\n",
1106 return -1;
1107 }
1108
1109 ast_debug(3, "%s: Channel departing bridge\n",
1111
1112 depart_channel(control, chan);
1113
1114 return 0;
1115}
const char * ast_channel_uniqueid(const struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_internal_bridge_channel(const struct ast_channel *chan)
Structure that contains information regarding a channel in a bridge.
struct ast_channel * chan

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_channelBridge channel on which interval hook has been called
ignoreIgnored
Returns
-1 (i.e. remove the interval hook)

Definition at line 1224 of file control.c.

1225{
1226 struct ast_datastore *datastore;
1227 RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
1228
1229 control = stasis_app_control_find_by_channel(bridge_channel->chan);
1230
1231 ast_channel_lock(bridge_channel->chan);
1232 if (ast_channel_state(bridge_channel->chan) != AST_STATE_UP) {
1233 /* Don't bother removing the datastore because it will happen when the channel is hung up */
1234 ast_channel_unlock(bridge_channel->chan);
1236 return -1;
1237 }
1238
1239 datastore = ast_channel_datastore_find(bridge_channel->chan, &timeout_datastore, NULL);
1240 if (!datastore) {
1241 ast_channel_unlock(bridge_channel->chan);
1242 return -1;
1243 }
1244 ast_channel_datastore_remove(bridge_channel->chan, datastore);
1245 ast_channel_unlock(bridge_channel->chan);
1246 ast_datastore_free(datastore);
1247
1248 return -1;
1249}
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
Remove a datastore from a channel.
Definition: channel.c:2413
struct ast_datastore * ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
Find a datastore on a channel.
Definition: channel.c:2418
struct ast_datastore_info timeout_datastore
Dial timeout datastore.
Definition: control.c:1201
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().
Definition: control.c:913
static int hangup_channel(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:1205
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition: datastore.c:68
struct stasis_app_control * stasis_app_control_find_by_channel(const struct ast_channel *chan)
Returns the handler for the given channel.
Definition: res_stasis.c:338
Structure for a data store object.
Definition: datastore.h:64
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941

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
controlThe control for chan
chanThe channel on which commands should be executed
dataBridge to be passed to the callback

Definition at line 1387 of file control.c.

1388{
1389 return control_swap_channel_in_bridge(control, data, chan, NULL);
1390}
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.
Definition: control.c:1293

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
controlControl to query.
Returns
A pointer to the associated stasis_app

Definition at line 1572 of file control.c.

1573{
1574 return control->app;
1575}
struct stasis_app * app
Definition: control.c:92

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
controlControl to count commands on
Returns
number of commands in the command que

Definition at line 352 of file control.c.

353{
354 return ao2_container_count(control->command_queue);
355}
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.

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
channelChannel to control.
appstasis_app for which this control is being created.
Returns
New control object.
Return values
NULLon error.

Definition at line 125 of file control.c.

126{
127 struct stasis_app_control *control;
128 int res;
129
130 control = ao2_alloc(sizeof(*control), control_dtor);
131 if (!control) {
132 return NULL;
133 }
134
135 AST_LIST_HEAD_INIT(&control->add_rules);
137
138 res = ast_cond_init(&control->wait_cond, NULL);
139 if (res != 0) {
140 ast_log(LOG_ERROR, "Error initializing ast_cond_t: %s\n",
141 strerror(errno));
142 ao2_ref(control, -1);
143 return NULL;
144 }
145
146 control->app = ao2_bump(app);
147
149 control->channel = channel;
150
153 if (!control->command_queue) {
154 ao2_ref(control, -1);
155 return NULL;
156 }
157
158 control->next_app = NULL;
159 AST_VECTOR_INIT(&control->next_app_args, 0);
160
161 return control;
162}
static const char app[]
Definition: app_adsiprog.c:56
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
#define ao2_container_alloc_list(ao2_options, container_options, sort_fn, cmp_fn)
Allocate and initialize a list container.
Definition: astobj2.h:1327
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2993
static void control_dtor(void *obj)
Definition: control.c:107
#define AST_LIST_HEAD_INIT(head)
Initializes a list head structure.
Definition: linkedlists.h:626
#define ast_cond_init(cond, attr)
Definition: lock.h:201
int errno
ast_cond_t wait_cond
Definition: control.c:54
#define AST_VECTOR_INIT(vec, size)
Initialize a vector.
Definition: vector.h:113

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.

1584{
1585 struct control_dial_args *args;
1586
1587 args = ast_malloc(sizeof(*args) + strlen(dialstring) + 1);
1588 if (!args) {
1589 return NULL;
1590 }
1591
1592 args->timeout = timeout;
1593 /* Safe */
1594 strcpy(args->dialstring, dialstring);
1595
1596 return args;
1597}
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
char dialstring[0]
Definition: control.c:1579
unsigned int timeout
Definition: control.c:1578

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.

1600{
1601 struct control_dial_args *args = data;
1602
1603 ast_free(args);
1604}

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
controlControl object to dispatch.
chanAssociated channel.
Returns
Number of commands executed

Definition at line 1504 of file control.c.

1506{
1507 int count = 0;
1508 struct ao2_iterator iter;
1509 struct stasis_app_command *command;
1510
1511 ast_assert(control->channel == chan);
1512
1514 while ((command = ao2_iterator_next(&iter))) {
1515 command_invoke(command, control, chan);
1516 ao2_ref(command, -1);
1517 ++count;
1518 }
1519 ao2_iterator_destroy(&iter);
1520
1521 return count;
1522}
#define ao2_iterator_next(iter)
Definition: astobj2.h:1911
@ AO2_ITERATOR_UNLINK
Definition: astobj2.h:1863
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
void command_invoke(struct stasis_app_command *command, struct stasis_app_control *control, struct ast_channel *chan)
Definition: command.c:101
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition: astobj2.h:1821

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.

108{
109 struct stasis_app_control *control = obj;
110
111 ao2_cleanup(control->command_queue);
112
114 ao2_cleanup(control->app);
115
116 control_move_cleanup(control);
117
118 ast_cond_destroy(&control->wait_cond);
122
123}
void ast_bridge_features_destroy(struct ast_bridge_features *features)
Destroy an allocated bridge features struct.
Definition: bridge.c:3674
#define ast_channel_cleanup(c)
Cleanup a channel reference.
Definition: channel.h:3015
#define AST_LIST_HEAD_DESTROY(head)
Destroys a list head structure.
Definition: linkedlists.h:653
#define ast_cond_destroy(cond)
Definition: lock.h:202
struct ast_bridge_features * bridge_features
Definition: control.c:70

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
controlControl object to flush command queue.

Definition at line 1491 of file control.c.

1492{
1493 struct ao2_iterator iter;
1494 struct stasis_app_command *command;
1495
1497 while ((command = ao2_iterator_next(&iter))) {
1498 command_complete(command, -1);
1499 ao2_ref(command, -1);
1500 }
1501 ao2_iterator_destroy(&iter);
1502}
void command_complete(struct stasis_app_command *command, int retval)
Definition: command.c:77

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
controlControl to query.
Return values
True(non-zero) if control_continue() has been called.
False(zero) otherwise.

Definition at line 357 of file control.c.

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

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.

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

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
controlThe control for the channel

Definition at line 1711 of file control.c.

1712{
1713 ast_free(control->next_app);
1714 control->next_app = NULL;
1715
1717}
void ast_free_ptr(void *ptr)
free() wrapper
Definition: astmm.c:1739
#define AST_VECTOR_RESET(vec, cleanup)
Reset vector.
Definition: vector.h:625

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
controlThe control for the channel
Returns
The name of the application we are moving to

Definition at line 1706 of file control.c.

1707{
1708 return control->next_app;
1709}

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
controlThe control for the channel
Returns
The arguments to pass to the application we are moving to

Definition at line 1719 of file control.c.

1720{
1721 return AST_VECTOR_STEAL_ELEMENTS(&control->next_app_args);
1722}
#define AST_VECTOR_STEAL_ELEMENTS(vec)
Steal the elements from a vector and reinitialize.
Definition: vector.h:140

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

1725{
1726 return AST_VECTOR_SIZE(&control->next_app_args);
1727}
#define AST_VECTOR_SIZE(vec)
Get the number of elements in a vector.
Definition: vector.h:609

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
controlThe control for chan
chanThe channel on which commands should be executed
Returns
The number of commands executed

Definition at line 1544 of file control.c.

1546{
1547 struct ao2_container *command_queue;
1548 int count = 0;
1549 struct ao2_iterator iter;
1550 struct stasis_app_command *command;
1551
1552 ast_channel_lock(chan);
1553 command_queue = command_prestart_get_container(chan);
1554 ast_channel_unlock(chan);
1555 if (!command_queue) {
1556 return 0;
1557 }
1558
1559 iter = ao2_iterator_init(command_queue, AO2_ITERATOR_UNLINK);
1560
1561 while ((command = ao2_iterator_next(&iter))) {
1562 command_invoke(command, control, chan);
1563 ao2_cleanup(command);
1564 ++count;
1565 }
1566
1567 ao2_iterator_destroy(&iter);
1568 ao2_cleanup(command_queue);
1569 return count;
1570}
struct ao2_container * command_prestart_get_container(struct ast_channel *chan)
Get the Stasis() prestart commands for a channel.
Definition: command.c:160
Generic container type.

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
controlThe control for the channel
appThe 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.

1701{
1702 ao2_cleanup(control->app);
1703 control->app = ao2_bump(app);
1704}

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
controlThe control for chan

Definition at line 846 of file control.c.

847{
848 if (control->silgen) {
849 ast_debug(3, "%s: Stopping silence generator\n",
852 control->channel, control->silgen);
853 control->silgen = NULL;
854 }
855}

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
controlThe control for chan
chanThe channel on which commands should be executed
bridgeBridge to be passed to the callback
swapChannel to swap with when joining the bridge

Definition at line 1293 of file control.c.

1294{
1295 int res;
1296 struct ast_bridge_features *features;
1298
1299 if (!control || !bridge) {
1300 return -1;
1301 }
1302
1303 ast_debug(3, "%s: Adding to bridge %s\n",
1305 bridge->uniqueid);
1306
1307 ast_assert(chan != NULL);
1308
1309 /* Depart whatever Stasis bridge we're currently in. */
1310 if (stasis_app_get_bridge(control)) {
1311 /* Note that it looks like there's a race condition here, since
1312 * we don't have control locked. But this happens from the
1313 * control callback thread, so there won't be any other
1314 * concurrent attempts to bridge.
1315 */
1316 ast_bridge_depart(chan);
1317 }
1318
1319
1321 bridge_after_cb_failed, control);
1322 if (res != 0) {
1323 ast_log(LOG_ERROR, "Error setting after-bridge callback\n");
1324 return -1;
1325 }
1326
1327 ao2_lock(control);
1328
1329 /* Ensure the controlling application is subscribed early enough
1330 * to receive the ChannelEnteredBridge message. This works in concert
1331 * with the subscription handled in the Stasis application execution
1332 * loop */
1333 app_subscribe_bridge(control->app, bridge);
1334
1335 /* Save off the channel's PBX */
1336 ast_assert(control->pbx == NULL);
1337 if (!control->pbx) {
1338 control->pbx = ast_channel_pbx(chan);
1340 }
1341
1342 /* Pull bridge features from the control */
1343 features = control->bridge_features;
1344 control->bridge_features = NULL;
1345 if (features && features->inhibit_colp) {
1347 }
1348
1350 /* We need to set control->bridge here since bridge_after_cb may be run
1351 * before ast_bridge_impart returns. bridge_after_cb gets a reason
1352 * code so it can tell if the bridge is actually valid or not.
1353 */
1354 control->bridge = bridge;
1355
1356 /* We can't be holding the control lock while impart is running
1357 * or we could create a deadlock with bridge_after_cb which also
1358 * tries to lock control.
1359 */
1360 ao2_unlock(control);
1361 res = ast_bridge_impart(bridge,
1362 chan,
1363 swap,
1364 features, /* features */
1365 flags);
1366 if (res != 0) {
1367 /* ast_bridge_impart failed before it could spawn the depart
1368 * thread. The callbacks aren't called in this case.
1369 * The impart could still fail even if ast_bridge_impart returned
1370 * ok but that's handled by bridge_after_cb.
1371 */
1372 ast_log(LOG_ERROR, "Error adding channel to bridge\n");
1373 ao2_lock(control);
1374 ast_channel_pbx_set(chan, control->pbx);
1375 control->pbx = NULL;
1376 control->bridge = NULL;
1377 ao2_unlock(control);
1378 } else {
1379 ast_channel_lock(chan);
1380 set_interval_hook(chan);
1381 ast_channel_unlock(chan);
1382 }
1383
1384 return res;
1385}
@ AST_BRIDGE_IMPART_INHIBIT_JOIN_COLP
Definition: bridge.h:592
struct ast_pbx * ast_channel_pbx(const struct ast_channel *chan)
void ast_channel_pbx_set(struct ast_channel *chan, struct ast_pbx *value)
static void set_interval_hook(struct ast_channel *chan)
Set a dial timeout interval hook on the channel.
Definition: control.c:1263
static void bridge_after_cb(struct ast_channel *chan, void *data)
Definition: control.c:1172
static void bridge_after_cb_failed(enum ast_bridge_after_cb_reason reason, void *data)
Definition: control.c:1179
int app_subscribe_bridge(struct stasis_app *app, struct ast_bridge *bridge)
Add a bridge subscription to an existing channel subscription.
Structure that contains features information.
unsigned int inhibit_colp
struct ast_pbx * pbx
Definition: control.c:74

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
controlControl to block on.

Definition at line 1524 of file control.c.

1525{
1526 if (!control) {
1527 return;
1528 }
1529
1530 ast_assert(control->command_queue != NULL);
1531
1532 ao2_lock(control->command_queue);
1533 while (ao2_container_count(control->command_queue) == 0) {
1534 int res = ast_cond_wait(&control->wait_cond,
1536 if (res < 0) {
1537 ast_log(LOG_ERROR, "Error waiting on command queue\n");
1538 break;
1539 }
1540 }
1541 ao2_unlock(control->command_queue);
1542}
void * ao2_object_get_lockaddr(void *obj)
Return the mutex lock address of an object.
Definition: astobj2.c:476
#define ast_cond_wait(cond, mutex)
Definition: lock.h:205

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
controlTake a guess
chanTake another guess

Definition at line 1078 of file control.c.

1079{
1080 ast_bridge_depart(chan);
1081
1082 /* Channels which have a PBX are not ones that have been created and dialed from ARI. They
1083 * have externally come in from the dialplan, and thus should not be placed into the dial
1084 * bridge. Only channels which are created and dialed in ARI should go into the dial bridge.
1085 */
1086 if (!ast_check_hangup(chan) && ast_channel_state(chan) != AST_STATE_UP && !ast_channel_pbx(chan)) {
1087 /* Channel is still being dialed, so put it back in the dialing bridge */
1088 add_to_dial_bridge(control, chan);
1089 }
1090
1091 return 0;
1092}
int ast_check_hangup(struct ast_channel *chan)
Check to see if a channel is needing hang up.
Definition: channel.c:445

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.

1019{
1020 struct stasis_app_control *control = data;
1021 struct ast_bridge_channel *bridge_channel;
1022
1024 bridge_channel = ast_channel_get_bridge_channel(chan);
1026
1027 ast_debug(3, "Channel: <%s> Reason: %d\n", ast_channel_name(control->channel), ast_channel_hangupcause(chan));
1028
1030
1031 control->bridge = NULL;
1032}
void __ao2_cleanup(void *obj)
Definition: astobj2.c:677
int ast_channel_hangupcause(const struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
Definition: channel.c:10604
static int bridge_channel_depart(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:1094

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.

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

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.

531{
532 if (dtmf_data->before) {
533 usleep(dtmf_data->before * 1000);
534 }
535
536 ast_dtmf_stream_external(chan, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
537
538 if (dtmf_data->after) {
539 usleep(dtmf_data->after * 1000);
540 }
541}
void ast_dtmf_stream_external(struct ast_channel *chan, const char *digits, int between, unsigned int duration)
Send a string of DTMF digits to a channel from an external thread.
Definition: main/app.c:1142

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.

544{
545 if (dtmf_data->before) {
546 ast_safe_sleep(chan, dtmf_data->before);
547 }
548
549 ast_dtmf_stream(chan, NULL, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
550
551 if (dtmf_data->after) {
552 ast_safe_sleep(chan, dtmf_data->after);
553 }
554}
int ast_safe_sleep(struct ast_channel *chan, int ms)
Wait for a specified amount of time, looking for hangups.
Definition: channel.c:1593
int ast_dtmf_stream(struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between, unsigned int duration)
Send a string of DTMF digits to a channel.
Definition: main/app.c:1127

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.

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

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.

273{
274 int retval;
275 struct stasis_app_command *command;
276
277 command_fn = command_fn ? : noop_cb;
278
279 command = command_create(command_fn, data, data_destructor);
280 if (!command) {
281 return NULL;
282 }
283
284 ao2_lock(control->command_queue);
285 if (control->is_done) {
286 ao2_unlock(control->command_queue);
287 ao2_ref(command, -1);
288 return NULL;
289 }
290 if (can_exec_fn && (retval = can_exec_fn(control))) {
291 ao2_unlock(control->command_queue);
292 command_complete(command, retval);
293 return command;
294 }
295
296 ao2_link_flags(control->command_queue, command, OBJ_NOLOCK);
297 ast_cond_signal(&control->wait_cond);
298
299 if (control->channel) {
300 /* Queue a null frame so that if and when the channel is waited on,
301 return immediately to process the new command */
303 }
304
305 ao2_unlock(control->command_queue);
306
307 return command;
308}
#define ao2_link_flags(container, obj, flags)
Add an object to a container.
Definition: astobj2.h:1554
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition: astobj2.h:1063
int ast_queue_frame(struct ast_channel *chan, struct ast_frame *f)
Queue one or more frames to a channel's frame queue.
Definition: channel.c:1158
struct stasis_app_command * command_create(stasis_app_command_cb callback, void *data, command_data_destructor_fn data_destructor)
Definition: command.c:55
static int noop_cb(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:259
static ENTRY retval
Definition: hsearch.c:50
struct ast_frame ast_null_frame
Definition: main/frame.c:79
#define ast_cond_signal(cond)
Definition: lock.h:203

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.

702{
703 struct chanvar *var = data;
704
705 ast_free(var->name);
706 ast_free(var->value);
707 ast_free(var);
708}

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
NULLUnable to find/create the dial bridge
non-NULLA reference to the dial bridge

Definition at line 983 of file control.c.

984{
985 struct ast_bridge *ret_bridge = NULL;
986
988
989 if (shutting_down) {
990 goto end;
991 }
992
993 if (dial_bridge) {
994 ret_bridge = ao2_bump(dial_bridge);
995 goto end;
996 }
997
998 dial_bridge = stasis_app_bridge_create_invisible("holding", "dial_bridge", NULL);
999 if (!dial_bridge) {
1000 goto end;
1001 }
1002 ret_bridge = ao2_bump(dial_bridge);
1003
1004end:
1006 return ret_bridge;
1007}
static struct ast_bridge * dial_bridge
Singleton dial bridge.
Definition: control.c:967
static int shutting_down
Indicates if the Stasis app internals are being shut down.
Definition: control.c:51
static ast_mutex_t dial_bridge_lock
Definition: control.c:968
char * end
Definition: eagi_proxy.c:73
#define ast_mutex_unlock(a)
Definition: lock.h:190
#define ast_mutex_lock(a)
Definition: lock.h:189
struct ast_bridge * stasis_app_bridge_create_invisible(const char *type, const char *name, const char *id)
Create an invisible bridge of the specified type.
Definition: res_stasis.c:859

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.

1207{
1209 return 0;
1210}
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
Definition: channel.c:2490
@ AST_SOFTHANGUP_EXPLICIT
Definition: channel.h:1168

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.

1119{
1120 struct stasis_app_control *control = data;
1121 struct ast_bridge_channel *bridge_channel;
1122
1123 ao2_lock(control);
1124 ast_debug(3, "%s, %s: %s\n",
1125 ast_channel_uniqueid(chan), control->bridge ? control->bridge->uniqueid : "unknown",
1127
1129 /* The impart actually failed so control->bridge isn't valid. */
1130 control->bridge = NULL;
1131 }
1132
1133 ast_assert(chan == control->channel);
1134
1135 /* Restore the channel's PBX */
1136 ast_channel_pbx_set(control->channel, control->pbx);
1137 control->pbx = NULL;
1138
1139 if (control->bridge) {
1140 app_unsubscribe_bridge(control->app, control->bridge);
1141
1142 /* No longer in the bridge */
1143 control->bridge = NULL;
1144
1145 /* Get the bridge channel so we don't depart from the wrong bridge */
1147 bridge_channel = ast_channel_get_bridge_channel(chan);
1149
1150 /* Depart this channel from the bridge using the command queue if possible */
1152 }
1153
1155 /* The channel has had a StasisEnd published on it, but until now had remained in
1156 * the bridging system. This means that the channel moved from a Stasis bridge to a
1157 * non-Stasis bridge and is now exiting the bridging system. Because of this, the
1158 * channel needs to exit the Stasis application and go to wherever the non-Stasis
1159 * bridge has directed it to go. If the non-Stasis bridge has not set up an after
1160 * bridge destination, then the channel should be hung up.
1161 */
1162 int hangup_flag;
1163
1166 ast_softhangup_nolock(chan, hangup_flag);
1168 }
1169 ao2_unlock(control);
1170}
@ AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED
Definition: bridge_after.h:49
int app_unsubscribe_bridge(struct stasis_app *app, struct ast_bridge *bridge)
Cancel the bridge subscription for an application.
int stasis_app_channel_is_stasis_end_published(struct ast_channel *chan)
Has this channel had a StasisEnd published on it?
Definition: res_stasis.c:1302

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.

261{
262 return 0;
263}

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
chanThe channel on which to set the interval hook

Definition at line 1263 of file control.c.

1264{
1265 struct ast_datastore *datastore;
1266 struct timeval *hangup_time;
1267 int64_t ms;
1268 struct ast_bridge_channel *bridge_channel;
1269
1271 if (!datastore) {
1272 return;
1273 }
1274
1275 hangup_time = datastore->data;
1276
1277 ms = ast_tvdiff_ms(*hangup_time, ast_tvnow());
1278 bridge_channel = ast_channel_get_bridge_channel(chan);
1279 if (!bridge_channel) {
1280 return;
1281 }
1282
1283 if (ast_bridge_interval_hook(bridge_channel->features, 0, ms > 0 ? ms : 1,
1284 bridge_timeout, NULL, NULL, 0)) {
1285 ao2_ref(bridge_channel, -1);
1286 return;
1287 }
1288
1289 ast_queue_frame(bridge_channel->chan, &ast_null_frame);
1290 ao2_ref(bridge_channel, -1);
1291}
int ast_bridge_interval_hook(struct ast_bridge_features *features, enum ast_bridge_hook_timer_option flags, unsigned int interval, ast_bridge_hook_callback callback, void *hook_pvt, ast_bridge_hook_pvt_destructor destructor, enum ast_bridge_hook_remove_flags remove_flags)
Attach an interval hook to a bridge features structure.
Definition: bridge.c:3319
static int bridge_timeout(struct ast_bridge_channel *bridge_channel, void *ignore)
Dial timeout.
Definition: control.c:1224
struct ast_bridge_features * features
void * data
Definition: datastore.h:66
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:107
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159

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
chanThe channel on which to set the dial timeout
timeoutThe timeout in seconds

Definition at line 1612 of file control.c.

1613{
1614 struct ast_datastore *datastore;
1615 struct timeval *hangup_time;
1616
1617 hangup_time = ast_malloc(sizeof(struct timeval));
1618
1620 if (!datastore) {
1621 return -1;
1622 }
1623 *hangup_time = ast_tvadd(ast_tvnow(), ast_samp2tv(timeout, 1));
1624 datastore->data = hangup_time;
1625
1626 ast_channel_lock(chan);
1627 ast_channel_datastore_add(chan, datastore);
1628
1629 if (ast_channel_is_bridged(chan)) {
1630 set_interval_hook(chan);
1631 }
1632 ast_channel_unlock(chan);
1633
1634 return 0;
1635}
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition: channel.c:2404
#define ast_datastore_alloc(info, uid)
Definition: datastore.h:85
struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate)
Returns a timeval corresponding to the duration of n samples at rate r. Useful to convert samples to ...
Definition: time.h:282
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition: extconf.c:2282

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
controlControl whose channel should have its DTMF absorbed when bridged
absorbWhether DTMF should be absorbed (1) instead of passed through (0).

Definition at line 1473 of file control.c.

1475{
1476 control->bridge_features->dtmf_passthrough = !absorb;
1477}
unsigned int dtmf_passthrough

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
controlControl whose channel should be added to the bridge
bridgePointer to the bridge
Returns
non-zero on failure
zero on success

Definition at line 1392 of file control.c.

1394{
1395 ast_debug(3, "%s: Sending channel add_to_bridge command\n",
1397
1399 control, control_add_channel_to_bridge, bridge, NULL,
1401}
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.
Definition: control.c:1387
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)
Definition: control.c:875
static int app_control_can_add_channel_to_bridge(struct stasis_app_control *control)
Definition: control.c:247

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
controlControl for res_stasis
roleRole to apply
Returns
0 for success
-1 for error.

Definition at line 325 of file control.c.

326{
327 char *role_dup;
328
329 role_dup = ast_strdup(role);
330 if (!role_dup) {
331 return -1;
332 }
333
335
336 return 0;
337}
static int app_control_add_role(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:317

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
controlControl in which to store the features
Returns
non-zero on failure
zero on success

Definition at line 1460 of file control.c.

1462{
1463 struct ast_bridge_features *features;
1464
1465 features = ast_bridge_features_new();
1466 if (!features) {
1467 return 1;
1468 }
1469 control->bridge_features = features;
1470 return 0;
1471}
struct ast_bridge_features * ast_bridge_features_new(void)
Allocate a new bridge features struct.
Definition: bridge.c:3683

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
controlControl for res_stasis

Definition at line 347 of file control.c.

348{
350}
static int app_control_clear_roles(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:339

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
controlControl for res_stasis
contextAn optional context to continue to
extensionAn optional extension to continue to
priorityAn optional priority to continue to
Returns
0 for success
-1 for error.

Definition at line 398 of file control.c.

399{
400 struct stasis_app_control_continue_data *continue_data;
401
402 if (!(continue_data = ast_calloc(1, sizeof(*continue_data)))) {
403 return -1;
404 }
405 ast_copy_string(continue_data->context, S_OR(context, ""), sizeof(continue_data->context));
406 ast_copy_string(continue_data->extension, S_OR(extension, ""), sizeof(continue_data->extension));
407 if (priority > 0) {
408 continue_data->priority = priority;
409 } else {
410 continue_data->priority = -1;
411 }
412
414
415 return 0;
416}
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
static int priority
static int app_control_continue(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:377
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition: strings.h:80
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
structure to hold extensions

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
controlControl for res_stasis.
dialstringThe dialstring to pass to the channel driver
timeoutOptional timeout in milliseconds

Definition at line 1675 of file control.c.

1677{
1678 struct control_dial_args *args;
1679
1681 if (!args) {
1682 return -1;
1683 }
1684
1687}
static struct control_dial_args * control_dial_args_alloc(const char *dialstring, unsigned int timeout)
Definition: control.c:1582
static void control_dial_args_destroy(void *data)
Definition: control.c:1599
static int app_control_dial(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:1637

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
controlControl for res_stasis.
dtmfDTMF string.
beforeAmount of time to wait before sending DTMF digits.
betweenAmount of time between each DTMF digit.
durationAmount of time each DTMF digit lasts for.
afterAmount of time to wait after sending DTMF digits.
Returns
0 for success.
-1 for error.

Definition at line 574 of file control.c.

575{
576 struct stasis_app_control_dtmf_data *dtmf_data;
577
578 if (!(dtmf_data = ast_calloc(1, sizeof(*dtmf_data) + strlen(dtmf) + 1))) {
579 return -1;
580 }
581
582 dtmf_data->before = before;
583 dtmf_data->between = between;
584 dtmf_data->duration = duration;
585 dtmf_data->after = after;
586 strcpy(dtmf_data->dtmf, dtmf);
587
589
590 return 0;
591}
static int app_control_dtmf(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:556

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)

◆ 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
controlControl for res_stasis.
Returns
Most recent snapshot. ao2_cleanup() when done.
Return values
NULLif channel isn't in cache.

Definition at line 869 of file control.c.

871{
873}
struct ast_channel_snapshot * ast_channel_snapshot_get_latest(const char *uniqueid)
Obtain the latest ast_channel_snapshot from the Stasis Message Bus API cache. This is an ao2 object,...

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
controlControl for res_stasis.

Definition at line 757 of file control.c.

758{
760}
static int app_control_hold(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:749

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
controlControl whose channel should have its COLP frames inhibited when bridged
inhibit_colpWhether COLP frames should be generated (0) or not (1).

Definition at line 1485 of file control.c.

1487{
1488 control->bridge_features->inhibit_colp = inhibit_colp;
1489}

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
controlControl for res_stasis.
moh_classclass of music on hold to play (NULL allowed)

Definition at line 789 of file control.c.

790{
791 char *data = NULL;
792
793 if (!ast_strlen_zero(moh_class)) {
794 data = ast_strdup(moh_class);
795 }
796
798}
static int app_control_moh_start(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:775
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65

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
controlControl for res_stasis.

Definition at line 807 of file control.c.

808{
810}
static int app_control_moh_stop(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:800

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
controlControl for res_stasis
app_nameThe name of the application to switch to
app_argsThe list of arguments to pass to the application
Returns
0 for success
-1 for error

Definition at line 460 of file control.c.

461{
462 struct stasis_app_control_move_data *move_data;
463 size_t size;
464
465 size = sizeof(*move_data) + strlen(app_name) + 1;
466 if (app_args) {
467 /* Application arguments are optional */
468 size += strlen(app_args) + 1;
469 }
470
471 if (!(move_data = ast_calloc(1, size))) {
472 return -1;
473 }
474
475 move_data->app_name = (char *)move_data + sizeof(*move_data);
476 strcpy(move_data->app_name, app_name); /* Safe */
477
478 if (app_args) {
479 move_data->app_args = move_data->app_name + strlen(app_name) + 1;
480 strcpy(move_data->app_args, app_args); /* Safe */
481 } else {
482 move_data->app_args = NULL;
483 }
484
486
487 return 0;
488}
static int app_control_move(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:423
const char * app_name(struct ast_app *app)
Definition: pbx_app.c:463

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
controlControl for res_stasis.
directionThe direction in which the audio should be muted.
frametypeThe type of stream that should be muted.
Returns
0 for success
-1 for error.

Definition at line 640 of file control.c.

641{
642 struct stasis_app_control_mute_data *mute_data;
643
644 if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
645 return -1;
646 }
647
648 mute_data->direction = direction;
649 mute_data->frametype = frametype;
650
652
653 return 0;
654}
static int app_control_mute(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:628
direction

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
controlControl whose channel should have its audio muted when bridged
muteWhether audio should be muted (1) instead of passed through (0).

Definition at line 1479 of file control.c.

1481{
1482 control->bridge_features->mute = mute;
1483}

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
controlControl to publish to
messageMessage to publish

Definition at line 1445 of file control.c.

1447{
1448 if (!control || !control->channel || !message) {
1449 return;
1450 }
1452}
struct stasis_topic * ast_channel_topic(struct ast_channel *chan)
A topic which publishes the events for a particular channel.
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic's subscribers.
Definition: stasis.c:1512

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
controlControl to publish to.
frame_typetype of control frame.
Returns
zero on success
non-zero on failure

Definition at line 1454 of file control.c.

1456{
1457 return ast_queue_control(control->channel, frame_type);
1458}
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame without payload.
Definition: channel.c:1250
frame_type
Definition: codec_builtin.c:44

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
controlControl for res_stasis
endpointThe 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.

510{
511 char *endpoint_data = ast_strdup(endpoint);
512
513 if (!endpoint_data) {
514 return -1;
515 }
516
518
519 return 0;
520}
static int app_control_redirect(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:490

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
controlControl object
ruleThe rule to register

Definition at line 219 of file control.c.

222{
223 return app_control_register_rule(control, &control->add_rules, rule);
224}
static void app_control_register_rule(struct stasis_app_control *control, struct app_control_rules *list, struct stasis_app_control_rule *obj)
Definition: control.c:164

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
controlControl object
ruleThe rule to register

Definition at line 233 of file control.c.

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

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
controlControl whose channel should be removed from the bridge
bridgePointer to the bridge
Returns
non-zero on failure
zero on success

Definition at line 1429 of file control.c.

1431{
1432 ast_debug(3, "%s: Sending channel remove_from_bridge command\n",
1437}
static int app_control_remove_channel_from_bridge(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:1403
static int app_control_can_remove_channel_from_bridge(struct stasis_app_control *control)
Definition: control.c:253

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
controlControl for res_stasis.
Returns
0 for success.
-1 for error.

Definition at line 601 of file control.c.

602{
604
605 return 0;
606}
static int app_control_ring(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:593

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
controlControl for res_stasis.
Returns
0 for success.
-1 for error.

Definition at line 616 of file control.c.

617{
619
620 return 0;
621}
static int app_control_ring_stop(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:608

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
controlControl for res_stasis.
variableThe name of the variable
valueThe value to set the variable to
Returns
0 for success.
-1 for error.

Definition at line 720 of file control.c.

721{
722 struct chanvar *var;
723
724 var = ast_calloc(1, sizeof(*var));
725 if (!var) {
726 return -1;
727 }
728
729 var->name = ast_strdup(variable);
730 if (!var->name) {
732 return -1;
733 }
734
735 /* It's kosher for value to be NULL. It means the variable is being unset */
736 if (value) {
737 var->value = ast_strdup(value);
738 if (!var->value) {
740 return -1;
741 }
742 }
743
745
746 return 0;
747}
static int app_control_set_channel_var(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:710
static void free_chanvar(void *data)
Definition: control.c:701
int value
Definition: syslog.c:37

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.

1690{
1692 shutting_down = 1;
1693 if (dial_bridge) {
1695 dial_bridge = NULL;
1696 }
1698}
int ast_bridge_destroy(struct ast_bridge *bridge, int cause)
Destroy a bridge.
Definition: bridge.c:944

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
controlControl for res_stasis.

Definition at line 841 of file control.c.

842{
844}
static int app_control_silence_start(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:812

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
controlControl for res_stasis.

Definition at line 864 of file control.c.

865{
867}
static int app_control_silence_stop(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:857

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
controlControl for res_stasis.

Definition at line 770 of file control.c.

771{
773}
static int app_control_unhold(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:762

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
controlControl for res_stasis.
directionThe direction in which the audio should be unmuted.
frametypeThe type of stream that should be unmuted.
Returns
0 for success
-1 for error.

Definition at line 668 of file control.c.

669{
670 struct stasis_app_control_mute_data *mute_data;
671
672 if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
673 return -1;
674 }
675
676 mute_data->direction = direction;
677 mute_data->frametype = frametype;
678
680
681 return 0;
682}
static int app_control_unmute(struct stasis_app_control *control, struct ast_channel *chan, void *data)
Definition: control.c:656

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
controlControl object
ruleThe rule to unregister

Definition at line 226 of file control.c.

229{
230 app_control_unregister_rule(control, &control->add_rules, rule);
231}
static void app_control_unregister_rule(struct stasis_app_control *control, struct app_control_rules *list, struct stasis_app_control_rule *obj)
Definition: control.c:173

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
controlControl object
ruleThe rule to unregister

Definition at line 240 of file control.c.

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

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
controlControl object for the channel to query.
Returns
Associated ast_bridge.
Return values
NULLif not associated with a bridge.

Definition at line 940 of file control.c.

941{
942 struct ast_bridge *ret;
943
944 if (!control) {
945 return NULL;
946 }
947
948 ao2_lock(control);
949 ret = control->bridge;
950 ao2_unlock(control);
951
952 return ret;
953}

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
controlControl object for the channel to send the command to.
commandCommand function to execute.
dataOptional data to pass along with the control function.
data_destructorOptional 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.

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

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
controlControl object for the channel to send the command to.
commandCommand function to execute.
dataOptional data to pass along with the control function.
data_destructorOptional 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.

916{
917 struct stasis_app_command *command;
918
919 if (control == NULL || control->is_done) {
920 /* If exec_command fails, it calls the data_destructor. In order to
921 * provide consistent behavior, we'll also call the data_destructor
922 * on this error path. This way, callers never have to call the
923 * data_destructor themselves.
924 */
925 if (data_destructor) {
927 }
928 return -1;
929 }
930
931 command = exec_command(control, command_fn, data, data_destructor);
932 if (!command) {
933 return -1;
934 }
935 ao2_ref(command, -1);
936
937 return 0;
938}
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)
Definition: control.c:310

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