Asterisk - The Open Source Telephony Project GIT-master-8f1982c
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Modules Pages
Data Structures | Macros | Typedefs | Functions | Variables
res_stasis.c File Reference

Stasis application support. More...

#include "asterisk.h"
#include "asterisk/astobj2.h"
#include "asterisk/callerid.h"
#include "asterisk/module.h"
#include "asterisk/stasis_app_impl.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_endpoints.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/strings.h"
#include "stasis/app.h"
#include "stasis/control.h"
#include "stasis/messaging.h"
#include "stasis/stasis_bridge.h"
#include "asterisk/core_unreal.h"
#include "asterisk/musiconhold.h"
#include "asterisk/causes.h"
#include "asterisk/stringfields.h"
#include "asterisk/bridge_after.h"
#include "asterisk/format_cache.h"
Include dependency graph for res_stasis.c:

Go to the source code of this file.

Data Structures

struct  event_sources
 
struct  replace_channel_store
 
struct  start_message_blob
 
struct  stasis_app_bridge_channel_wrapper
 

Macros

#define APPS_NUM_BUCKETS   127
 Number of buckets for the Stasis application hash table. Remember to keep it a prime number! More...
 
#define BRIDGES_NUM_BUCKETS   127
 Number of buckets for the Stasis bridges hash table. Remember to keep it a prime number! More...
 
#define CONTROLS_NUM_BUCKETS   127
 Number of buckets for the Stasis application hash table. Remember to keep it a prime number! More...
 
#define MAX_WAIT_MS   200
 

Typedefs

typedef enum stasis_app_subscribe_res(* app_subscription_handler) (struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)
 

Functions

static void __reg_module (void)
 
static int __stasis_app_register (const char *app_name, stasis_app_cb handler, void *data, int all_events)
 
static void __unreg_module (void)
 
static int add_masquerade_store (struct ast_channel *chan)
 
static int app_compare (void *obj, void *arg, int flags)
 
static struct stasis_app_event_sourceapp_event_source_find (const char *uri)
 
static struct ast_jsonapp_event_sources_to_json (const struct stasis_app *app, struct ast_json *json)
 
char * app_get_replace_channel_app (struct ast_channel *chan)
 Get the app that the replacement channel will be controlled by. More...
 
static enum stasis_app_subscribe_res app_handle_subscriptions (const char *app_name, const char **event_source_uris, int event_sources_count, struct ast_json **json, app_subscription_handler handler)
 
static int app_hash (const void *obj, const int flags)
 
int app_send_end_msg (struct stasis_app *app, struct ast_channel *chan)
 Send StasisEnd message to the listening app. More...
 
int app_set_replace_channel_app (struct ast_channel *chan, const char *replace_app)
 Set the app that the replacement channel will be controlled by. More...
 
int app_set_replace_channel_snapshot (struct ast_channel *chan, struct ast_channel_snapshot *replace_snapshot)
 Set the snapshot of the channel that this channel will replace. More...
 
static enum stasis_app_subscribe_res app_subscribe (struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)
 
static enum stasis_app_subscribe_res app_unsubscribe (struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)
 
static int append_name (void *obj, void *arg, int flags)
 
struct ast_moduleAST_MODULE_SELF_SYM (void)
 
static struct ast_bridgebridge_create_common (const char *type, const char *name, const char *id, int invisible)
 
static struct ast_channelbridge_moh_create (struct ast_bridge *bridge)
 
static int bridges_channel_compare (void *obj, void *arg, int flags)
 
static int bridges_channel_hash_fn (const void *obj, const int flags)
 
static int bridges_channel_sort_fn (const void *obj_left, const void *obj_right, const int flags)
 
static int bridges_compare (void *obj, void *arg, int flags)
 
static int bridges_hash (const void *obj, const int flags)
 
static int bridges_sort (const void *left, const void *right, const int flags)
 
static int channel_id_sanitizer (const char *id)
 Sanitization callback for channel unique IDs. More...
 
static void channel_replaced_cb (void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
 
static int channel_sanitizer (const struct ast_channel *chan)
 Sanitization callback for channels. More...
 
static int channel_snapshot_sanitizer (const struct ast_channel_snapshot *snapshot)
 Sanitization callback for channel snapshots. More...
 
static void channel_stolen_cb (void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
 
static void cleanup (void)
 Clean up any old apps that we don't need any more. More...
 
static int cleanup_cb (void *obj, void *arg, int flags)
 
static int control_compare (void *obj, void *arg, int flags)
 
static int control_hash (const void *obj, const int flags)
 
static void control_unlink (struct stasis_app_control *control)
 In addition to running ao2_cleanup(), this function also removes the object from the app_controls container. More...
 
static struct stasis_appfind_app_by_name (const char *app_name)
 
static struct ast_channel_snapshotget_replace_channel_snapshot (struct ast_channel *chan)
 
static struct replace_channel_storeget_replace_channel_store (struct ast_channel *chan, int no_create)
 
static int has_masquerade_store (struct ast_channel *chan)
 
static int load_module (void)
 
static int masq_match_cb (void *obj, void *data, int flags)
 
static void * moh_channel_thread (void *data)
 
static void playback_after_bridge_cb (struct ast_channel *chan, void *data)
 
static void playback_after_bridge_cb_failed (enum ast_bridge_after_cb_reason reason, void *data)
 
static struct ast_channelprepare_bridge_moh_channel (void)
 
static void remove_bridge_playback (char *bridge_id)
 
static void remove_masquerade_store (struct ast_channel *chan)
 
static void remove_stasis_end_published (struct ast_channel *chan)
 
static void replace_channel_destroy (void *obj)
 
static int send_start_msg (struct stasis_app *app, struct ast_channel *chan, int argc, char *argv[])
 
static int send_start_msg_snapshots (struct ast_channel *chan, struct stasis_app *app, int argc, char *argv[], struct ast_channel_snapshot *snapshot, struct ast_channel_snapshot *replace_channel_snapshot)
 
static int set_internal_datastore (struct ast_channel *chan)
 
static void start_message_blob_dtor (void *obj)
 
static void stasis_app_bridge_channel_wrapper_destructor (void *obj)
 
struct ast_bridgestasis_app_bridge_create (const char *type, const char *name, const char *id)
 Create a bridge of the specified type. More...
 
struct ast_bridgestasis_app_bridge_create_invisible (const char *type, const char *name, const char *id)
 Create an invisible bridge of the specified type. More...
 
void stasis_app_bridge_destroy (const char *bridge_id)
 Destroy the bridge. More...
 
struct ast_bridgestasis_app_bridge_find_by_id (const char *bridge_id)
 Returns the bridge with the given id. More...
 
struct ast_channelstasis_app_bridge_moh_channel (struct ast_bridge *bridge)
 Finds or creates an announcer channel in a bridge that can play music on hold. More...
 
int stasis_app_bridge_moh_stop (struct ast_bridge *bridge)
 Breaks down MOH channels playing on the bridge created by stasis_app_bridge_moh_channel. More...
 
int stasis_app_bridge_playback_channel_add (struct ast_bridge *bridge, struct ast_channel *chan, struct stasis_app_control *control)
 Adds a channel to the list of ARI playback channels for bridges. More...
 
struct ast_channelstasis_app_bridge_playback_channel_find (struct ast_bridge *bridge)
 Finds an existing ARI playback channel in a bridge. More...
 
void stasis_app_bridge_playback_channel_remove (char *bridge_id, struct stasis_app_control *control)
 remove channel from list of ARI playback channels for bridges. More...
 
int stasis_app_channel_is_internal (struct ast_channel *chan)
 Is this channel internal to Stasis? More...
 
int stasis_app_channel_is_stasis_end_published (struct ast_channel *chan)
 Has this channel had a StasisEnd published on it? More...
 
int stasis_app_channel_set_internal (struct ast_channel *chan)
 Mark this channel as being internal to Stasis. More...
 
void stasis_app_channel_set_stasis_end_published (struct ast_channel *chan)
 Indicate that this channel has had a StasisEnd published for it. More...
 
int stasis_app_channel_unreal_set_internal (struct ast_channel *chan)
 Mark this unreal channel and it's other half as being internal to Stasis. More...
 
struct stasis_app_controlstasis_app_control_create (struct ast_channel *chan)
 Creates a control handler for a channel that isn't in a stasis app. More...
 
void stasis_app_control_execute_until_exhausted (struct ast_channel *chan, struct stasis_app_control *control)
 Act on a stasis app control queue until it is empty. More...
 
struct stasis_app_controlstasis_app_control_find_by_channel (const struct ast_channel *chan)
 Returns the handler for the given channel. More...
 
struct stasis_app_controlstasis_app_control_find_by_channel_id (const char *channel_id)
 Returns the handler for the channel with the given id. More...
 
void stasis_app_control_flush_queue (struct stasis_app_control *control)
 Flush the control command queue. More...
 
int stasis_app_control_is_done (struct stasis_app_control *control)
 Check if a control is marked as done. More...
 
int stasis_app_exec (struct ast_channel *chan, const char *app_name, int argc, char *argv[])
 Stasis dialplan application callback. More...
 
struct ao2_containerstasis_app_get_all (void)
 Gets the names of all registered Stasis applications. More...
 
struct stasis_appstasis_app_get_by_name (const char *name)
 Retrieve a handle to a Stasis application by its name. More...
 
struct stasis_message_sanitizerstasis_app_get_sanitizer (void)
 Get the Stasis message sanitizer for app_stasis applications. More...
 
int stasis_app_is_registered (const char *name)
 Check if a Stasis application is registered. More...
 
struct ast_jsonstasis_app_object_to_json (struct stasis_app *app)
 Return the JSON representation of a Stasis application. More...
 
int stasis_app_register (const char *app_name, stasis_app_cb handler, void *data)
 Register a new Stasis application. More...
 
int stasis_app_register_all (const char *app_name, stasis_app_cb handler, void *data)
 Register a new Stasis application that receives all Asterisk events. More...
 
void stasis_app_register_event_source (struct stasis_app_event_source *obj)
 Register an application event source. More...
 
int stasis_app_send (const char *app_name, struct ast_json *message)
 Send a message to the given Stasis application. More...
 
enum stasis_app_subscribe_res stasis_app_subscribe (const char *app_name, const char **event_source_uris, int event_sources_count, struct ast_json **json)
 Subscribes an application to a list of event sources. More...
 
enum stasis_app_subscribe_res stasis_app_subscribe_channel (const char *app_name, struct ast_channel *chan)
 Directly subscribe an application to a channel. More...
 
struct ast_jsonstasis_app_to_json (const char *app_name)
 Return the JSON representation of a Stasis application. More...
 
void stasis_app_unregister (const char *app_name)
 Unregister a Stasis application and unsubscribe from all event sources. More...
 
void stasis_app_unregister_event_source (struct stasis_app_event_source *obj)
 Unregister an application event source. More...
 
enum stasis_app_subscribe_res stasis_app_unsubscribe (const char *app_name, const char **event_source_uris, int event_sources_count, struct ast_json **json)
 Unsubscribes an application from a list of event sources. More...
 
enum stasis_app_user_event_res stasis_app_user_event (const char *app_name, const char *event_name, const char **source_uris, int sources_count, struct ast_json *json_variables)
 Generate a Userevent for stasis app (echo to AMI) More...
 
static struct ast_jsonstasis_end_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
 
 STASIS_MESSAGE_TYPE_DEFN_LOCAL (end_message_type,.to_json=stasis_end_to_json)
 
 STASIS_MESSAGE_TYPE_DEFN_LOCAL (start_message_type,.to_json=stasis_start_to_json)
 
static struct ast_jsonstasis_start_to_json (struct stasis_message *message, const struct stasis_message_sanitizer *sanitize)
 
static int unload_module (void)
 

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Stasis application support" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load_pri = AST_MODPRI_APP_DEPEND - 1, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, }
 
struct ao2_containerapp_bridges
 
struct ao2_containerapp_bridges_moh
 
struct ao2_containerapp_bridges_playback
 
struct ao2_containerapp_controls
 
struct stasis_message_sanitizer app_sanitizer
 Sanitization callbacks for communication to Stasis applications. More...
 
struct ao2_containerapps_registry
 Stasis application container. More...
 
static const struct ast_module_infoast_module_info = &__mod_info
 
struct event_sources event_sources = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
 
static const struct ast_datastore_info masquerade_store_info
 
static const struct ast_datastore_info replace_channel_store_info
 
struct ast_datastore_info set_end_published_info
 
static const struct ast_datastore_info stasis_internal_channel_info
 

Detailed Description

Stasis application support.

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

res_stasis.so brings together the various components of the Stasis application infrastructure.

First, there's the Stasis application handler, stasis_app_exec(). This is called by app_stasis.so to give control of a channel to the Stasis application code from the dialplan.

While a channel is in stasis_app_exec(), it has a stasis_app_control object, which may be used to control the channel.

To control the channel, commands may be sent to channel using stasis_app_send_command() and stasis_app_send_async_command().

Alongside this, applications may be registered/unregistered using stasis_app_register()/stasis_app_unregister(). While a channel is in Stasis, events received on the channel's topic are converted to JSON and forwarded to the stasis_app_cb. The application may also subscribe to the channel to continue to receive messages even after the channel has left Stasis, but it will not be able to control it.

Given all the stuff that comes together in this module, it's been broken up into several pieces that are in res/stasis/ and compiled into res_stasis.so.

Definition in file res_stasis.c.

Macro Definition Documentation

◆ APPS_NUM_BUCKETS

#define APPS_NUM_BUCKETS   127

Number of buckets for the Stasis application hash table. Remember to keep it a prime number!

Definition at line 83 of file res_stasis.c.

◆ BRIDGES_NUM_BUCKETS

#define BRIDGES_NUM_BUCKETS   127

Number of buckets for the Stasis bridges hash table. Remember to keep it a prime number!

Definition at line 95 of file res_stasis.c.

◆ CONTROLS_NUM_BUCKETS

#define CONTROLS_NUM_BUCKETS   127

Number of buckets for the Stasis application hash table. Remember to keep it a prime number!

Definition at line 89 of file res_stasis.c.

◆ MAX_WAIT_MS

#define MAX_WAIT_MS   200

Time to wait for a frame in the application

Definition at line 77 of file res_stasis.c.

Typedef Documentation

◆ app_subscription_handler

typedef enum stasis_app_subscribe_res(* app_subscription_handler) (struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)

Definition at line 1976 of file res_stasis.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 2459 of file res_stasis.c.

◆ __stasis_app_register()

static int __stasis_app_register ( const char *  app_name,
stasis_app_cb  handler,
void *  data,
int  all_events 
)
static

Definition at line 1787 of file res_stasis.c.

1788{
1789 RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
1790
1791 if (!apps_registry) {
1792 return -1;
1793 }
1794
1797 if (app) {
1798 /*
1799 * We need to unlock the apps_registry before calling app_update to
1800 * prevent the possibility of a deadlock with the session.
1801 */
1803 app_update(app, handler, data);
1804 cleanup();
1805 return 0;
1806 }
1807
1809 if (!app) {
1811 return -1;
1812 }
1813
1814 if (all_events) {
1815 struct stasis_app_event_source *source;
1816
1819 if (!source->subscribe) {
1820 continue;
1821 }
1822
1823 source->subscribe(app, NULL);
1824 }
1826 }
1828
1830
1831 /* We lazily clean up the apps_registry, because it's good enough to
1832 * prevent memory leaks, and we're lazy.
1833 */
1834 cleanup();
1835 return 0;
1836}
static const char app[]
Definition: app_adsiprog.c:56
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_link_flags(container, obj, flags)
Add an object to a container.
Definition: astobj2.h:1554
#define ao2_find(container, arg, flags)
Definition: astobj2.h:1736
#define ao2_unlock(a)
Definition: astobj2.h:729
#define ao2_lock(a)
Definition: astobj2.h:717
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition: astobj2.h:1063
@ OBJ_SEARCH_KEY
The arg parameter is a search key, but is not an object.
Definition: astobj2.h:1101
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:78
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:151
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
const char * app_name(struct ast_app *app)
Definition: pbx_app.c:463
void app_update(struct stasis_app *app, stasis_app_cb handler, void *data)
Update the handler and data for a res_stasis application.
struct stasis_app * app_create(const char *name, stasis_app_cb handler, void *data, enum stasis_app_subscription_model subscription_model)
Create a res_stasis application.
@ STASIS_APP_SUBSCRIBE_MANUAL
An application must manually subscribe to each resource that it cares about. This is the default appr...
@ STASIS_APP_SUBSCRIBE_ALL
An application is automatically subscribed to all resources in Asterisk, even if it does not control ...
static void cleanup(void)
Clean up any old apps that we don't need any more.
Definition: res_stasis.c:327
struct ao2_container * apps_registry
Stasis application container.
Definition: res_stasis.c:100
#define NULL
Definition: resample.c:96
Event source information and callbacks.
Definition: stasis_app.h:184
struct stasis_app_event_source * next
Definition: stasis_app.h:237
int(* subscribe)(struct stasis_app *app, void *obj)
Subscribe an application to an event source.
Definition: stasis_app.h:206
static void handler(const char *name, int response_code, struct ast_variable *get_params, struct ast_variable *path_vars, struct ast_variable *headers, struct ast_json *body, struct ast_ari_response *response)
Definition: test_ari.c:59
#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, ao2_find, ao2_link_flags, ao2_lock, ao2_unlock, app, app_create(), app_name(), app_update(), apps_registry, AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, cleanup(), handler(), stasis_app_event_source::next, NULL, OBJ_NOLOCK, OBJ_SEARCH_KEY, RAII_VAR, STASIS_APP_SUBSCRIBE_ALL, STASIS_APP_SUBSCRIBE_MANUAL, and stasis_app_event_source::subscribe.

Referenced by stasis_app_register(), and stasis_app_register_all().

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 2459 of file res_stasis.c.

◆ add_masquerade_store()

static int add_masquerade_store ( struct ast_channel chan)
static

Definition at line 1262 of file res_stasis.c.

1263{
1264 struct ast_datastore *datastore;
1265
1266 SCOPED_CHANNELLOCK(lock, chan);
1268 return 0;
1269 }
1270
1272 if (!datastore) {
1273 return -1;
1274 }
1275
1276 ast_channel_datastore_add(chan, datastore);
1277
1278 return 0;
1279}
ast_mutex_t lock
Definition: app_sla.c:337
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition: channel.c:2354
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:2368
#define ast_datastore_alloc(info, uid)
Definition: datastore.h:85
#define SCOPED_CHANNELLOCK(varname, chan)
scoped lock specialization for channels.
Definition: lock.h:626
static const struct ast_datastore_info masquerade_store_info
Definition: res_stasis.c:1250
Structure for a data store object.
Definition: datastore.h:64

References ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, lock, masquerade_store_info, NULL, and SCOPED_CHANNELLOCK.

Referenced by stasis_app_exec().

◆ app_compare()

static int app_compare ( void *  obj,
void *  arg,
int  flags 
)
static

AO2 comparison function for app

Definition at line 208 of file res_stasis.c.

209{
210 const struct stasis_app *object_left = obj;
211 const struct stasis_app *object_right = arg;
212 const char *right_key = arg;
213 int cmp;
214
215 switch (flags & OBJ_SEARCH_MASK) {
217 right_key = stasis_app_name(object_right);
218 /* Fall through */
219 case OBJ_SEARCH_KEY:
220 cmp = strcmp(stasis_app_name(object_left), right_key);
221 break;
223 /*
224 * We could also use a partial key struct containing a length
225 * so strlen() does not get called for every comparison instead.
226 */
227 cmp = strncmp(stasis_app_name(object_left), right_key, strlen(right_key));
228 break;
229 default:
230 /*
231 * What arg points to is specific to this traversal callback
232 * and has no special meaning to astobj2.
233 */
234 cmp = 0;
235 break;
236 }
237 if (cmp) {
238 return 0;
239 }
240 /*
241 * At this point the traversal callback is identical to a sorted
242 * container.
243 */
244 return CMP_MATCH;
245}
@ CMP_MATCH
Definition: astobj2.h:1027
@ OBJ_SEARCH_PARTIAL_KEY
The arg parameter is a partial search key similar to OBJ_SEARCH_KEY.
Definition: astobj2.h:1116
@ OBJ_SEARCH_OBJECT
The arg parameter is an object of the same type.
Definition: astobj2.h:1087
@ OBJ_SEARCH_MASK
Search option field mask.
Definition: astobj2.h:1072
const char * stasis_app_name(const struct stasis_app *app)
Retrieve an application's name.

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and stasis_app_name().

Referenced by load_module().

◆ app_event_source_find()

static struct stasis_app_event_source * app_event_source_find ( const char *  uri)
static

Definition at line 1976 of file res_stasis.c.

1977{
1978 struct stasis_app_event_source *source;
1979
1982 if (ast_begins_with(uri, source->scheme)) {
1983 break;
1984 }
1985 }
1987
1988 return source;
1989}
static int force_inline attribute_pure ast_begins_with(const char *str, const char *prefix)
Checks whether a string begins with another.
Definition: strings.h:97
const char * scheme
The scheme to match against on [un]subscribes.
Definition: stasis_app.h:186

References ast_begins_with(), AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, stasis_app_event_source::next, and stasis_app_event_source::scheme.

Referenced by app_handle_subscriptions().

◆ app_event_sources_to_json()

static struct ast_json * app_event_sources_to_json ( const struct stasis_app app,
struct ast_json json 
)
static

Definition at line 1929 of file res_stasis.c.

1931{
1932 struct stasis_app_event_source *source;
1933
1936 if (source->to_json) {
1937 source->to_json(app, json);
1938 }
1939 }
1941
1942 return json;
1943}
void(* to_json)(const struct stasis_app *app, struct ast_json *json)
Convert event source data to json.
Definition: stasis_app.h:234

References app, AST_LIST_TRAVERSE, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, stasis_app_event_source::next, and stasis_app_event_source::to_json.

Referenced by stasis_app_object_to_json().

◆ app_get_replace_channel_app()

char * app_get_replace_channel_app ( struct ast_channel chan)

Get the app that the replacement channel will be controlled by.

Parameters
chanThe channel on which this will be set
Return values
NULLon error
Returns
the name of the controlling app (must be ast_free()d)

Definition at line 1012 of file res_stasis.c.

1013{
1015 char *replace_channel_app;
1016
1017 if (!replace) {
1018 return NULL;
1019 }
1020
1021 replace_channel_app = replace->app;
1022 replace->app = NULL;
1023
1024 return replace_channel_app;
1025}
static int replace(struct ast_channel *chan, const char *cmd, char *data, struct ast_str **buf, ssize_t len)
Definition: func_strings.c:980
static struct replace_channel_store * get_replace_channel_store(struct ast_channel *chan, int no_create)
Definition: res_stasis.c:935

References get_replace_channel_store(), NULL, and replace().

Referenced by bridge_stasis_run_cb().

◆ app_handle_subscriptions()

static enum stasis_app_subscribe_res app_handle_subscriptions ( const char *  app_name,
const char **  event_source_uris,
int  event_sources_count,
struct ast_json **  json,
app_subscription_handler  handler 
)
static

Definition at line 2018 of file res_stasis.c.

2022{
2024 int i;
2025
2027
2028 if (!app) {
2030 }
2031
2032 for (i = 0; i < event_sources_count; ++i) {
2033 const char *uri = event_source_uris[i];
2034 struct stasis_app_event_source *event_source;
2035 enum stasis_app_subscribe_res res;
2036
2037 event_source = app_event_source_find(uri);
2038 if (!event_source) {
2039 ast_log(LOG_WARNING, "Invalid scheme: %s\n", uri);
2040 ao2_ref(app, -1);
2041
2043 }
2044
2045 res = handler(app, uri, event_source);
2046 if (res != STASIS_ASR_OK) {
2047 ao2_ref(app, -1);
2048
2049 return res;
2050 }
2051 }
2052
2053 if (json) {
2054 ast_debug(3, "%s: Successful; setting results\n", app_name);
2056 }
2057
2058 ao2_ref(app, -1);
2059
2060 return STASIS_ASR_OK;
2061}
#define ast_log
Definition: astobj2.c:42
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_WARNING
struct ast_json * stasis_app_object_to_json(struct stasis_app *app)
Return the JSON representation of a Stasis application.
Definition: res_stasis.c:1945
static struct stasis_app * find_app_by_name(const char *app_name)
Definition: res_stasis.c:1727
static struct stasis_app_event_source * app_event_source_find(const char *uri)
Definition: res_stasis.c:1976
stasis_app_subscribe_res
Return code for stasis_app_[un]subscribe.
Definition: stasis_app.h:292
@ STASIS_ASR_OK
Definition: stasis_app.h:293
@ STASIS_ASR_EVENT_SOURCE_BAD_SCHEME
Definition: stasis_app.h:296
@ STASIS_ASR_APP_NOT_FOUND
Definition: stasis_app.h:294
#define ast_assert(a)
Definition: utils.h:739

References ao2_ref, app, app_event_source_find(), app_name(), ast_assert, ast_debug, ast_log, find_app_by_name(), handler(), LOG_WARNING, NULL, stasis_app_object_to_json(), STASIS_ASR_APP_NOT_FOUND, STASIS_ASR_EVENT_SOURCE_BAD_SCHEME, and STASIS_ASR_OK.

Referenced by stasis_app_subscribe(), and stasis_app_unsubscribe().

◆ app_hash()

static int app_hash ( const void *  obj,
const int  flags 
)
static

AO2 hash function for app

Definition at line 186 of file res_stasis.c.

187{
188 const struct stasis_app *app;
189 const char *key;
190
191 switch (flags & OBJ_SEARCH_MASK) {
192 case OBJ_SEARCH_KEY:
193 key = obj;
194 break;
196 app = obj;
197 key = stasis_app_name(app);
198 break;
199 default:
200 /* Hash can only work on something with a full key. */
201 ast_assert(0);
202 return 0;
203 }
204 return ast_str_hash(key);
205}
static force_inline int attribute_pure ast_str_hash(const char *str)
Compute a hash value on a string.
Definition: strings.h:1259

References app, ast_assert, ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and stasis_app_name().

Referenced by load_module().

◆ app_send_end_msg()

int app_send_end_msg ( struct stasis_app app,
struct ast_channel chan 
)

Send StasisEnd message to the listening app.

Parameters
appThe app that owns the channel
chanThe channel for which the message is being sent
Return values
zeroon success
Returns
non-zero on failure

Definition at line 1128 of file res_stasis.c.

1129{
1131 struct ast_json *blob;
1132 struct stasis_message *msg;
1133
1134 if (sanitize && sanitize->channel
1135 && sanitize->channel(chan)) {
1136 return 0;
1137 }
1138
1139 blob = ast_json_pack("{s: s, s: o}",
1140 "app", stasis_app_name(app),
1141 "timestamp", ast_json_timeval(ast_tvnow(), NULL)
1142 );
1143 if (!blob) {
1144 ast_log(LOG_ERROR, "Error packing JSON for StasisEnd message\n");
1145 return -1;
1146 }
1147
1150 msg = ast_channel_blob_create(chan, end_message_type(), blob);
1151 if (msg) {
1153 }
1154 ao2_cleanup(msg);
1155 ast_json_unref(blob);
1156
1157 return 0;
1158}
struct stasis_message * ast_channel_blob_create(struct ast_channel *chan, struct stasis_message_type *type, struct ast_json *blob)
Creates a ast_channel_blob message.
#define LOG_ERROR
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition: json.c:612
struct ast_json * ast_json_timeval(const struct timeval tv, const char *zone)
Construct a timeval as JSON.
Definition: json.c:670
int app_unsubscribe_channel(struct stasis_app *app, struct ast_channel *chan)
Cancel the subscription an app has for a channel.
struct stasis_message_sanitizer * stasis_app_get_sanitizer(void)
Get the Stasis message sanitizer for app_stasis applications.
Definition: res_stasis.c:2343
static void remove_masquerade_store(struct ast_channel *chan)
Definition: res_stasis.c:1281
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic's subscribers.
Definition: stasis.c:1538
struct stasis_topic * ast_app_get_topic(struct stasis_app *app)
Returns the stasis topic for an app.
Abstract JSON element (object, array, string, int, ...).
Structure containing callbacks for Stasis message sanitization.
Definition: stasis.h:200
int(* channel)(const struct ast_channel *chan)
Callback which determines whether a channel should be sanitized from a message based on the channel.
Definition: stasis.h:232
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159

References ao2_cleanup, app, app_unsubscribe_channel(), ast_app_get_topic(), ast_channel_blob_create(), ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_log, ast_tvnow(), stasis_message_sanitizer::channel, LOG_ERROR, NULL, remove_masquerade_store(), stasis_app_get_sanitizer(), stasis_app_name(), and stasis_publish().

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

◆ app_set_replace_channel_app()

int app_set_replace_channel_app ( struct ast_channel chan,
const char *  replace_app 
)

Set the app that the replacement channel will be controlled by.

Parameters
chanThe channel on which this will be set
replace_appThe app that will be controlling this channel
Return values
zerosuccess
non-zerofailure

Definition at line 976 of file res_stasis.c.

977{
979
980 if (!replace) {
981 return -1;
982 }
983
984 ast_free(replace->app);
985 replace->app = NULL;
986
987 if (replace_app) {
988 replace->app = ast_strdup(replace_app);
989 if (!replace->app) {
990 return -1;
991 }
992 }
993
994 return 0;
995}
#define ast_free(a)
Definition: astmm.h:180
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241

References ast_free, ast_strdup, get_replace_channel_store(), NULL, and replace().

Referenced by bridge_stasis_push_peek().

◆ app_set_replace_channel_snapshot()

int app_set_replace_channel_snapshot ( struct ast_channel chan,
struct ast_channel_snapshot replace_snapshot 
)

Set the snapshot of the channel that this channel will replace.

Parameters
chanThe channel on which this will be set
replace_snapshotThe snapshot of the channel that is being replaced
Return values
zerosuccess
non-zerofailure

Definition at line 964 of file res_stasis.c.

965{
967
968 if (!replace) {
969 return -1;
970 }
971
972 ao2_replace(replace->snapshot, replace_snapshot);
973 return 0;
974}
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
Definition: astobj2.h:501

References ao2_replace, get_replace_channel_store(), and replace().

Referenced by bridge_stasis_push_peek().

◆ app_subscribe()

static enum stasis_app_subscribe_res app_subscribe ( struct stasis_app app,
const char *  uri,
struct stasis_app_event_source event_source 
)
static

Definition at line 2098 of file res_stasis.c.

2101{
2102 const char *app_name = stasis_app_name(app);
2103 RAII_VAR(void *, obj, NULL, ao2_cleanup);
2104
2105 ast_debug(3, "%s: Checking %s\n", app_name, uri);
2106
2107 if (!ast_strlen_zero(uri + strlen(event_source->scheme)) &&
2108 (!event_source->find || (!(obj = event_source->find(app, uri + strlen(event_source->scheme)))))) {
2109 ast_log(LOG_WARNING, "Event source not found: %s\n", uri);
2111 }
2112
2113 ast_debug(3, "%s: Subscribing to %s\n", app_name, uri);
2114
2115 if (!event_source->subscribe || (event_source->subscribe(app, obj))) {
2116 ast_log(LOG_WARNING, "Error subscribing app '%s' to '%s'\n",
2117 app_name, uri);
2119 }
2120
2121 return STASIS_ASR_OK;
2122}
@ STASIS_ASR_INTERNAL_ERROR
Definition: stasis_app.h:297
@ STASIS_ASR_EVENT_SOURCE_NOT_FOUND
Definition: stasis_app.h:295
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
void *(* find)(const struct stasis_app *app, const char *id)
Find an event source data object by the given id/name.
Definition: stasis_app.h:196

References ao2_cleanup, app, app_name(), ast_debug, ast_log, ast_strlen_zero(), stasis_app_event_source::find, LOG_WARNING, NULL, RAII_VAR, stasis_app_event_source::scheme, stasis_app_name(), STASIS_ASR_EVENT_SOURCE_NOT_FOUND, STASIS_ASR_INTERNAL_ERROR, STASIS_ASR_OK, and stasis_app_event_source::subscribe.

Referenced by stasis_app_subscribe().

◆ app_unsubscribe()

static enum stasis_app_subscribe_res app_unsubscribe ( struct stasis_app app,
const char *  uri,
struct stasis_app_event_source event_source 
)
static

Definition at line 2143 of file res_stasis.c.

2146{
2147 const char *app_name = stasis_app_name(app);
2148 const char *id = uri + strlen(event_source->scheme);
2149
2150 if (!event_source->is_subscribed ||
2151 (!event_source->is_subscribed(app, id))) {
2153 }
2154
2155 ast_debug(3, "%s: Unsubscribing from %s\n", app_name, uri);
2156
2157 if (!event_source->unsubscribe || (event_source->unsubscribe(app, id))) {
2158 ast_log(LOG_WARNING, "Error unsubscribing app '%s' to '%s'\n",
2159 app_name, uri);
2160 return -1;
2161 }
2162 return 0;
2163}
int(* unsubscribe)(struct stasis_app *app, const char *id)
Cancel the subscription an app has to an event source.
Definition: stasis_app.h:216
int(* is_subscribed)(struct stasis_app *app, const char *id)
Find an event source by the given id/name.
Definition: stasis_app.h:226

References app, app_name(), ast_debug, ast_log, stasis_app_event_source::is_subscribed, LOG_WARNING, stasis_app_event_source::scheme, stasis_app_name(), STASIS_ASR_EVENT_SOURCE_NOT_FOUND, and stasis_app_event_source::unsubscribe.

Referenced by stasis_app_unsubscribe().

◆ append_name()

static int append_name ( void *  obj,
void *  arg,
int  flags 
)
static

Definition at line 1760 of file res_stasis.c.

1761{
1762 struct stasis_app *app = obj;
1763 struct ao2_container *apps = arg;
1764
1766 return 0;
1767}
int ast_str_container_add(struct ao2_container *str_container, const char *add)
Adds a string to a string container allocated by ast_str_container_alloc.
Definition: strings.c:205
Generic container type.
Registered applications container.
Definition: pbx_app.c:68

References app, ast_str_container_add(), and stasis_app_name().

Referenced by stasis_app_get_all().

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 2459 of file res_stasis.c.

◆ bridge_create_common()

static struct ast_bridge * bridge_create_common ( const char *  type,
const char *  name,
const char *  id,
int  invisible 
)
static

Definition at line 821 of file res_stasis.c.

822{
823 struct ast_bridge *bridge;
824 char *requested_type, *requested_types = ast_strdupa(S_OR(type, "mixing"));
825 int capabilities = 0;
830 int send_sdp_label = 0;
831
832 ast_debug(1, "Creating bridge of type '%s' with name '%s' and id '%s'\n",
833 type, S_OR(name, "<unknown>"), S_OR(id, "<unknown>"));
834 if (invisible) {
836 }
837
838 if (!ast_strlen_zero(id)) {
839 bridge = stasis_app_bridge_find_by_id(id);
840 if (bridge) {
841 ast_log(LOG_WARNING, "Bridge with id '%s' already exists\n", id);
842 ao2_ref(bridge, -1);
843 return NULL;
844 }
845 }
846
847 while ((requested_type = strsep(&requested_types, ","))) {
848 requested_type = ast_strip(requested_type);
849
850 if (!strcmp(requested_type, "mixing")) {
851 capabilities |= STASIS_BRIDGE_MIXING_CAPABILITIES;
852 flags |= AST_BRIDGE_FLAG_SMART;
853 } else if (!strcmp(requested_type, "holding")) {
854 capabilities |= AST_BRIDGE_CAPABILITY_HOLDING;
855 } else if (!strcmp(requested_type, "dtmf_events") ||
856 !strcmp(requested_type, "proxy_media")) {
857 capabilities &= ~AST_BRIDGE_CAPABILITY_NATIVE;
858 } else if (!strcmp(requested_type, "video_sfu")) {
859 video_mode = AST_BRIDGE_VIDEO_MODE_SFU;
860 } else if (!strcmp(requested_type, "video_single")) {
862 } else if (!strcmp(requested_type, "sdp_label")) {
863 send_sdp_label = 1;
864 }
865 }
866
867 /* For an SFU video bridge we ensure it always remains in multimix for the best experience. */
868 if (video_mode == AST_BRIDGE_VIDEO_MODE_SFU) {
869 capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
870 flags &= ~AST_BRIDGE_FLAG_SMART;
871 }
872
873 if (!capabilities
874 /* Holding and mixing capabilities don't mix. */
875 || ((capabilities & AST_BRIDGE_CAPABILITY_HOLDING)
876 && (capabilities & (STASIS_BRIDGE_MIXING_CAPABILITIES)))) {
877 return NULL;
878 }
879
880 bridge = bridge_stasis_new(capabilities, flags, name, id, video_mode, send_sdp_label);
881 if (bridge) {
882 if (!ao2_link(app_bridges, bridge)) {
883 ast_bridge_destroy(bridge, 0);
884 bridge = NULL;
885 }
886 }
887
888 return bridge;
889}
char * strsep(char **str, const char *delims)
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ao2_link(container, obj)
Add an object to a container.
Definition: astobj2.h:1532
int ast_bridge_destroy(struct ast_bridge *bridge, int cause)
Destroy a bridge.
Definition: bridge.c:1009
@ AST_BRIDGE_CAPABILITY_MULTIMIX
Definition: bridge.h:98
@ AST_BRIDGE_CAPABILITY_HOLDING
Definition: bridge.h:90
ast_bridge_video_mode_type
Video source modes.
Definition: bridge.h:102
@ AST_BRIDGE_VIDEO_MODE_SINGLE_SRC
Definition: bridge.h:106
@ AST_BRIDGE_VIDEO_MODE_TALKER_SRC
Definition: bridge.h:109
@ AST_BRIDGE_VIDEO_MODE_SFU
Definition: bridge.h:113
@ AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY
@ AST_BRIDGE_FLAG_SWAP_INHIBIT_TO
@ AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM
@ AST_BRIDGE_FLAG_MERGE_INHIBIT_TO
@ AST_BRIDGE_FLAG_SMART
@ AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM
@ AST_BRIDGE_FLAG_INVISIBLE
static const char type[]
Definition: chan_ooh323.c:109
static const char name[]
Definition: format_mp3.c:68
struct ast_bridge * stasis_app_bridge_find_by_id(const char *bridge_id)
Returns the bridge with the given id.
Definition: res_stasis.c:800
struct ao2_container * app_bridges
Definition: res_stasis.c:104
struct ast_bridge * bridge_stasis_new(uint32_t capabilities, unsigned int flags, const char *name, const char *id, enum ast_bridge_video_mode_type video_mode, unsigned int send_sdp_label)
#define STASIS_BRIDGE_MIXING_CAPABILITIES
Definition: stasis_bridge.h:39
#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
char * ast_strip(char *s)
Strip leading/trailing whitespace from a string.
Definition: strings.h:223
Structure that contains information about a bridge.
Definition: bridge.h:353

References ao2_link, ao2_ref, app_bridges, AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_CAPABILITY_MULTIMIX, ast_bridge_destroy(), AST_BRIDGE_FLAG_INVISIBLE, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SMART, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, AST_BRIDGE_FLAG_SWAP_INHIBIT_TO, AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY, AST_BRIDGE_VIDEO_MODE_SFU, AST_BRIDGE_VIDEO_MODE_SINGLE_SRC, AST_BRIDGE_VIDEO_MODE_TALKER_SRC, ast_debug, ast_log, ast_strdupa, ast_strip(), ast_strlen_zero(), bridge_stasis_new(), LOG_WARNING, name, NULL, S_OR, stasis_app_bridge_find_by_id(), STASIS_BRIDGE_MIXING_CAPABILITIES, strsep(), and type.

Referenced by stasis_app_bridge_create(), and stasis_app_bridge_create_invisible().

◆ bridge_moh_create()

static struct ast_channel * bridge_moh_create ( struct ast_bridge bridge)
static

Definition at line 600 of file res_stasis.c.

601{
602 struct stasis_app_bridge_channel_wrapper *new_wrapper;
603 struct ast_channel *chan;
604 pthread_t threadid;
605
607 if (!chan) {
608 return NULL;
609 }
610
612 ast_hangup(chan);
613 return NULL;
614 }
615
618 ast_hangup(chan);
619 return NULL;
620 }
621
622 new_wrapper = ao2_alloc_options(sizeof(*new_wrapper),
624 if (!new_wrapper) {
625 ast_hangup(chan);
626 return NULL;
627 }
628
630 || ast_string_field_set(new_wrapper, bridge_id, bridge->uniqueid)
631 || ast_string_field_set(new_wrapper, channel_id, ast_channel_uniqueid(chan))) {
632 ao2_ref(new_wrapper, -1);
633 ast_hangup(chan);
634 return NULL;
635 }
636
637 if (!ao2_link_flags(app_bridges_moh, new_wrapper, OBJ_NOLOCK)) {
638 ao2_ref(new_wrapper, -1);
639 ast_hangup(chan);
640 return NULL;
641 }
642
643 /* Pass the new_wrapper ref to moh_channel_thread() */
644 if (ast_pthread_create_detached(&threadid, NULL, moh_channel_thread, new_wrapper)) {
645 ast_log(LOG_ERROR, "Failed to create channel thread. Abandoning MOH channel creation.\n");
647 ao2_ref(new_wrapper, -1);
648 ast_hangup(chan);
649 return NULL;
650 }
651
652 return chan;
653}
@ AO2_ALLOC_OPT_LOCK_NOLOCK
Definition: astobj2.h:367
#define ao2_unlink_flags(container, obj, flags)
Remove an object from a container.
Definition: astobj2.h:1600
#define ao2_alloc_options(data_size, destructor_fn, options)
Definition: astobj2.h:404
@ AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE
@ AST_BRIDGE_CHANNEL_FLAG_LONELY
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition: channel.c:2510
const char * ast_channel_uniqueid(const struct ast_channel *chan)
#define AST_CHANNEL_NAME
Definition: channel.h:173
int ast_unreal_channel_push_to_bridge(struct ast_channel *ast, struct ast_bridge *bridge, unsigned int flags)
Push the semi2 unreal channel into a bridge from either member of the unreal pair.
Definition: core_unreal.c:928
static void stasis_app_bridge_channel_wrapper_destructor(void *obj)
Definition: res_stasis.c:481
struct ao2_container * app_bridges_moh
Definition: res_stasis.c:106
int stasis_app_channel_unreal_set_internal(struct ast_channel *chan)
Mark this unreal channel and it's other half as being internal to Stasis.
Definition: res_stasis.c:2367
static struct ast_channel * prepare_bridge_moh_channel(void)
Definition: res_stasis.c:536
static void * moh_channel_thread(void *data)
Definition: res_stasis.c:555
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
const ast_string_field uniqueid
Definition: bridge.h:405
Main Channel structure associated with a channel.
struct ast_bridge * bridge
#define ast_pthread_create_detached(a, b, c, d)
Definition: utils.h:588
#define AST_UUID_STR_LEN
Definition: uuid.h:27

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_link_flags, ao2_ref, ao2_unlink_flags, app_bridges_moh, AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE, AST_BRIDGE_CHANNEL_FLAG_LONELY, AST_CHANNEL_NAME, ast_channel_uniqueid(), ast_hangup(), ast_log, ast_pthread_create_detached, ast_string_field_init, ast_string_field_set, ast_unreal_channel_push_to_bridge(), AST_UUID_STR_LEN, ast_channel::bridge, LOG_ERROR, moh_channel_thread(), NULL, OBJ_NOLOCK, prepare_bridge_moh_channel(), stasis_app_bridge_channel_wrapper_destructor(), stasis_app_channel_unreal_set_internal(), and ast_bridge::uniqueid.

Referenced by stasis_app_bridge_moh_channel().

◆ bridges_channel_compare()

static int bridges_channel_compare ( void *  obj,
void *  arg,
int  flags 
)
static

AO2 comparison function for bridges moh container

Definition at line 455 of file res_stasis.c.

456{
457 const struct stasis_app_bridge_channel_wrapper *object_left = obj;
458 const struct stasis_app_bridge_channel_wrapper *object_right = arg;
459 const char *right_key = arg;
460 int cmp;
461
462 switch (flags & OBJ_SEARCH_MASK) {
464 right_key = object_right->bridge_id;
465 case OBJ_SEARCH_KEY:
466 cmp = strcmp(object_left->bridge_id, right_key);
467 break;
469 cmp = strncmp(object_left->bridge_id, right_key, strlen(right_key));
470 break;
471 default:
472 cmp = 0;
473 break;
474 }
475 if (cmp) {
476 return 0;
477 }
478 return CMP_MATCH;
479}
const ast_string_field bridge_id
Definition: res_stasis.c:451

References stasis_app_bridge_channel_wrapper::bridge_id, CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

◆ bridges_channel_hash_fn()

static int bridges_channel_hash_fn ( const void *  obj,
const int  flags 
)
static

AO2 hash function for the bridges moh container

Definition at line 488 of file res_stasis.c.

489{
490 const struct stasis_app_bridge_channel_wrapper *wrapper;
491 const char *key;
492
493 switch (flags & OBJ_SEARCH_MASK) {
494 case OBJ_SEARCH_KEY:
495 key = obj;
496 break;
498 wrapper = obj;
499 key = wrapper->bridge_id;
500 break;
501 default:
502 /* Hash can only work on something with a full key. */
503 ast_assert(0);
504 return 0;
505 }
506 return ast_str_hash(key);
507}

References ast_assert, ast_str_hash(), stasis_app_bridge_channel_wrapper::bridge_id, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by load_module().

◆ bridges_channel_sort_fn()

static int bridges_channel_sort_fn ( const void *  obj_left,
const void *  obj_right,
const int  flags 
)
static

Definition at line 509 of file res_stasis.c.

510{
511 const struct stasis_app_bridge_channel_wrapper *left = obj_left;
512 const struct stasis_app_bridge_channel_wrapper *right = obj_right;
513 const char *right_key = obj_right;
514 int cmp;
515
516 switch (flags & OBJ_SEARCH_MASK) {
518 right_key = right->bridge_id;
519 /* Fall through */
520 case OBJ_SEARCH_KEY:
521 cmp = strcmp(left->bridge_id, right_key);
522 break;
524 cmp = strncmp(left->bridge_id, right_key, strlen(right_key));
525 break;
526 default:
527 /* Sort can only work on something with a full or partial key. */
528 ast_assert(0);
529 cmp = 0;
530 break;
531 }
532 return cmp;
533}

References ast_assert, stasis_app_bridge_channel_wrapper::bridge_id, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

◆ bridges_compare()

static int bridges_compare ( void *  obj,
void *  arg,
int  flags 
)
static

AO2 comparison function for bridges container

Definition at line 378 of file res_stasis.c.

379{
380 const struct ast_bridge *object_left = obj;
381 const struct ast_bridge *object_right = arg;
382 const char *right_key = arg;
383 int cmp;
384
385 switch (flags & OBJ_SEARCH_MASK) {
387 right_key = object_right->uniqueid;
388 /* Fall through */
389 case OBJ_SEARCH_KEY:
390 cmp = strcmp(object_left->uniqueid, right_key);
391 break;
393 /*
394 * We could also use a partial key struct containing a length
395 * so strlen() does not get called for every comparison instead.
396 */
397 cmp = strncmp(object_left->uniqueid, right_key, strlen(right_key));
398 break;
399 default:
400 /*
401 * What arg points to is specific to this traversal callback
402 * and has no special meaning to astobj2.
403 */
404 cmp = 0;
405 break;
406 }
407 if (cmp) {
408 return 0;
409 }
410 /*
411 * At this point the traversal callback is identical to a sorted
412 * container.
413 */
414 return CMP_MATCH;
415}

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and ast_bridge::uniqueid.

Referenced by load_module().

◆ bridges_hash()

static int bridges_hash ( const void *  obj,
const int  flags 
)
static

AO2 hash function for bridges container

Definition at line 356 of file res_stasis.c.

357{
358 const struct ast_bridge *bridge;
359 const char *key;
360
361 switch (flags & OBJ_SEARCH_MASK) {
362 case OBJ_SEARCH_KEY:
363 key = obj;
364 break;
366 bridge = obj;
367 key = bridge->uniqueid;
368 break;
369 default:
370 /* Hash can only work on something with a full key. */
371 ast_assert(0);
372 return 0;
373 }
374 return ast_str_hash(key);
375}

References ast_assert, ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and ast_bridge::uniqueid.

Referenced by load_module().

◆ bridges_sort()

static int bridges_sort ( const void *  left,
const void *  right,
const int  flags 
)
static

AO2 sort function for bridges container

Definition at line 418 of file res_stasis.c.

419{
420 const struct ast_bridge *object_left = left;
421 const struct ast_bridge *object_right = right;
422 const char *right_key = right;
423 int cmp;
424
425 switch (flags & OBJ_SEARCH_MASK) {
427 right_key = object_right->uniqueid;
428 /* Fall through */
429 case OBJ_SEARCH_KEY:
430 cmp = strcmp(object_left->uniqueid, right_key);
431 break;
433 cmp = strncmp(object_left->uniqueid, right_key, strlen(right_key));
434 break;
435 default:
436 ast_assert(0);
437 cmp = 0;
438 break;
439 }
440 return cmp;
441}

References ast_assert, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and ast_bridge::uniqueid.

Referenced by load_module().

◆ channel_id_sanitizer()

static int channel_id_sanitizer ( const char *  id)
static

Sanitization callback for channel unique IDs.

Definition at line 2324 of file res_stasis.c.

2325{
2326 struct ast_channel_snapshot *snapshot;
2327 int ret;
2328
2329 snapshot = ast_channel_snapshot_get_latest(id);
2330 ret = channel_snapshot_sanitizer(snapshot);
2331 ao2_cleanup(snapshot);
2332
2333 return ret;
2334}
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,...
static int channel_snapshot_sanitizer(const struct ast_channel_snapshot *snapshot)
Sanitization callback for channel snapshots.
Definition: res_stasis.c:2306
Structure representing a snapshot of channel state.

References ao2_cleanup, ast_channel_snapshot_get_latest(), and channel_snapshot_sanitizer().

◆ channel_replaced_cb()

static void channel_replaced_cb ( void *  data,
struct ast_channel old_chan,
struct ast_channel new_chan 
)
static

Definition at line 1204 of file res_stasis.c.

1205{
1206 RAII_VAR(struct ast_channel_snapshot *, new_snapshot, NULL, ao2_cleanup);
1207 RAII_VAR(struct ast_channel_snapshot *, old_snapshot, NULL, ao2_cleanup);
1208 struct stasis_app_control *control;
1209
1210 /* At this point, new_chan is the channel pointer that is in Stasis() and
1211 * has the unknown channel's name in it while old_chan is the channel pointer
1212 * that is not in Stasis(), but has the guts of the channel that Stasis() knows
1213 * about */
1214
1215 /* grab a snapshot for the channel that is jumping into Stasis() */
1216 new_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(new_chan));
1217 if (!new_snapshot) {
1218 ast_log(LOG_ERROR, "Could not get snapshot for masquerading channel\n");
1219 return;
1220 }
1221
1222 /* grab a snapshot for the channel that has been kicked out of Stasis() */
1223 old_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(old_chan));
1224 if (!old_snapshot) {
1225 ast_log(LOG_ERROR, "Could not get snapshot for masqueraded channel\n");
1226 return;
1227 }
1228
1229 /*
1230 * Find, unlink, and relink control since the channel has a new
1231 * name/uniqueid and its hash has changed.
1232 */
1233 control = ao2_callback(app_controls, OBJ_UNLINK, masq_match_cb, new_chan);
1234 if (!control) {
1235 ast_log(LOG_ERROR, "Could not find control for masquerading channel\n");
1236 return;
1237 }
1238 ao2_link(app_controls, control);
1239
1240
1241 /* send the StasisStart with replace_channel to the app */
1242 send_start_msg_snapshots(new_chan, control_app(control), 0, NULL, new_snapshot,
1243 old_snapshot);
1244 /* send the StasisEnd message to the app */
1245 app_send_end_msg(control_app(control), old_chan);
1246
1247 ao2_cleanup(control);
1248}
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition: astobj2.h:1693
@ OBJ_UNLINK
Definition: astobj2.h:1039
struct stasis_app * control_app(struct stasis_app_control *control)
Returns the pointer (non-reffed) to the app associated with this control.
Definition: control.c:1593
struct ao2_container * app_controls
Definition: res_stasis.c:102
static int send_start_msg_snapshots(struct ast_channel *chan, struct stasis_app *app, int argc, char *argv[], struct ast_channel_snapshot *snapshot, struct ast_channel_snapshot *replace_channel_snapshot)
Definition: res_stasis.c:1036
int app_send_end_msg(struct stasis_app *app, struct ast_channel *chan)
Send StasisEnd message to the listening app.
Definition: res_stasis.c:1128
static int masq_match_cb(void *obj, void *data, int flags)
Definition: res_stasis.c:1160

References ao2_callback, ao2_cleanup, ao2_link, app_controls, app_send_end_msg(), ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_log, control_app(), LOG_ERROR, masq_match_cb(), NULL, OBJ_UNLINK, RAII_VAR, and send_start_msg_snapshots().

◆ channel_sanitizer()

static int channel_sanitizer ( const struct ast_channel chan)
static

Sanitization callback for channels.

Definition at line 2315 of file res_stasis.c.

2316{
2317 if (!chan || !(ast_channel_tech(chan)->properties & AST_CHAN_TP_INTERNAL)) {
2318 return 0;
2319 }
2320 return 1;
2321}
@ AST_CHAN_TP_INTERNAL
Channels with this particular technology are an implementation detail of Asterisk and should generall...
Definition: channel.h:991
const struct ast_channel_tech * ast_channel_tech(const struct ast_channel *chan)

References AST_CHAN_TP_INTERNAL, and ast_channel_tech().

◆ channel_snapshot_sanitizer()

static int channel_snapshot_sanitizer ( const struct ast_channel_snapshot snapshot)
static

Sanitization callback for channel snapshots.

Definition at line 2306 of file res_stasis.c.

2307{
2308 if (!snapshot || !(snapshot->base->tech_properties & AST_CHAN_TP_INTERNAL)) {
2309 return 0;
2310 }
2311 return 1;
2312}
struct ast_channel_snapshot_base * base

References AST_CHAN_TP_INTERNAL, ast_channel_snapshot::base, and ast_channel_snapshot_base::tech_properties.

Referenced by channel_id_sanitizer().

◆ channel_stolen_cb()

static void channel_stolen_cb ( void *  data,
struct ast_channel old_chan,
struct ast_channel new_chan 
)
static

Definition at line 1173 of file res_stasis.c.

1174{
1175 struct stasis_app_control *control;
1176
1177 /*
1178 * At this point, old_chan is the channel pointer that is in Stasis() and
1179 * has the unknown channel's name in it while new_chan is the channel pointer
1180 * that is not in Stasis(), but has the guts of the channel that Stasis() knows
1181 * about.
1182 *
1183 * Find and unlink control since the channel has a new name/uniqueid
1184 * and its hash has changed. Since the channel is leaving stasis don't
1185 * bother putting it back into the container. Nobody is going to
1186 * remove it from the container later.
1187 */
1188 control = ao2_callback(app_controls, OBJ_UNLINK, masq_match_cb, old_chan);
1189 if (!control) {
1190 ast_log(LOG_ERROR, "Could not find control for masqueraded channel\n");
1191 return;
1192 }
1193
1194 /* send the StasisEnd message to the app */
1196 app_send_end_msg(control_app(control), new_chan);
1197
1198 /* remove the datastore */
1199 remove_masquerade_store(old_chan);
1200
1201 ao2_cleanup(control);
1202}
void stasis_app_channel_set_stasis_end_published(struct ast_channel *chan)
Indicate that this channel has had a StasisEnd published for it.
Definition: res_stasis.c:1332

References ao2_callback, ao2_cleanup, app_controls, app_send_end_msg(), ast_log, control_app(), LOG_ERROR, masq_match_cb(), OBJ_UNLINK, remove_masquerade_store(), and stasis_app_channel_set_stasis_end_published().

◆ cleanup()

static void cleanup ( void  )
static

Clean up any old apps that we don't need any more.

Definition at line 327 of file res_stasis.c.

328{
331}
@ OBJ_NODATA
Definition: astobj2.h:1044
@ OBJ_MULTIPLE
Definition: astobj2.h:1049
static int cleanup_cb(void *obj, void *arg, int flags)
Definition: res_stasis.c:309

References ao2_callback, apps_registry, cleanup_cb(), NULL, OBJ_MULTIPLE, OBJ_NODATA, and OBJ_UNLINK.

Referenced by __stasis_app_register(), stasis_app_exec(), stasis_app_unregister(), and unload_module().

◆ cleanup_cb()

static int cleanup_cb ( void *  obj,
void *  arg,
int  flags 
)
static

Definition at line 309 of file res_stasis.c.

310{
311 struct stasis_app *app = obj;
312
313 if (!app_is_finished(app)) {
314 return 0;
315 }
316
317 ast_verb(1, "Shutting down application '%s'\n", stasis_app_name(app));
319
320 return CMP_MATCH;
321
322}
#define ast_verb(level,...)
void app_shutdown(struct stasis_app *app)
Tears down an application.
int app_is_finished(struct stasis_app *app)
Checks whether a deactivated app has no channels.

References app, app_is_finished(), app_shutdown(), ast_verb, CMP_MATCH, and stasis_app_name().

Referenced by ast_sched_clean_by_callback(), and cleanup().

◆ control_compare()

static int control_compare ( void *  obj,
void *  arg,
int  flags 
)
static

AO2 comparison function for stasis_app_control

Definition at line 270 of file res_stasis.c.

271{
272 const struct stasis_app_control *object_left = obj;
273 const struct stasis_app_control *object_right = arg;
274 const char *right_key = arg;
275 int cmp;
276
277 switch (flags & OBJ_SEARCH_MASK) {
279 right_key = stasis_app_control_get_channel_id(object_right);
280 /* Fall through */
281 case OBJ_SEARCH_KEY:
282 cmp = strcmp(stasis_app_control_get_channel_id(object_left), right_key);
283 break;
285 /*
286 * We could also use a partial key struct containing a length
287 * so strlen() does not get called for every comparison instead.
288 */
289 cmp = strncmp(stasis_app_control_get_channel_id(object_left), right_key, strlen(right_key));
290 break;
291 default:
292 /*
293 * What arg points to is specific to this traversal callback
294 * and has no special meaning to astobj2.
295 */
296 cmp = 0;
297 break;
298 }
299 if (cmp) {
300 return 0;
301 }
302 /*
303 * At this point the traversal callback is identical to a sorted
304 * container.
305 */
306 return CMP_MATCH;
307}
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:1460

References CMP_MATCH, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, and stasis_app_control_get_channel_id().

Referenced by load_module().

◆ control_hash()

static int control_hash ( const void *  obj,
const int  flags 
)
static

AO2 hash function for stasis_app_control

Definition at line 248 of file res_stasis.c.

249{
250 const struct stasis_app_control *control;
251 const char *key;
252
253 switch (flags & OBJ_SEARCH_MASK) {
254 case OBJ_SEARCH_KEY:
255 key = obj;
256 break;
258 control = obj;
260 break;
261 default:
262 /* Hash can only work on something with a full key. */
263 ast_assert(0);
264 return 0;
265 }
266 return ast_str_hash(key);
267}

References ast_assert, ast_str_hash(), OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and stasis_app_control_get_channel_id().

Referenced by load_module().

◆ control_unlink()

static void control_unlink ( struct stasis_app_control control)
static

In addition to running ao2_cleanup(), this function also removes the object from the app_controls container.

Definition at line 811 of file res_stasis.c.

812{
813 if (!control) {
814 return;
815 }
816
817 ao2_unlink(app_controls, control);
818 ao2_cleanup(control);
819}
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition: astobj2.h:1578

References ao2_cleanup, ao2_unlink, and app_controls.

Referenced by stasis_app_exec().

◆ find_app_by_name()

static struct stasis_app * find_app_by_name ( const char *  app_name)
static

Definition at line 1727 of file res_stasis.c.

1728{
1729 struct stasis_app *res = NULL;
1730
1731 if (!apps_registry) {
1732 return NULL;
1733 }
1734
1735 if (!ast_strlen_zero(app_name)) {
1737 }
1738
1739 return res;
1740}

References ao2_find, app_name(), apps_registry, ast_strlen_zero(), NULL, and OBJ_SEARCH_KEY.

Referenced by app_handle_subscriptions(), stasis_app_get_by_name(), stasis_app_is_registered(), stasis_app_subscribe_channel(), stasis_app_to_json(), and stasis_app_user_event().

◆ get_replace_channel_snapshot()

static struct ast_channel_snapshot * get_replace_channel_snapshot ( struct ast_channel chan)
static

Definition at line 997 of file res_stasis.c.

998{
1000 struct ast_channel_snapshot *replace_channel_snapshot;
1001
1002 if (!replace) {
1003 return NULL;
1004 }
1005
1006 replace_channel_snapshot = replace->snapshot;
1007 replace->snapshot = NULL;
1008
1009 return replace_channel_snapshot;
1010}

References get_replace_channel_store(), NULL, and replace().

Referenced by send_start_msg().

◆ get_replace_channel_store()

static struct replace_channel_store * get_replace_channel_store ( struct ast_channel chan,
int  no_create 
)
static

Definition at line 935 of file res_stasis.c.

936{
937 struct ast_datastore *datastore;
938 struct replace_channel_store *ret;
939
940 ast_channel_lock(chan);
942 if (!datastore && !no_create) {
944 if (datastore) {
945 ast_channel_datastore_add(chan, datastore);
946 }
947 }
948
949 if (!datastore) {
950 ast_channel_unlock(chan);
951 return NULL;
952 }
953
954 if (!datastore->data) {
955 datastore->data = ast_calloc(1, sizeof(struct replace_channel_store));
956 }
957
958 ret = datastore->data;
959 ast_channel_unlock(chan);
960
961 return ret;
962}
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
#define ast_channel_lock(chan)
Definition: channel.h:2972
#define ast_channel_unlock(chan)
Definition: channel.h:2973
static const struct ast_datastore_info replace_channel_store_info
Definition: res_stasis.c:930
void * data
Definition: datastore.h:66

References ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_datastore::data, NULL, and replace_channel_store_info.

Referenced by app_get_replace_channel_app(), app_set_replace_channel_app(), app_set_replace_channel_snapshot(), and get_replace_channel_snapshot().

◆ has_masquerade_store()

static int has_masquerade_store ( struct ast_channel chan)
static

Definition at line 1256 of file res_stasis.c.

1257{
1258 SCOPED_CHANNELLOCK(lock, chan);
1260}

References ast_channel_datastore_find(), lock, masquerade_store_info, NULL, and SCOPED_CHANNELLOCK.

Referenced by stasis_app_exec().

◆ load_module()

static int load_module ( void  )
static

Definition at line 2416 of file res_stasis.c.

2417{
2418 if (STASIS_MESSAGE_TYPE_INIT(start_message_type) != 0) {
2420 }
2421 if (STASIS_MESSAGE_TYPE_INIT(end_message_type) != 0) {
2423 }
2438 unload_module();
2440 }
2441
2442 if (messaging_init()) {
2443 unload_module();
2445 }
2446
2448
2450
2452}
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition: astobj2.h:363
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition: astobj2.h:1303
@ AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT
Reject objects with duplicate keys in container.
Definition: astobj2.h:1188
int messaging_init(void)
Initialize the messaging layer.
Definition: messaging.c:539
@ AST_MODULE_LOAD_SUCCESS
Definition: module.h:70
@ AST_MODULE_LOAD_DECLINE
Module has failed to load, may be in an inconsistent state.
Definition: module.h:78
struct ao2_container * app_bridges_playback
Definition: res_stasis.c:108
#define BRIDGES_NUM_BUCKETS
Number of buckets for the Stasis bridges hash table. Remember to keep it a prime number!
Definition: res_stasis.c:95
static int bridges_compare(void *obj, void *arg, int flags)
Definition: res_stasis.c:378
static int app_compare(void *obj, void *arg, int flags)
Definition: res_stasis.c:208
static int bridges_hash(const void *obj, const int flags)
Definition: res_stasis.c:356
static int app_hash(const void *obj, const int flags)
Definition: res_stasis.c:186
#define APPS_NUM_BUCKETS
Number of buckets for the Stasis application hash table. Remember to keep it a prime number!
Definition: res_stasis.c:83
static int control_hash(const void *obj, const int flags)
Definition: res_stasis.c:248
#define CONTROLS_NUM_BUCKETS
Number of buckets for the Stasis application hash table. Remember to keep it a prime number!
Definition: res_stasis.c:89
static int bridges_sort(const void *left, const void *right, const int flags)
Definition: res_stasis.c:418
static int bridges_channel_sort_fn(const void *obj_left, const void *obj_right, const int flags)
Definition: res_stasis.c:509
static int bridges_channel_compare(void *obj, void *arg, int flags)
Definition: res_stasis.c:455
static int unload_module(void)
Definition: res_stasis.c:2274
static int bridges_channel_hash_fn(const void *obj, const int flags)
Definition: res_stasis.c:488
static int control_compare(void *obj, void *arg, int flags)
Definition: res_stasis.c:270
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1493
void stasis_app_register_event_sources(void)
Register core event sources.
void bridge_stasis_init(void)

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, app_bridges, app_bridges_moh, app_bridges_playback, app_compare(), app_controls, app_hash(), APPS_NUM_BUCKETS, apps_registry, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, bridge_stasis_init(), bridges_channel_compare(), bridges_channel_hash_fn(), bridges_channel_sort_fn(), bridges_compare(), bridges_hash(), BRIDGES_NUM_BUCKETS, bridges_sort(), control_compare(), control_hash(), CONTROLS_NUM_BUCKETS, messaging_init(), NULL, stasis_app_register_event_sources(), STASIS_MESSAGE_TYPE_INIT, and unload_module().

◆ masq_match_cb()

static int masq_match_cb ( void *  obj,
void *  data,
int  flags 
)
static

Definition at line 1160 of file res_stasis.c.

1161{
1162 struct stasis_app_control *control = obj;
1163 struct ast_channel *chan = data;
1164
1165 if (!strcmp(ast_channel_uniqueid(chan),
1167 return CMP_MATCH;
1168 }
1169
1170 return 0;
1171}
const char * data

References ast_channel_uniqueid(), CMP_MATCH, ast_channel::data, and stasis_app_control_get_channel_id().

Referenced by channel_replaced_cb(), and channel_stolen_cb().

◆ moh_channel_thread()

static void * moh_channel_thread ( void *  data)
static

Provides the moh channel with a thread so it can actually play its music

Definition at line 555 of file res_stasis.c.

556{
557 struct stasis_app_bridge_channel_wrapper *moh_wrapper = data;
558 struct ast_channel *moh_channel = ast_channel_get_by_name(moh_wrapper->channel_id);
559 struct ast_frame *f;
560
561 if (!moh_channel) {
562 ao2_unlink(app_bridges_moh, moh_wrapper);
563 ao2_ref(moh_wrapper, -1);
564 return NULL;
565 }
566
567 /* Read and discard any frame coming from the stasis bridge. */
568 for (;;) {
569 if (ast_waitfor(moh_channel, -1) < 0) {
570 /* Error or hungup */
571 break;
572 }
573
574 f = ast_read(moh_channel);
575 if (!f) {
576 /* Hungup */
577 break;
578 }
579 ast_frfree(f);
580 }
581
582 ao2_unlink(app_bridges_moh, moh_wrapper);
583 ao2_ref(moh_wrapper, -1);
584
585 ast_moh_stop(moh_channel);
586 ast_hangup(moh_channel);
587
588 return NULL;
589}
int ast_waitfor(struct ast_channel *chan, int ms)
Wait for input on a channel.
Definition: channel.c:3130
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
Definition: channel.c:4214
struct ast_channel * ast_channel_get_by_name(const char *search)
Find a channel by name or uniqueid.
Definition: channel.c:1397
#define ast_frfree(fr)
void ast_moh_stop(struct ast_channel *chan)
Turn off music on hold on a given channel.
Definition: channel.c:7749
Data structure associated with a single frame of data.
const ast_string_field channel_id
Definition: res_stasis.c:451

References ao2_ref, ao2_unlink, app_bridges_moh, ast_channel_get_by_name(), ast_frfree, ast_hangup(), ast_moh_stop(), ast_read(), ast_waitfor(), stasis_app_bridge_channel_wrapper::channel_id, and NULL.

Referenced by bridge_moh_create().

◆ playback_after_bridge_cb()

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

Definition at line 724 of file res_stasis.c.

725{
726 char *bridge_id = data;
727
728 remove_bridge_playback(bridge_id);
729}
static void remove_bridge_playback(char *bridge_id)
Definition: res_stasis.c:699

References remove_bridge_playback().

Referenced by stasis_app_bridge_playback_channel_add().

◆ playback_after_bridge_cb_failed()

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

Definition at line 717 of file res_stasis.c.

718{
719 char *bridge_id = data;
720
721 remove_bridge_playback(bridge_id);
722}

References remove_bridge_playback().

Referenced by stasis_app_bridge_playback_channel_add().

◆ prepare_bridge_moh_channel()

static struct ast_channel * prepare_bridge_moh_channel ( void  )
static

Request a bridge MOH channel

Definition at line 536 of file res_stasis.c.

537{
538 struct ast_channel *chan;
539 struct ast_format_cap *cap;
540
542 if (!cap) {
543 return NULL;
544 }
545
547
548 chan = ast_request("Announcer", cap, NULL, NULL, "ARI_MOH", NULL);
549 ao2_ref(cap, -1);
550
551 return chan;
552}
struct ast_channel * ast_request(const char *type, struct ast_format_cap *request_cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *addr, int *cause)
Requests a channel.
Definition: channel.c:6313
struct ast_format * ast_format_slin
Built-in cached signed linear 8kHz format.
Definition: format_cache.c:41
@ AST_FORMAT_CAP_FLAG_DEFAULT
Definition: format_cap.h:38
#define ast_format_cap_append(cap, format, framing)
Add format capability to capabilities structure.
Definition: format_cap.h:99
#define ast_format_cap_alloc(flags)
Allocate a new ast_format_cap structure.
Definition: format_cap.h:49
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54

References ao2_ref, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_request(), and NULL.

Referenced by bridge_moh_create().

◆ remove_bridge_playback()

static void remove_bridge_playback ( char *  bridge_id)
static

Removes the bridge to playback channel link

Definition at line 699 of file res_stasis.c.

700{
701 struct stasis_app_bridge_channel_wrapper *wrapper;
702 struct stasis_app_control *control;
703
705
706 if (wrapper) {
708 if (control) {
709 ao2_unlink(app_controls, control);
710 ao2_ref(control, -1);
711 }
712 ao2_ref(wrapper, -1);
713 }
714 ast_free(bridge_id);
715}
struct stasis_app_control * stasis_app_control_find_by_channel_id(const char *channel_id)
Returns the handler for the channel with the given id.
Definition: res_stasis.c:349

References ao2_find, ao2_ref, ao2_unlink, app_bridges_playback, app_controls, ast_free, stasis_app_bridge_channel_wrapper::channel_id, OBJ_SEARCH_KEY, OBJ_UNLINK, and stasis_app_control_find_by_channel_id().

Referenced by playback_after_bridge_cb(), and playback_after_bridge_cb_failed().

◆ remove_masquerade_store()

static void remove_masquerade_store ( struct ast_channel chan)
static

Definition at line 1281 of file res_stasis.c.

1282{
1283 struct ast_datastore *datastore;
1284
1285 SCOPED_CHANNELLOCK(lock, chan);
1287 if (!datastore) {
1288 return;
1289 }
1290
1291 ast_channel_datastore_remove(chan, datastore);
1292 ast_datastore_free(datastore);
1293}
int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
Remove a datastore from a channel.
Definition: channel.c:2363
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition: datastore.c:68

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_datastore_free(), lock, masquerade_store_info, NULL, and SCOPED_CHANNELLOCK.

Referenced by app_send_end_msg(), channel_stolen_cb(), and stasis_app_exec().

◆ remove_stasis_end_published()

static void remove_stasis_end_published ( struct ast_channel chan)
static

Definition at line 1355 of file res_stasis.c.

1356{
1357 struct ast_datastore *datastore;
1358
1359 ast_channel_lock(chan);
1361 if (datastore) {
1362 ast_channel_datastore_remove(chan, datastore);
1363 ast_datastore_free(datastore);
1364 }
1365 ast_channel_unlock(chan);
1366}
struct ast_datastore_info set_end_published_info
Definition: res_stasis.c:1328

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_unlock, ast_datastore_free(), NULL, and set_end_published_info.

Referenced by stasis_app_exec().

◆ replace_channel_destroy()

static void replace_channel_destroy ( void *  obj)
static

Definition at line 921 of file res_stasis.c.

922{
923 struct replace_channel_store *replace = obj;
924
925 ao2_cleanup(replace->snapshot);
926 ast_free(replace->app);
928}

References ao2_cleanup, ast_free, and replace().

◆ send_start_msg()

static int send_start_msg ( struct stasis_app app,
struct ast_channel chan,
int  argc,
char *  argv[] 
)
static

Definition at line 1102 of file res_stasis.c.

1104{
1105 int ret = -1;
1106 struct ast_channel_snapshot *snapshot;
1107 struct ast_channel_snapshot *replace_channel_snapshot;
1108
1109 ast_assert(chan != NULL);
1110
1111 replace_channel_snapshot = get_replace_channel_snapshot(chan);
1112
1113 /* Set channel info */
1114 ast_channel_lock(chan);
1115 snapshot = ast_channel_snapshot_create(chan);
1116 ast_channel_unlock(chan);
1117 if (snapshot) {
1118 ret = send_start_msg_snapshots(chan, app, argc, argv, snapshot, replace_channel_snapshot);
1119 ao2_ref(snapshot, -1);
1120 }
1121 ao2_cleanup(replace_channel_snapshot);
1122
1123 return ret;
1124}
struct ast_channel_snapshot * ast_channel_snapshot_create(struct ast_channel *chan)
Generate a snapshot of the channel state. This is an ao2 object, so ao2_cleanup() to deallocate.
static struct ast_channel_snapshot * get_replace_channel_snapshot(struct ast_channel *chan)
Definition: res_stasis.c:997

References ao2_cleanup, ao2_ref, app, ast_assert, ast_channel_lock, ast_channel_snapshot_create(), ast_channel_unlock, get_replace_channel_snapshot(), NULL, and send_start_msg_snapshots().

Referenced by stasis_app_exec().

◆ send_start_msg_snapshots()

static int send_start_msg_snapshots ( struct ast_channel chan,
struct stasis_app app,
int  argc,
char *  argv[],
struct ast_channel_snapshot snapshot,
struct ast_channel_snapshot replace_channel_snapshot 
)
static

Definition at line 1036 of file res_stasis.c.

1039{
1040 struct ast_json *json_blob;
1041 struct ast_json *json_args;
1042 struct start_message_blob *payload;
1043 struct stasis_message *msg;
1044 int i;
1045
1046 if (app_subscribe_channel(app, chan)) {
1047 ast_log(LOG_ERROR, "Error subscribing app '%s' to channel '%s'\n",
1049 return -1;
1050 }
1051
1052 payload = ao2_alloc(sizeof(*payload), start_message_blob_dtor);
1053 if (!payload) {
1054 ast_log(LOG_ERROR, "Error packing JSON for StasisStart message\n");
1055 return -1;
1056 }
1057
1058 payload->channel = ao2_bump(snapshot);
1059 payload->replace_channel = ao2_bump(replace_channel_snapshot);
1060
1061 json_blob = ast_json_pack("{s: s, s: o, s: []}",
1062 "app", stasis_app_name(app),
1063 "timestamp", ast_json_timeval(ast_tvnow(), NULL),
1064 "args");
1065 if (!json_blob) {
1066 ast_log(LOG_ERROR, "Error packing JSON for StasisStart message\n");
1067 ao2_ref(payload, -1);
1068 return -1;
1069 }
1070 payload->blob = json_blob;
1071
1072
1073 /* Append arguments to args array */
1074 json_args = ast_json_object_get(json_blob, "args");
1075 ast_assert(json_args != NULL);
1076 for (i = 0; i < argc; ++i) {
1077 int r = ast_json_array_append(json_args,
1078 ast_json_string_create(argv[i]));
1079 if (r != 0) {
1080 ast_log(LOG_ERROR, "Error appending to StasisStart message\n");
1081 ao2_ref(payload, -1);
1082 return -1;
1083 }
1084 }
1085
1086
1087 msg = stasis_message_create(start_message_type(), payload);
1088 ao2_ref(payload, -1);
1089 if (!msg) {
1090 ast_log(LOG_ERROR, "Error sending StasisStart message\n");
1091 return -1;
1092 }
1093
1094 if (replace_channel_snapshot) {
1095 app_unsubscribe_channel_id(app, replace_channel_snapshot->base->uniqueid);
1096 }
1098 ao2_ref(msg, -1);
1099 return 0;
1100}
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition: astobj2.h:480
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:409
const char * ast_channel_name(const struct ast_channel *chan)
struct ast_json * ast_json_string_create(const char *value)
Construct a JSON string from value.
Definition: json.c:278
int ast_json_array_append(struct ast_json *array, struct ast_json *value)
Append to an array.
Definition: json.c:378
struct ast_json * ast_json_object_get(struct ast_json *object, const char *key)
Get a field from a JSON object.
Definition: json.c:407
int app_subscribe_channel(struct stasis_app *app, struct ast_channel *chan)
Subscribes an application to a channel.
int app_unsubscribe_channel_id(struct stasis_app *app, const char *channel_id)
Cancel the subscription an app has for a channel.
static void start_message_blob_dtor(void *obj)
Definition: res_stasis.c:1027
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
const ast_string_field uniqueid
struct ast_channel_snapshot * replace_channel
Definition: res_stasis.c:143
struct ast_channel_snapshot * channel
Definition: res_stasis.c:142
struct ast_json * blob
Definition: res_stasis.c:144

References ao2_alloc, ao2_bump, ao2_ref, app, app_subscribe_channel(), app_unsubscribe_channel_id(), ast_app_get_topic(), ast_assert, ast_channel_name(), ast_json_array_append(), ast_json_object_get(), ast_json_pack(), ast_json_string_create(), ast_json_timeval(), ast_log, ast_tvnow(), ast_channel_snapshot::base, start_message_blob::blob, start_message_blob::channel, LOG_ERROR, NULL, start_message_blob::replace_channel, start_message_blob_dtor(), stasis_app_name(), stasis_message_create(), stasis_publish(), and ast_channel_snapshot_base::uniqueid.

Referenced by channel_replaced_cb(), and send_start_msg().

◆ set_internal_datastore()

static int set_internal_datastore ( struct ast_channel chan)
static

Definition at line 2352 of file res_stasis.c.

2353{
2354 struct ast_datastore *datastore;
2355
2357 if (!datastore) {
2359 if (!datastore) {
2360 return -1;
2361 }
2362 ast_channel_datastore_add(chan, datastore);
2363 }
2364 return 0;
2365}
static const struct ast_datastore_info stasis_internal_channel_info
Definition: res_stasis.c:2348

References ast_channel_datastore_add(), ast_channel_datastore_find(), ast_datastore_alloc, NULL, and stasis_internal_channel_info.

Referenced by stasis_app_channel_set_internal(), and stasis_app_channel_unreal_set_internal().

◆ start_message_blob_dtor()

static void start_message_blob_dtor ( void *  obj)
static

Definition at line 1027 of file res_stasis.c.

1028{
1029 struct start_message_blob *payload = obj;
1030
1031 ao2_cleanup(payload->channel);
1032 ao2_cleanup(payload->replace_channel);
1033 ast_json_unref(payload->blob);
1034}

References ao2_cleanup, ast_json_unref(), start_message_blob::blob, start_message_blob::channel, and start_message_blob::replace_channel.

Referenced by send_start_msg_snapshots().

◆ stasis_app_bridge_channel_wrapper_destructor()

static void stasis_app_bridge_channel_wrapper_destructor ( void *  obj)
static

Definition at line 481 of file res_stasis.c.

482{
483 struct stasis_app_bridge_channel_wrapper *wrapper = obj;
485}
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374

References ast_string_field_free_memory.

Referenced by bridge_moh_create(), and stasis_app_bridge_playback_channel_add().

◆ stasis_app_bridge_create()

struct ast_bridge * stasis_app_bridge_create ( const char *  type,
const char *  name,
const char *  id 
)

Create a bridge of the specified type.

Parameters
typeThe type of bridge to be created
nameOptional name to give to the bridge
idOptional Unique ID to give to the bridge
Returns
New bridge.
Return values
NULLon error.

Definition at line 891 of file res_stasis.c.

892{
893 return bridge_create_common(type, name, id, 0);
894}
static struct ast_bridge * bridge_create_common(const char *type, const char *name, const char *id, int invisible)
Definition: res_stasis.c:821

References bridge_create_common(), name, and type.

Referenced by ast_ari_bridges_create(), and ast_ari_bridges_create_with_id().

◆ stasis_app_bridge_create_invisible()

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.

Parameters
typeThe type of bridge to be created
nameOptional name to give to the bridge
idOptional Unique ID to give to the bridge
Returns
New bridge.
Return values
NULLon error.

Definition at line 896 of file res_stasis.c.

897{
898 return bridge_create_common(type, name, id, 1);
899}

References bridge_create_common(), name, and type.

Referenced by get_dial_bridge().

◆ stasis_app_bridge_destroy()

void stasis_app_bridge_destroy ( const char *  bridge_id)

Destroy the bridge.

Parameters
bridge_idUniqueid of bridge to be destroyed

Definition at line 901 of file res_stasis.c.

902{
903 struct ast_bridge *bridge = stasis_app_bridge_find_by_id(bridge_id);
904 if (!bridge) {
905 return;
906 }
907 ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": destroying bridge\n",
908 BRIDGE_PRINTF_VARS(bridge));
909
910 ao2_unlink(app_bridges, bridge);
911 ast_debug(1, "Bridge " BRIDGE_PRINTF_SPEC ": unlinked from app_bridges. current refcount: %d\n",
912 BRIDGE_PRINTF_VARS(bridge), ao2_ref(bridge, 0));
913 ast_bridge_destroy(bridge, 0);
914}
#define BRIDGE_PRINTF_VARS(bridge)
Definition: bridge.h:80
#define BRIDGE_PRINTF_SPEC
Definition: bridge.h:79

References ao2_ref, ao2_unlink, app_bridges, ast_bridge_destroy(), ast_debug, BRIDGE_PRINTF_SPEC, BRIDGE_PRINTF_VARS, and stasis_app_bridge_find_by_id().

Referenced by ast_ari_bridges_destroy().

◆ stasis_app_bridge_find_by_id()

struct ast_bridge * stasis_app_bridge_find_by_id ( const char *  bridge_id)

Returns the bridge with the given id.

Parameters
bridge_idUniqueid of the bridge.
Returns
NULL bridge not created by a Stasis application, or bridge does not exist.
Pointer to bridge.

Definition at line 800 of file res_stasis.c.

802{
803 return ao2_find(app_bridges, bridge_id, OBJ_SEARCH_KEY);
804}

References ao2_find, app_bridges, and OBJ_SEARCH_KEY.

Referenced by bridge_create_common(), bridge_find(), find_bridge(), and stasis_app_bridge_destroy().

◆ stasis_app_bridge_moh_channel()

struct ast_channel * stasis_app_bridge_moh_channel ( struct ast_bridge bridge)

Finds or creates an announcer channel in a bridge that can play music on hold.

Parameters
bridgeBridge we want an MOH channel for
Returns
NULL if the music on hold channel fails to be created or join the bridge for any reason.
Pointer to the ;1 end of the announcer channel chain.

Definition at line 655 of file res_stasis.c.

656{
657 struct ast_channel *chan;
658 struct stasis_app_bridge_channel_wrapper *moh_wrapper;
659
661 moh_wrapper = ao2_find(app_bridges_moh, bridge->uniqueid, OBJ_SEARCH_KEY | OBJ_NOLOCK);
662 if (!moh_wrapper) {
663 chan = bridge_moh_create(bridge);
664 }
666
667 if (moh_wrapper) {
668 chan = ast_channel_get_by_name(moh_wrapper->channel_id);
669 ao2_ref(moh_wrapper, -1);
670 }
671
672 return chan;
673}
static struct ast_channel * bridge_moh_create(struct ast_bridge *bridge)
Definition: res_stasis.c:600

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, app_bridges_moh, ast_channel_get_by_name(), bridge_moh_create(), stasis_app_bridge_channel_wrapper::channel_id, OBJ_NOLOCK, OBJ_SEARCH_KEY, and ast_bridge::uniqueid.

Referenced by ast_ari_bridges_start_moh().

◆ stasis_app_bridge_moh_stop()

int stasis_app_bridge_moh_stop ( struct ast_bridge bridge)

Breaks down MOH channels playing on the bridge created by stasis_app_bridge_moh_channel.

Parameters
bridgeBridge we want to stop the MOH on
Returns
-1 if no moh channel could be found and stopped
0 on success

Definition at line 675 of file res_stasis.c.

676{
677 struct stasis_app_bridge_channel_wrapper *moh_wrapper;
678 struct ast_channel *chan;
679
681 if (!moh_wrapper) {
682 return -1;
683 }
684
685 chan = ast_channel_get_by_name(moh_wrapper->channel_id);
686 ao2_ref(moh_wrapper, -1);
687 if (!chan) {
688 return -1;
689 }
690
691 ast_moh_stop(chan);
693 ao2_cleanup(chan);
694
695 return 0;
696}
#define AST_CAUSE_NORMAL_CLEARING
Definition: causes.h:106
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
Definition: channel.c:2440

References ao2_cleanup, ao2_find, ao2_ref, app_bridges_moh, AST_CAUSE_NORMAL_CLEARING, ast_channel_get_by_name(), ast_moh_stop(), ast_softhangup(), ast_channel::bridge, stasis_app_bridge_channel_wrapper::channel_id, OBJ_SEARCH_KEY, OBJ_UNLINK, and ast_bridge::uniqueid.

Referenced by ast_ari_bridges_stop_moh().

◆ stasis_app_bridge_playback_channel_add()

int stasis_app_bridge_playback_channel_add ( struct ast_bridge bridge,
struct ast_channel chan,
struct stasis_app_control control 
)

Adds a channel to the list of ARI playback channels for bridges.

Parameters
bridgeBridge we are adding the playback channel for
chanChannel being added as a playback channel (must be ;1)
controlThe app control structure for the playback channel
Return values
-1failed to add channel for any reason
0on success

Definition at line 731 of file res_stasis.c.

734{
736 char *bridge_id = ast_strdup(bridge->uniqueid);
737
738 if (!bridge_id) {
739 return -1;
740 }
741
744 ast_free(bridge_id);
745 return -1;
746 }
747
748 new_wrapper = ao2_alloc_options(sizeof(*new_wrapper),
750 if (!new_wrapper) {
751 return -1;
752 }
753
754 if (ast_string_field_init(new_wrapper, 32)) {
755 return -1;
756 }
757
758 ast_string_field_set(new_wrapper, bridge_id, bridge->uniqueid);
759 ast_string_field_set(new_wrapper, channel_id, ast_channel_uniqueid(chan));
760
761 if (!ao2_link(app_bridges_playback, new_wrapper)) {
762 return -1;
763 }
764
765 ao2_link(app_controls, control);
766 return 0;
767}
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 playback_after_bridge_cb(struct ast_channel *chan, void *data)
Definition: res_stasis.c:724
static void playback_after_bridge_cb_failed(enum ast_bridge_after_cb_reason reason, void *data)
Definition: res_stasis.c:717

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_link, app_bridges_playback, app_controls, ast_bridge_set_after_callback(), ast_channel_uniqueid(), ast_free, ast_strdup, ast_string_field_init, ast_string_field_set, stasis_app_control::bridge, NULL, playback_after_bridge_cb(), playback_after_bridge_cb_failed(), RAII_VAR, stasis_app_bridge_channel_wrapper_destructor(), and ast_bridge::uniqueid.

Referenced by ari_bridges_play_new().

◆ stasis_app_bridge_playback_channel_find()

struct ast_channel * stasis_app_bridge_playback_channel_find ( struct ast_bridge bridge)

Finds an existing ARI playback channel in a bridge.

Parameters
bridgeBridge we want to find the playback channel for
Returns
NULL if the playback channel can not be found for any reason.
Pointer to the ;1 end of the playback channel chain.

Definition at line 785 of file res_stasis.c.

786{
787 struct stasis_app_bridge_channel_wrapper *playback_wrapper;
788 struct ast_channel *chan;
789
791 if (!playback_wrapper) {
792 return NULL;
793 }
794
795 chan = ast_channel_get_by_name(playback_wrapper->channel_id);
796 ao2_ref(playback_wrapper, -1);
797 return chan;
798}

References ao2_find, ao2_ref, app_bridges_playback, ast_channel_get_by_name(), ast_channel::bridge, stasis_app_bridge_channel_wrapper::channel_id, NULL, OBJ_SEARCH_KEY, and ast_bridge::uniqueid.

Referenced by ari_bridges_handle_play().

◆ stasis_app_bridge_playback_channel_remove()

void stasis_app_bridge_playback_channel_remove ( char *  bridge_id,
struct stasis_app_control control 
)

remove channel from list of ARI playback channels for bridges.

Parameters
bridge_idThe unique ID of the bridge the playback channel is in.
controlThe app control structure for the playback channel

Definition at line 769 of file res_stasis.c.

771{
772 struct stasis_app_bridge_channel_wrapper *wrapper;
773
775 if (wrapper) {
776 /* If wrapper is not found, then that means the after bridge callback has been
777 * called or is in progress. No need to unlink the control here since that has
778 * been done or is about to be done in the after bridge callback
779 */
780 ao2_unlink(app_controls, control);
781 ao2_ref(wrapper, -1);
782 }
783}

References ao2_find, ao2_ref, ao2_unlink, app_bridges_playback, app_controls, stasis_app_bridge_channel_wrapper::bridge_id, OBJ_SEARCH_KEY, and OBJ_UNLINK.

Referenced by ari_bridges_play_new(), and bridge_channel_control_thread().

◆ stasis_app_channel_is_internal()

int stasis_app_channel_is_internal ( struct ast_channel chan)

Is this channel internal to Stasis?

Parameters
chanThe channel to check.
Return values
0No
1Yes

Definition at line 2401 of file res_stasis.c.

2402{
2403 struct ast_datastore *datastore;
2404 int res = 0;
2405
2406 ast_channel_lock(chan);
2408 if (datastore) {
2409 res = 1;
2410 }
2411 ast_channel_unlock(chan);
2412
2413 return res;
2414}

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, NULL, and stasis_internal_channel_info.

Referenced by bridge_stasis_push().

◆ stasis_app_channel_is_stasis_end_published()

int stasis_app_channel_is_stasis_end_published ( struct ast_channel chan)

Has this channel had a StasisEnd published on it?

Parameters
chanThe channel upon which the query rests.
Return values
0No
1Yes

Definition at line 1344 of file res_stasis.c.

1345{
1346 struct ast_datastore *datastore;
1347
1348 ast_channel_lock(chan);
1350 ast_channel_unlock(chan);
1351
1352 return datastore ? 1 : 0;
1353}

References ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, NULL, and set_end_published_info.

Referenced by internal_bridge_after_cb(), and stasis_app_exec().

◆ stasis_app_channel_set_internal()

int stasis_app_channel_set_internal ( struct ast_channel chan)

Mark this channel as being internal to Stasis.

Parameters
chanThe channel to mark.
Return values
zeroSuccess
non-zeroFailure

Definition at line 2390 of file res_stasis.c.

2391{
2392 int res;
2393
2394 ast_channel_lock(chan);
2395 res = set_internal_datastore(chan);
2396 ast_channel_unlock(chan);
2397
2398 return res;
2399}
static int set_internal_datastore(struct ast_channel *chan)
Definition: res_stasis.c:2352

References ast_channel_lock, ast_channel_unlock, ast_unreal_pvt::chan, and set_internal_datastore().

◆ stasis_app_channel_set_stasis_end_published()

void stasis_app_channel_set_stasis_end_published ( struct ast_channel chan)

Indicate that this channel has had a StasisEnd published for it.

Parameters
chanThe channel that is exiting Stasis.

Definition at line 1332 of file res_stasis.c.

1333{
1334 struct ast_datastore *datastore;
1335
1337 if (datastore) {
1338 ast_channel_lock(chan);
1339 ast_channel_datastore_add(chan, datastore);
1340 ast_channel_unlock(chan);
1341 }
1342}

References ast_channel_datastore_add(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, NULL, and set_end_published_info.

Referenced by bridge_stasis_moving(), and channel_stolen_cb().

◆ stasis_app_channel_unreal_set_internal()

int stasis_app_channel_unreal_set_internal ( struct ast_channel chan)

Mark this unreal channel and it's other half as being internal to Stasis.

Parameters
chanThe channel to mark.
Return values
zeroSuccess
non-zeroFailure

Definition at line 2367 of file res_stasis.c.

2368{
2369 struct ast_channel *outchan = NULL, *outowner = NULL;
2370 int res = 0;
2371 struct ast_unreal_pvt *unreal_pvt = ast_channel_tech_pvt(chan);
2372
2373 ao2_ref(unreal_pvt, +1);
2374 ast_unreal_lock_all(unreal_pvt, &outowner, &outchan);
2375 if (outowner) {
2376 res |= set_internal_datastore(outowner);
2377 ast_channel_unlock(outowner);
2378 ast_channel_unref(outowner);
2379 }
2380 if (outchan) {
2381 res |= set_internal_datastore(outchan);
2382 ast_channel_unlock(outchan);
2383 ast_channel_unref(outchan);
2384 }
2385 ao2_unlock(unreal_pvt);
2386 ao2_ref(unreal_pvt, -1);
2387 return res;
2388}
void * ast_channel_tech_pvt(const struct ast_channel *chan)
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:3008
void ast_unreal_lock_all(struct ast_unreal_pvt *p, struct ast_channel **outchan, struct ast_channel **outowner)
Send an unreal pvt in with no locks held and get all locks.
Definition: core_unreal.c:47
The base pvt structure for local channel derivatives.
Definition: core_unreal.h:91
struct ast_channel * chan
Definition: core_unreal.h:94

References ao2_ref, ao2_unlock, ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, ast_unreal_lock_all(), ast_unreal_pvt::chan, NULL, and set_internal_datastore().

Referenced by bridge_moh_create(), and prepare_bridge_media_channel().

◆ stasis_app_control_create()

struct stasis_app_control * stasis_app_control_create ( struct ast_channel chan)

Creates a control handler for a channel that isn't in a stasis app.

Since
12.0.0
Parameters
chanChannel to create controller handle for
Returns
NULL on failure to create the handle
Pointer to res_stasis handler.

Definition at line 333 of file res_stasis.c.

334{
335 return control_create(chan, NULL);
336}
struct stasis_app_control * control_create(struct ast_channel *channel, struct stasis_app *app)
Create a control object.
Definition: control.c:131

References control_create(), and NULL.

Referenced by ari_bridges_play_new(), and ast_ari_bridges_record().

◆ stasis_app_control_execute_until_exhausted()

void stasis_app_control_execute_until_exhausted ( struct ast_channel chan,
struct stasis_app_control control 
)

Act on a stasis app control queue until it is empty.

Since
12.0.0
Parameters
chanChannel to handle
controlControl object to execute

Definition at line 1295 of file res_stasis.c.

1296{
1297 while (!control_is_done(control)) {
1298 int command_count;
1299 command_count = control_dispatch_all(control, chan);
1300
1301 ao2_lock(control);
1302
1303 if (control_command_count(control)) {
1304 /* If the command queue isn't empty, something added to the queue before it was locked. */
1305 ao2_unlock(control);
1306 continue;
1307 }
1308
1309 if (command_count == 0 || ast_channel_fdno(chan) == -1) {
1310 control_mark_done(control);
1311 ao2_unlock(control);
1312 break;
1313 }
1314 ao2_unlock(control);
1315 }
1316}
int ast_channel_fdno(const struct ast_channel *chan)
int control_is_done(struct stasis_app_control *control)
Returns true if control_continue() has been called on this control.
Definition: control.c:363
int control_dispatch_all(struct stasis_app_control *control, struct ast_channel *chan)
Dispatch all commands enqueued to this control.
Definition: control.c:1525
int control_command_count(struct stasis_app_control *control)
Returns the count of items in a control's command queue.
Definition: control.c:358
void control_mark_done(struct stasis_app_control *control)
Definition: control.c:369

References ao2_lock, ao2_unlock, ast_channel_fdno(), control_command_count(), control_dispatch_all(), control_is_done(), and control_mark_done().

Referenced by bridge_channel_control_thread().

◆ stasis_app_control_find_by_channel()

struct stasis_app_control * stasis_app_control_find_by_channel ( const struct ast_channel chan)

Returns the handler for the given channel.

Parameters
chanChannel to handle.
Returns
NULL channel not in Stasis application.
Pointer to res_stasis handler.

Definition at line 338 of file res_stasis.c.

340{
341 if (chan == NULL) {
342 return NULL;
343 }
344
347}

References ast_channel_uniqueid(), NULL, and stasis_app_control_find_by_channel_id().

Referenced by ari_bridges_play_found(), bridge_stasis_moving(), bridge_stasis_push(), bridge_stasis_push_peek(), and bridge_timeout().

◆ stasis_app_control_find_by_channel_id()

struct stasis_app_control * stasis_app_control_find_by_channel_id ( const char *  channel_id)

Returns the handler for the channel with the given id.

Parameters
channel_idUniqueid of the channel.
Returns
NULL channel not in Stasis application, or channel does not exist.
Pointer to res_stasis handler.

Definition at line 349 of file res_stasis.c.

351{
352 return ao2_find(app_controls, channel_id, OBJ_SEARCH_KEY);
353}

References ao2_find, app_controls, and OBJ_SEARCH_KEY.

Referenced by find_channel_control(), find_control(), remove_bridge_playback(), and stasis_app_control_find_by_channel().

◆ stasis_app_control_flush_queue()

void stasis_app_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 1323 of file res_stasis.c.

1324{
1325 control_flush_queue(control);
1326}
void control_flush_queue(struct stasis_app_control *control)
Flush the control command queue.
Definition: control.c:1512

References control_flush_queue().

Referenced by bridge_channel_control_thread().

◆ stasis_app_control_is_done()

int stasis_app_control_is_done ( struct stasis_app_control control)

Check if a control is marked as done.

Since
12.2.0
Parameters
controlWhich control object is being evaluated

Definition at line 1318 of file res_stasis.c.

1319{
1320 return control_is_done(control);
1321}

References control_is_done().

Referenced by ari_bridges_play_found().

◆ stasis_app_exec()

int stasis_app_exec ( struct ast_channel chan,
const char *  app_name,
int  argc,
char *  argv[] 
)

Stasis dialplan application callback.

Control a channel using stasis_app.

Definition at line 1369 of file res_stasis.c.

1371{
1372 RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
1373 RAII_VAR(struct stasis_app_control *, control, NULL, control_unlink);
1374 struct ast_bridge *bridge = NULL;
1375 int res = 0;
1376 int needs_depart;
1377
1378 ast_assert(chan != NULL);
1379
1380 /* Just in case there's a lingering indication that the channel has had a stasis
1381 * end published on it, remove that now.
1382 */
1384
1385 if (!apps_registry) {
1386 return -1;
1387 }
1388
1390 if (!app) {
1392 "Stasis app '%s' not registered\n", app_name);
1393 return -1;
1394 }
1395 if (!app_is_active(app)) {
1397 "Stasis app '%s' not active\n", app_name);
1398 return -1;
1399 }
1400
1401 control = control_create(chan, app);
1402 if (!control) {
1403 ast_log(LOG_ERROR, "Control allocation failed or Stasis app '%s' not registered\n", app_name);
1404 return -1;
1405 }
1406
1407 if (!control_app(control)) {
1408 ast_log(LOG_ERROR, "Stasis app '%s' not registered\n", app_name);
1409 return -1;
1410 }
1411
1412 if (!app_is_active(control_app(control))) {
1413 ast_log(LOG_ERROR, "Stasis app '%s' not active\n", app_name);
1414 return -1;
1415 }
1416 ao2_link(app_controls, control);
1417
1418 if (add_masquerade_store(chan)) {
1419 ast_log(LOG_ERROR, "Failed to attach masquerade detector\n");
1420 return -1;
1421 }
1422
1423 res = send_start_msg(control_app(control), chan, argc, argv);
1424 if (res != 0) {
1426 "Error sending start message to '%s'\n", app_name);
1428 return -1;
1429 }
1430
1431 /* Pull queued prestart commands and execute */
1432 control_prestart_dispatch_all(control, chan);
1433
1434 while (!control_is_done(control)) {
1435 RAII_VAR(struct ast_frame *, f, NULL, ast_frame_dtor);
1436 int r;
1437 int command_count;
1438 RAII_VAR(struct ast_bridge *, last_bridge, NULL, ao2_cleanup);
1439
1440 /* Check to see if a bridge absorbed our hangup frame */
1441 if (ast_check_hangup_locked(chan)) {
1442 control_mark_done(control);
1443 break;
1444 }
1445
1446 /* control->next_app is only modified within the control thread, so this is safe */
1447 if (control_next_app(control)) {
1448 struct stasis_app *next_app = ao2_find(apps_registry, control_next_app(control), OBJ_SEARCH_KEY);
1449
1450 if (next_app && app_is_active(next_app)) {
1451 int idx;
1452 int next_argc;
1453 char **next_argv;
1454
1455 /* If something goes wrong in this conditional, res will need to be non-zero
1456 * so that the code below the exec loop knows something went wrong during a move.
1457 */
1459 res = has_masquerade_store(chan) && app_send_end_msg(control_app(control), chan);
1460 if (res != 0) {
1462 "Error sending end message to %s\n", stasis_app_name(control_app(control)));
1463 control_mark_done(control);
1464 ao2_ref(next_app, -1);
1465 break;
1466 }
1467 } else {
1469 }
1470
1471 /* This will ao2_bump next_app, and unref the previous app by 1 */
1472 control_set_app(control, next_app);
1473
1474 /* There's a chance that the previous application is ready for clean up, so go ahead
1475 * and do that now.
1476 */
1477 cleanup();
1478
1479 /* We need to add another masquerade store, otherwise the leave message will
1480 * not show up for the correct application.
1481 */
1482 if (add_masquerade_store(chan)) {
1483 ast_log(LOG_ERROR, "Failed to attach masquerade detector\n");
1484 res = -1;
1485 control_mark_done(control);
1486 ao2_ref(next_app, -1);
1487 break;
1488 }
1489
1490 /* We MUST get the size before the list, as control_next_app_args steals the elements
1491 * from the string vector.
1492 */
1493 next_argc = control_next_app_args_size(control);
1494 next_argv = control_next_app_args(control);
1495
1496 res = send_start_msg(control_app(control), chan, next_argc, next_argv);
1497
1498 /* Even if res != 0, we still need to free the memory we got from control_argv */
1499 if (next_argv) {
1500 for (idx = 0; idx < next_argc; idx++) {
1501 ast_free(next_argv[idx]);
1502 }
1503 ast_free(next_argv);
1504 }
1505
1506 if (res != 0) {
1508 "Error sending start message to '%s'\n", stasis_app_name(control_app(control)));
1510 control_mark_done(control);
1511 ao2_ref(next_app, -1);
1512 break;
1513 }
1514
1515 /* Done switching applications, free memory and clean up */
1516 control_move_cleanup(control);
1517 } else {
1518 /* If we can't switch applications, do nothing */
1519 struct ast_json *msg;
1520 RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
1521
1522 if (!next_app) {
1523 ast_log(LOG_ERROR, "Could not move to Stasis app '%s' - not registered\n",
1524 control_next_app(control));
1525 } else {
1526 ast_log(LOG_ERROR, "Could not move to Stasis app '%s' - not active\n",
1527 control_next_app(control));
1528 }
1529
1531 if (!snapshot) {
1532 ast_log(LOG_ERROR, "Could not get channel shapshot for '%s'\n",
1533 ast_channel_name(chan));
1534 } else {
1535 struct ast_json *json_args;
1536 int next_argc = control_next_app_args_size(control);
1537 char **next_argv = control_next_app_args(control);
1538
1539 msg = ast_json_pack("{s: s, s: o, s: o, s: s, s: []}",
1540 "type", "ApplicationMoveFailed",
1541 "timestamp", ast_json_timeval(ast_tvnow(), NULL),
1542 "channel", ast_channel_snapshot_to_json(snapshot, NULL),
1543 "destination", control_next_app(control),
1544 "args");
1545 if (!msg) {
1546 ast_log(LOG_ERROR, "Failed to pack JSON for ApplicationMoveFailed message\n");
1547 } else {
1548 json_args = ast_json_object_get(msg, "args");
1549 if (!json_args) {
1550 ast_log(LOG_ERROR, "Could not get args json array");
1551 } else {
1552 int r = 0;
1553 int idx;
1554 for (idx = 0; idx < next_argc; ++idx) {
1555 r = ast_json_array_append(json_args,
1556 ast_json_string_create(next_argv[idx]));
1557 if (r != 0) {
1558 ast_log(LOG_ERROR, "Error appending to ApplicationMoveFailed message\n");
1559 break;
1560 }
1561 }
1562 if (r == 0) {
1563 app_send(control_app(control), msg);
1564 }
1565 }
1566 ast_json_unref(msg);
1567 }
1568 }
1569 }
1570 control_move_cleanup(control);
1571 ao2_cleanup(next_app);
1572 }
1573
1574 last_bridge = bridge;
1575 bridge = ao2_bump(stasis_app_get_bridge(control));
1576
1577 if (bridge != last_bridge) {
1578 if (last_bridge) {
1579 app_unsubscribe_bridge(control_app(control), last_bridge);
1580 }
1581 if (bridge) {
1582 app_subscribe_bridge(control_app(control), bridge);
1583 }
1584 }
1585
1586 if (bridge) {
1587 /* Bridge/dial is handling channel frames */
1588 control_wait(control);
1589 control_dispatch_all(control, chan);
1590 continue;
1591 }
1592
1593 r = ast_waitfor(chan, MAX_WAIT_MS);
1594
1595 if (r < 0) {
1596 ast_debug(3, "%s: Poll error\n",
1597 ast_channel_uniqueid(chan));
1598 control_mark_done(control);
1599 break;
1600 }
1601
1602 command_count = control_dispatch_all(control, chan);
1603
1604 if (command_count > 0 && ast_channel_fdno(chan) == -1) {
1605 /* Command drained the channel; wait for next frame */
1606 continue;
1607 }
1608
1609 if (r == 0) {
1610 /* Timeout */
1611 continue;
1612 }
1613
1614 f = ast_read(chan);
1615 if (!f) {
1616 /* Continue on in the dialplan */
1617 ast_debug(3, "%s: Hangup (no more frames)\n",
1618 ast_channel_uniqueid(chan));
1619 control_mark_done(control);
1620 break;
1621 }
1622
1623 if (f->frametype == AST_FRAME_CONTROL) {
1624 if (f->subclass.integer == AST_CONTROL_HANGUP) {
1625 /* Continue on in the dialplan */
1626 ast_debug(3, "%s: Hangup\n",
1627 ast_channel_uniqueid(chan));
1628 control_mark_done(control);
1629 break;
1630 }
1631 }
1632 }
1633
1634 ast_channel_lock(chan);
1635 needs_depart = (ast_channel_internal_bridge_channel(chan) != NULL);
1636 ast_channel_unlock(chan);
1637 if (needs_depart) {
1638 ast_bridge_depart(chan);
1639 }
1640
1641 if (stasis_app_get_bridge(control)) {
1643 }
1644 ao2_cleanup(bridge);
1645
1646 /* Only publish a stasis_end event if it hasn't already been published */
1647 if (!res && !stasis_app_channel_is_stasis_end_published(chan)) {
1648 /* A masquerade has occurred and this message will be wrong so it
1649 * has already been sent elsewhere. */
1650 res = has_masquerade_store(chan) && app_send_end_msg(control_app(control), chan);
1651 if (res != 0) {
1653 "Error sending end message to %s\n", stasis_app_name(control_app(control)));
1654 return res;
1655 }
1656 } else {
1658 }
1659
1660 control_flush_queue(control);
1661
1662 /* Stop any lingering silence generator */
1663 control_silence_stop_now(control);
1664
1665 /* There's an off chance that app is ready for cleanup. Go ahead
1666 * and clean up, just in case
1667 */
1668 cleanup();
1669
1670 if (stasis_app_control_is_failed(control)) {
1671 res = -1;
1672 }
1673 /* The control needs to be removed from the controls container in
1674 * case a new PBX is started and ends up coming back into Stasis.
1675 */
1676 control_unlink(control);
1677 control = NULL;
1678
1679 if (!res && !ast_channel_pbx(chan)) {
1680 int chan_hungup;
1681
1682 /* The ASYNCGOTO softhangup flag may have broken the channel out of
1683 * its bridge to run dialplan, so if there's no pbx on the channel
1684 * let it run dialplan here. Otherwise, it will run when this
1685 * application exits. */
1686 ast_channel_lock(chan);
1688 chan_hungup = ast_check_hangup(chan);
1689 ast_channel_unlock(chan);
1690
1691 if (!chan_hungup) {
1692 struct ast_pbx_args pbx_args;
1693
1694 memset(&pbx_args, 0, sizeof(pbx_args));
1695 pbx_args.no_hangup_chan = 1;
1696
1697 res = ast_pbx_run_args(chan, &pbx_args);
1698 }
1699 }
1700
1701 return res;
1702}
int ast_bridge_depart(struct ast_channel *chan)
Depart a channel from a bridge.
Definition: bridge.c:1975
void ast_channel_clear_softhangup(struct ast_channel *chan, int flag)
Clear a set of softhangup flags from a channel.
Definition: channel.c:2401
int ast_check_hangup_locked(struct ast_channel *chan)
Definition: channel.c:458
struct ast_bridge_channel * ast_channel_internal_bridge_channel(const struct ast_channel *chan)
int ast_check_hangup(struct ast_channel *chan)
Check to see if a channel is needing hang up.
Definition: channel.c:444
struct ast_pbx * ast_channel_pbx(const struct ast_channel *chan)
@ AST_SOFTHANGUP_ASYNCGOTO
Definition: channel.h:1146
int control_prestart_dispatch_all(struct stasis_app_control *control, struct ast_channel *chan)
Dispatch all queued prestart commands.
Definition: control.c:1565
void control_wait(struct stasis_app_control *control)
Blocks until control's command queue has a command available.
Definition: control.c:1545
char ** control_next_app_args(struct stasis_app_control *control)
Returns the list of arguments to pass to the application we are moving to.
Definition: control.c:1740
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.
Definition: control.c:1745
void control_set_app(struct stasis_app_control *control, struct stasis_app *app)
Set the application the control object belongs to.
Definition: control.c:1721
void control_silence_stop_now(struct stasis_app_control *control)
Stop playing silence to a channel right now.
Definition: control.c:863
char * control_next_app(struct stasis_app_control *control)
Returns the name of the application we are moving to.
Definition: control.c:1727
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:1732
void ast_frame_dtor(struct ast_frame *frame)
NULL-safe wrapper for ast_frfree, good for RAII_VAR.
Definition: main/frame.c:187
@ AST_FRAME_CONTROL
@ AST_CONTROL_HANGUP
enum ast_pbx_result ast_pbx_run_args(struct ast_channel *c, struct ast_pbx_args *args)
Execute the PBX in the current thread.
Definition: pbx.c:4750
int app_subscribe_bridge(struct stasis_app *app, struct ast_bridge *bridge)
Add a bridge subscription to an existing channel subscription.
int app_unsubscribe_bridge(struct stasis_app *app, struct ast_bridge *bridge)
Cancel the bridge subscription for an application.
int app_is_active(struct stasis_app *app)
Checks whether an app is active.
void app_send(struct stasis_app *app, struct ast_json *message)
Send a message to an application.
static int send_start_msg(struct stasis_app *app, struct ast_channel *chan, int argc, char *argv[])
Definition: res_stasis.c:1102
static void remove_stasis_end_published(struct ast_channel *chan)
Definition: res_stasis.c:1355
static int add_masquerade_store(struct ast_channel *chan)
Definition: res_stasis.c:1262
static int has_masquerade_store(struct ast_channel *chan)
Definition: res_stasis.c:1256
#define MAX_WAIT_MS
Definition: res_stasis.c:77
static void control_unlink(struct stasis_app_control *control)
In addition to running ao2_cleanup(), this function also removes the object from the app_controls con...
Definition: res_stasis.c:811
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:1344
int stasis_app_control_is_failed(const struct stasis_app_control *control)
Check if a control object is marked as "failed".
Definition: control.c:382
struct ast_bridge * stasis_app_get_bridge(struct stasis_app_control *control)
Gets the bridge currently associated with a control object.
Definition: control.c:957
struct ast_json * ast_channel_snapshot_to_json(const struct ast_channel_snapshot *snapshot, const struct stasis_message_sanitizer *sanitize)
Build a JSON object from a ast_channel_snapshot.
Options for ast_pbx_run()
Definition: pbx.h:408

References add_masquerade_store(), ao2_bump, ao2_cleanup, ao2_find, ao2_link, ao2_ref, app, app_controls, app_is_active(), app_name(), app_send(), app_send_end_msg(), app_subscribe_bridge(), app_unsubscribe_bridge(), apps_registry, ast_assert, ast_bridge_depart(), ast_channel_clear_softhangup(), ast_channel_fdno(), ast_channel_internal_bridge_channel(), ast_channel_lock, ast_channel_name(), ast_channel_pbx(), ast_channel_snapshot_get_latest(), ast_channel_snapshot_to_json(), ast_channel_uniqueid(), ast_channel_unlock, ast_check_hangup(), ast_check_hangup_locked(), AST_CONTROL_HANGUP, ast_debug, AST_FRAME_CONTROL, ast_frame_dtor(), ast_free, ast_json_array_append(), ast_json_object_get(), ast_json_pack(), ast_json_string_create(), ast_json_timeval(), ast_json_unref(), ast_log, ast_pbx_run_args(), ast_read(), AST_SOFTHANGUP_ASYNCGOTO, ast_tvnow(), ast_waitfor(), cleanup(), control_app(), control_create(), control_dispatch_all(), control_flush_queue(), control_is_done(), control_mark_done(), control_move_cleanup(), control_next_app(), control_next_app_args(), control_next_app_args_size(), control_prestart_dispatch_all(), control_set_app(), control_silence_stop_now(), control_unlink(), control_wait(), has_masquerade_store(), LOG_ERROR, MAX_WAIT_MS, ast_pbx_args::no_hangup_chan, NULL, OBJ_SEARCH_KEY, RAII_VAR, remove_masquerade_store(), remove_stasis_end_published(), send_start_msg(), stasis_app_channel_is_stasis_end_published(), stasis_app_control_is_failed(), stasis_app_get_bridge(), and stasis_app_name().

Referenced by app_exec().

◆ stasis_app_get_all()

struct ao2_container * stasis_app_get_all ( void  )

Gets the names of all registered Stasis applications.

Returns
ast_str_container of container names.
Return values
NULLon error.

Definition at line 1769 of file res_stasis.c.

1770{
1771 struct ao2_container *apps;
1772
1773 if (!apps_registry) {
1774 return NULL;
1775 }
1776
1778 if (!apps) {
1779 return NULL;
1780 }
1781
1783
1784 return apps;
1785}
static struct apps apps
static int append_name(void *obj, void *arg, int flags)
Definition: res_stasis.c:1760
#define ast_str_container_alloc(buckets)
Allocates a hash container for bare strings.
Definition: strings.h:1365

References ao2_callback, append_name(), apps, apps_registry, ast_str_container_alloc, NULL, and OBJ_NODATA.

Referenced by ari_show_apps(), ast_ari_applications_list(), complete_ari_app(), and stasis_app_set_global_debug().

◆ stasis_app_get_by_name()

struct stasis_app * stasis_app_get_by_name ( const char *  name)

Retrieve a handle to a Stasis application by its name.

Parameters
nameThe name of the registered Stasis application
Returns
stasis_app on success.
Return values
NULLon error.

Definition at line 1742 of file res_stasis.c.

1743{
1744 return find_app_by_name(name);
1745}

References find_app_by_name(), and name.

Referenced by ari_set_debug(), ari_show_app(), ast_ari_applications_filter(), stasis_app_event_allowed(), stasis_app_get_debug_by_name(), stasis_app_set_debug_by_name(), and stasis_app_set_global_debug().

◆ stasis_app_get_sanitizer()

struct stasis_message_sanitizer * stasis_app_get_sanitizer ( void  )

Get the Stasis message sanitizer for app_stasis applications.

Return values
Thestasis message sanitizer

Definition at line 2343 of file res_stasis.c.

2344{
2345 return &app_sanitizer;
2346}
struct stasis_message_sanitizer app_sanitizer
Sanitization callbacks for communication to Stasis applications.
Definition: res_stasis.c:2337

References app_sanitizer.

Referenced by app_send_end_msg(), ast_ari_bridges_create(), ast_ari_bridges_create_with_id(), ast_ari_bridges_get(), ast_ari_bridges_list(), ast_ari_channels_list(), ast_ari_endpoints_get(), ast_ari_endpoints_list(), ast_ari_endpoints_list_by_tech(), channel_callerid(), channel_connected_line(), channel_destroyed_event(), channel_dialplan(), message_received_handler(), simple_bridge_event(), simple_channel_event(), and simple_endpoint_event().

◆ stasis_app_is_registered()

int stasis_app_is_registered ( const char *  name)

Check if a Stasis application is registered.

Parameters
nameThe name of the registered Stasis application
Returns
1 if the application is registered.
0 if the application is not registered.

Definition at line 1747 of file res_stasis.c.

1748{
1750
1751 /*
1752 * It's safe to unref app here because we're not actually
1753 * using it or returning it.
1754 */
1756
1757 return app != NULL;
1758}

References ao2_cleanup, app, find_app_by_name(), name, and NULL.

◆ stasis_app_object_to_json()

struct ast_json * stasis_app_object_to_json ( struct stasis_app app)

Return the JSON representation of a Stasis application.

Since
16.3.0
Parameters
appThe application.
Returns
JSON representation of app with given name.
Return values
NULLon error.

Definition at line 1945 of file res_stasis.c.

1946{
1947 if (!app) {
1948 return NULL;
1949 }
1950
1953}
struct ast_json * app_to_json(const struct stasis_app *app)
Create a JSON representation of a stasis_app.
static struct ast_json * app_event_sources_to_json(const struct stasis_app *app, struct ast_json *json)
Definition: res_stasis.c:1929
struct ast_json * stasis_app_event_filter_to_json(struct stasis_app *app, struct ast_json *json)
Convert and add the app's event type filter(s) to the given json object.

References app, app_event_sources_to_json(), app_to_json(), NULL, and stasis_app_event_filter_to_json().

Referenced by app_handle_subscriptions(), ast_ari_applications_filter(), and stasis_app_to_json().

◆ stasis_app_register()

int stasis_app_register ( const char *  app_name,
stasis_app_cb  handler,
void *  data 
)

Register a new Stasis application.

If an application is already registered with the given name, the old application is sent a 'replaced' message and unregistered.

Parameters
app_nameName of this application.
handlerCallback for application messages.
dataData blob to pass to the callback. Must be AO2 managed.
Returns
0 for success
-1 for error.

Definition at line 1838 of file res_stasis.c.

1839{
1840 return __stasis_app_register(app_name, handler, data, 0);
1841}
static int __stasis_app_register(const char *app_name, stasis_app_cb handler, void *data, int all_events)
Definition: res_stasis.c:1787

References __stasis_app_register(), app_name(), and handler().

Referenced by ari_ws_session_create(), and AST_TEST_DEFINE().

◆ stasis_app_register_all()

int stasis_app_register_all ( const char *  app_name,
stasis_app_cb  handler,
void *  data 
)

Register a new Stasis application that receives all Asterisk events.

If an application is already registered with the given name, the old application is sent a 'replaced' message and unregistered.

Parameters
app_nameName of this application.
handlerCallback for application messages.
dataData blob to pass to the callback. Must be AO2 managed.
Returns
0 for success
-1 for error.

Definition at line 1843 of file res_stasis.c.

1844{
1845 return __stasis_app_register(app_name, handler, data, 1);
1846}

References __stasis_app_register(), app_name(), and handler().

Referenced by ari_ws_session_create().

◆ stasis_app_register_event_source()

void stasis_app_register_event_source ( struct stasis_app_event_source obj)

Register an application event source.

Parameters
objthe event source to register

Definition at line 1895 of file res_stasis.c.

1896{
1900}
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:52
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
Definition: linkedlists.h:731

References AST_LIST_INSERT_TAIL, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and stasis_app_event_source::next.

Referenced by load_module(), and stasis_app_register_event_sources().

◆ stasis_app_send()

int stasis_app_send ( const char *  app_name,
struct ast_json message 
)

Send a message to the given Stasis application.

The message given to the handler is a borrowed copy. If you want to keep a reference to it, you should use ao2_ref() to keep it around.

Parameters
app_nameName of the application to invoke.
messageMessage to send (borrowed reference)
Returns
0 for success.
-1 for error.

Definition at line 1704 of file res_stasis.c.

1705{
1706 struct stasis_app *app;
1707
1708 if (!apps_registry) {
1709 return -1;
1710 }
1711
1713 if (!app) {
1714 /* XXX We can do a better job handling late binding, queueing up
1715 * the call for a few seconds to wait for the app to register.
1716 */
1718 "Stasis app '%s' not registered\n", app_name);
1719 return -1;
1720 }
1722 ao2_ref(app, -1);
1723
1724 return 0;
1725}

References ao2_find, ao2_ref, app, app_name(), app_send(), apps_registry, ast_log, LOG_WARNING, and OBJ_SEARCH_KEY.

Referenced by AST_TEST_DEFINE(), and send_device_state().

◆ stasis_app_subscribe()

enum stasis_app_subscribe_res stasis_app_subscribe ( const char *  app_name,
const char **  event_source_uris,
int  event_sources_count,
struct ast_json **  json 
)

Subscribes an application to a list of event sources.

Parameters
app_nameName of the application to subscribe.
event_source_urisURIs for the event sources to subscribe to.
event_sources_countArray size of event_source_uris.
jsonOptional output pointer for JSON representation of the app after adding the subscription.
Returns
stasis_app_subscribe_res return code.
Note
Do not hold any channel locks if subscribing to a channel.

Definition at line 2124 of file res_stasis.c.

2127{
2129 app_name, event_source_uris, event_sources_count,
2130 json, app_subscribe);
2131}
static enum stasis_app_subscribe_res app_subscribe(struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)
Definition: res_stasis.c:2098
static enum stasis_app_subscribe_res app_handle_subscriptions(const char *app_name, const char **event_source_uris, int event_sources_count, struct ast_json **json, app_subscription_handler handler)
Definition: res_stasis.c:2018

References app_handle_subscriptions(), app_name(), and app_subscribe().

Referenced by ast_ari_applications_subscribe().

◆ stasis_app_subscribe_channel()

enum stasis_app_subscribe_res stasis_app_subscribe_channel ( const char *  app_name,
struct ast_channel chan 
)

Directly subscribe an application to a channel.

Parameters
app_nameName of the application to subscribe.
chanThe channel to subscribe to
Returns
stasis_app_subscribe_res return code.
Note
This method can be used when you already hold a channel and its lock. This bypasses the channel lookup that would normally be performed by stasis_app_subscribe.

Definition at line 2063 of file res_stasis.c.

2065{
2067 int res;
2068
2069 if (!app) {
2071 }
2072
2073 ast_debug(3, "%s: Subscribing to %s\n", app_name, ast_channel_uniqueid(chan));
2074
2075 res = app_subscribe_channel(app, chan);
2076 ao2_ref(app, -1);
2077
2078 if (res != 0) {
2079 ast_log(LOG_ERROR, "Error subscribing app '%s' to channel '%s'\n",
2082 }
2083
2084 return STASIS_ASR_OK;
2085}

References ao2_ref, app, app_name(), app_subscribe_channel(), ast_channel_uniqueid(), ast_debug, ast_log, find_app_by_name(), LOG_ERROR, STASIS_ASR_APP_NOT_FOUND, STASIS_ASR_INTERNAL_ERROR, and STASIS_ASR_OK.

Referenced by ari_channels_handle_originate_with_id(), and ast_ari_channels_create().

◆ stasis_app_to_json()

struct ast_json * stasis_app_to_json ( const char *  app_name)

Return the JSON representation of a Stasis application.

Parameters
app_nameName of the application.
Returns
JSON representation of app with given name.
Return values
NULLon error.

Definition at line 1955 of file res_stasis.c.

1956{
1958 struct ast_json *json = stasis_app_object_to_json(app);
1959
1961
1962 return json;
1963}

References ao2_cleanup, app, app_name(), find_app_by_name(), and stasis_app_object_to_json().

Referenced by append_json(), and ast_ari_applications_get().

◆ stasis_app_unregister()

void stasis_app_unregister ( const char *  app_name)

Unregister a Stasis application and unsubscribe from all event sources.

Parameters
app_nameName of the application to unregister.

Definition at line 1848 of file res_stasis.c.

1849{
1850 struct stasis_app *app;
1851 struct stasis_app_event_source *source;
1852 int res;
1853
1854 if (!app_name) {
1855 return;
1856 }
1857
1858 if (!apps_registry) {
1859 return;
1860 }
1861
1863 if (!app) {
1865 "Stasis app '%s' not registered\n", app_name);
1866 return;
1867 }
1868
1869 /* Unsubscribe from all event sources. */
1872 if (!source->unsubscribe || !source->is_subscribed
1873 || !source->is_subscribed(app, NULL)) {
1874 continue;
1875 }
1876
1877 res = source->unsubscribe(app, NULL);
1878 if (res) {
1879 ast_log(LOG_WARNING, "%s: Error unsubscribing from event source '%s'\n",
1880 app_name, source->scheme);
1881 }
1882 }
1884
1886
1887 /* There's a decent chance that app is ready for cleanup. Go ahead
1888 * and clean up, just in case
1889 */
1890 cleanup();
1891
1892 ao2_ref(app, -1);
1893}
void app_deactivate(struct stasis_app *app)
Deactivates an application.

References ao2_find, ao2_ref, app, app_deactivate(), app_name(), apps_registry, AST_LIST_TRAVERSE, ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_UNLOCK, cleanup(), stasis_app_event_source::is_subscribed, LOG_ERROR, LOG_WARNING, stasis_app_event_source::next, NULL, OBJ_SEARCH_KEY, stasis_app_event_source::scheme, and stasis_app_event_source::unsubscribe.

Referenced by ari_ws_session_reset(), and AST_TEST_DEFINE().

◆ stasis_app_unregister_event_source()

void stasis_app_unregister_event_source ( struct stasis_app_event_source obj)

Unregister an application event source.

Parameters
objthe event source to unregister

Definition at line 1902 of file res_stasis.c.

1903{
1904 struct stasis_app_event_source *source;
1905
1908 if (source == obj) {
1910 break;
1911 }
1912 }
1915}
#define AST_RWLIST_REMOVE_CURRENT
Definition: linkedlists.h:570
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
Definition: linkedlists.h:545
#define AST_RWLIST_TRAVERSE_SAFE_END
Definition: linkedlists.h:617

References AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and stasis_app_event_source::next.

Referenced by stasis_app_unregister_event_sources(), and unload_module().

◆ stasis_app_unsubscribe()

enum stasis_app_subscribe_res stasis_app_unsubscribe ( const char *  app_name,
const char **  event_source_uris,
int  event_sources_count,
struct ast_json **  json 
)

Unsubscribes an application from a list of event sources.

Parameters
app_nameName of the application to subscribe.
event_source_urisURIs for the event sources to subscribe to.
event_sources_countArray size of event_source_uris.
jsonOptional output pointer for JSON representation of the app after adding the subscription.
Returns
stasis_app_subscribe_res return code.

Definition at line 2165 of file res_stasis.c.

2168{
2170 app_name, event_source_uris, event_sources_count,
2171 json, app_unsubscribe);
2172}
static enum stasis_app_subscribe_res app_unsubscribe(struct stasis_app *app, const char *uri, struct stasis_app_event_source *event_source)
Definition: res_stasis.c:2143

References app_handle_subscriptions(), app_name(), and app_unsubscribe().

Referenced by ast_ari_applications_unsubscribe().

◆ stasis_app_user_event()

enum stasis_app_user_event_res stasis_app_user_event ( const char *  app_name,
const char *  event_name,
const char **  source_uris,
int  sources_count,
struct ast_json json_variables 
)

Generate a Userevent for stasis app (echo to AMI)

Parameters
app_nameName of the application to generate event for/to.
event_nameName of the Userevent.
source_urisURIs for the source objects to attach to event.
sources_countArray size of source_uris.
json_variablesevent blob variables.
Returns
stasis_app_user_event_res return code.

Definition at line 2174 of file res_stasis.c.

2178{
2180 struct ast_json *blob = NULL;
2181 struct ast_multi_object_blob *multi;
2182 struct stasis_message *message;
2184 int have_channel = 0;
2185 int i;
2186
2187 if (!app) {
2188 ast_log(LOG_WARNING, "App %s not found\n", app_name);
2190 }
2191
2193 return res;
2194 }
2195
2196 if (json_variables) {
2197 struct ast_json *json_value = ast_json_string_create(event_name);
2198
2199 if (json_value && !ast_json_object_set(json_variables, "eventname", json_value)) {
2200 blob = ast_json_ref(json_variables);
2201 }
2202 } else {
2203 blob = ast_json_pack("{s: s}", "eventname", event_name);
2204 }
2205
2206 if (!blob) {
2207 ast_log(LOG_ERROR, "Failed to initialize blob\n");
2208
2209 return res;
2210 }
2211
2212 multi = ast_multi_object_blob_create(blob);
2213 ast_json_unref(blob);
2214 if (!multi) {
2215 ast_log(LOG_ERROR, "Failed to initialize multi\n");
2216
2217 return res;
2218 }
2219
2220 for (i = 0; i < sources_count; ++i) {
2221 const char *uri = source_uris[i];
2222 void *snapshot=NULL;
2224
2225 if (ast_begins_with(uri, "channel:")) {
2227 snapshot = ast_channel_snapshot_get_latest(uri + 8);
2228 have_channel = 1;
2229 } else if (ast_begins_with(uri, "bridge:")) {
2231 snapshot = ast_bridge_get_snapshot_by_uniqueid(uri + 7);
2232 } else if (ast_begins_with(uri, "endpoint:")) {
2234 snapshot = ast_endpoint_latest_snapshot(uri + 9, NULL);
2235 } else {
2236 ast_log(LOG_WARNING, "Invalid scheme: %s\n", uri);
2237 ao2_ref(multi, -1);
2238
2240 }
2241 if (!snapshot) {
2242 ast_log(LOG_ERROR, "Unable to get snapshot for %s\n", uri);
2243 ao2_ref(multi, -1);
2244
2246 }
2247 ast_multi_object_blob_add(multi, type, snapshot);
2248 }
2249
2251 ao2_ref(multi, -1);
2252
2253 if (!message) {
2254 ast_log(LOG_ERROR, "Unable to create stasis user event message\n");
2255 return res;
2256 }
2257
2258 /*
2259 * Publishing to two different topics is normally to be avoided -- except
2260 * in this case both are final destinations with no forwards (only listeners).
2261 * The message has to be delivered to the application topic for ARI, but a
2262 * copy is also delivered directly to the manager for AMI if there is a channel.
2263 */
2265
2266 if (have_channel) {
2268 }
2269 ao2_ref(message, -1);
2270
2271 return STASIS_APP_USER_OK;
2272}
struct stasis_topic * ast_manager_get_topic(void)
Get the Stasis Message Bus API topic for AMI.
Definition: manager.c:454
void ast_multi_object_blob_add(struct ast_multi_object_blob *multi, enum stasis_user_multi_object_snapshot_type type, void *object)
Add an object to a multi object blob previously created.
Definition: stasis.c:2028
stasis_user_multi_object_snapshot_type
Object type code for multi user object snapshots.
Definition: stasis.h:1353
struct ast_multi_object_blob * ast_multi_object_blob_create(struct ast_json *blob)
Create a stasis multi object blob.
Definition: stasis.c:2002
struct ast_endpoint_snapshot * ast_endpoint_latest_snapshot(const char *tech, const char *resource)
Retrieve the most recent snapshot for the endpoint with the given name.
struct stasis_message_type * ast_multi_user_event_type(void)
Message type for custom user defined events with multi object blobs.
@ STASIS_UMOS_ENDPOINT
Definition: stasis.h:1356
@ STASIS_UMOS_BRIDGE
Definition: stasis.h:1355
@ STASIS_UMOS_CHANNEL
Definition: stasis.h:1354
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition: json.c:67
int ast_json_object_set(struct ast_json *object, const char *key, struct ast_json *value)
Set a field in a JSON object.
Definition: json.c:414
stasis_app_user_event_res
Return code for stasis_app_user_event.
Definition: stasis_app.h:265
@ STASIS_APP_USER_APP_NOT_FOUND
Definition: stasis_app.h:267
@ STASIS_APP_USER_EVENT_SOURCE_NOT_FOUND
Definition: stasis_app.h:268
@ STASIS_APP_USER_EVENT_SOURCE_BAD_SCHEME
Definition: stasis_app.h:269
@ STASIS_APP_USER_OK
Definition: stasis_app.h:266
@ STASIS_APP_USER_INTERNAL_ERROR
Definition: stasis_app.h:271
struct ast_bridge_snapshot * ast_bridge_get_snapshot_by_uniqueid(const char *bridge_id)
Returns the current snapshot for the bridge.
A multi object blob data structure to carry user event stasis messages.
Definition: stasis.c:1977

References ao2_cleanup, ao2_ref, app, app_name(), ast_app_get_topic(), ast_begins_with(), ast_bridge_get_snapshot_by_uniqueid(), ast_channel_snapshot_get_latest(), ast_endpoint_latest_snapshot(), ast_json_object_set(), ast_json_pack(), ast_json_ref(), ast_json_string_create(), ast_json_unref(), ast_log, ast_manager_get_topic(), ast_multi_object_blob_add(), ast_multi_object_blob_create(), ast_multi_user_event_type(), find_app_by_name(), LOG_ERROR, LOG_WARNING, NULL, RAII_VAR, STASIS_APP_USER_APP_NOT_FOUND, STASIS_APP_USER_EVENT_SOURCE_BAD_SCHEME, STASIS_APP_USER_EVENT_SOURCE_NOT_FOUND, STASIS_APP_USER_INTERNAL_ERROR, STASIS_APP_USER_OK, stasis_message_create(), stasis_publish(), STASIS_UMOS_BRIDGE, STASIS_UMOS_CHANNEL, STASIS_UMOS_ENDPOINT, and type.

Referenced by ast_ari_events_user_event().

◆ stasis_end_to_json()

static struct ast_json * stasis_end_to_json ( struct stasis_message message,
const struct stasis_message_sanitizer sanitize 
)
static

Definition at line 115 of file res_stasis.c.

117{
119 struct ast_json *msg;
120
121 if (sanitize && sanitize->channel_snapshot &&
122 sanitize->channel_snapshot(payload->snapshot)) {
123 return NULL;
124 }
125
126 msg = ast_json_pack("{s: s, s: O, s: o}",
127 "type", "StasisEnd",
128 "timestamp", ast_json_object_get(payload->blob, "timestamp"),
129 "channel", ast_channel_snapshot_to_json(payload->snapshot, sanitize));
130 if (!msg) {
131 ast_log(LOG_ERROR, "Failed to pack JSON for StasisEnd message\n");
132 return NULL;
133 }
134
135 return msg;
136}
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
Blob of data associated with a channel.
struct ast_channel_snapshot * snapshot
struct ast_json * blob
int(* channel_snapshot)(const struct ast_channel_snapshot *snapshot)
Callback which determines whether a channel should be sanitized from a message based on the channel's...
Definition: stasis.h:221

References ast_channel_snapshot_to_json(), ast_json_object_get(), ast_json_pack(), ast_log, ast_channel_blob::blob, stasis_message_sanitizer::channel_snapshot, LOG_ERROR, NULL, ast_channel_blob::snapshot, and stasis_message_data().

◆ STASIS_MESSAGE_TYPE_DEFN_LOCAL() [1/2]

STASIS_MESSAGE_TYPE_DEFN_LOCAL ( end_message_type  ,
to_json = stasis_end_to_json 
)

◆ STASIS_MESSAGE_TYPE_DEFN_LOCAL() [2/2]

STASIS_MESSAGE_TYPE_DEFN_LOCAL ( start_message_type  ,
to_json = stasis_start_to_json 
)

◆ stasis_start_to_json()

static struct ast_json * stasis_start_to_json ( struct stasis_message message,
const struct stasis_message_sanitizer sanitize 
)
static

Definition at line 147 of file res_stasis.c.

149{
151 struct ast_json *msg;
152
153 if (sanitize && sanitize->channel_snapshot &&
154 sanitize->channel_snapshot(payload->channel)) {
155 return NULL;
156 }
157
158 msg = ast_json_pack("{s: s, s: O, s: O, s: o}",
159 "type", "StasisStart",
160 "timestamp", ast_json_object_get(payload->blob, "timestamp"),
161 "args", ast_json_object_get(payload->blob, "args"),
162 "channel", ast_channel_snapshot_to_json(payload->channel, NULL));
163 if (!msg) {
164 ast_log(LOG_ERROR, "Failed to pack JSON for StasisStart message\n");
165 return NULL;
166 }
167
168 if (payload->replace_channel) {
169 int res = ast_json_object_set(msg, "replace_channel",
171
172 if (res) {
173 ast_json_unref(msg);
174 ast_log(LOG_ERROR, "Failed to append JSON for StasisStart message\n");
175 return NULL;
176 }
177 }
178
179 return msg;
180}

References ast_channel_snapshot_to_json(), ast_json_object_get(), ast_json_object_set(), ast_json_pack(), ast_json_unref(), ast_log, start_message_blob::blob, start_message_blob::channel, stasis_message_sanitizer::channel_snapshot, LOG_ERROR, NULL, start_message_blob::replace_channel, and stasis_message_data().

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 2274 of file res_stasis.c.

2275{
2277
2279
2280 cleanup();
2281
2283
2286
2289
2291 app_bridges = NULL;
2292
2295
2298
2299 STASIS_MESSAGE_TYPE_CLEANUP(end_message_type);
2300 STASIS_MESSAGE_TYPE_CLEANUP(start_message_type);
2301
2302 return 0;
2303}
int messaging_cleanup(void)
Tidy up the messaging layer.
Definition: messaging.c:529
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1515
void stasis_app_unregister_event_sources(void)
Unregister core event sources.
void stasis_app_control_shutdown(void)
Let Stasis app internals shut down.
Definition: control.c:1710

References ao2_cleanup, app_bridges, app_bridges_moh, app_bridges_playback, app_controls, apps_registry, cleanup(), messaging_cleanup(), NULL, stasis_app_control_shutdown(), stasis_app_unregister_event_sources(), and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by load_module().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Stasis application support" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load_pri = AST_MODPRI_APP_DEPEND - 1, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, }
static

Definition at line 2459 of file res_stasis.c.

◆ app_bridges

struct ao2_container* app_bridges

◆ app_bridges_moh

struct ao2_container* app_bridges_moh

◆ app_bridges_playback

struct ao2_container* app_bridges_playback

◆ app_controls

struct ao2_container* app_controls

◆ app_sanitizer

struct stasis_message_sanitizer app_sanitizer
Initial value:
= {
.channel_id = channel_id_sanitizer,
.channel_snapshot = channel_snapshot_sanitizer,
.channel = channel_sanitizer,
}
static int channel_sanitizer(const struct ast_channel *chan)
Sanitization callback for channels.
Definition: res_stasis.c:2315
static int channel_id_sanitizer(const char *id)
Sanitization callback for channel unique IDs.
Definition: res_stasis.c:2324

Sanitization callbacks for communication to Stasis applications.

Definition at line 2337 of file res_stasis.c.

Referenced by stasis_app_get_sanitizer().

◆ apps_registry

struct ao2_container* apps_registry

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 2459 of file res_stasis.c.

◆ event_sources

struct event_sources event_sources = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

◆ masquerade_store_info

const struct ast_datastore_info masquerade_store_info
static
Initial value:
= {
.type = "stasis-masquerade",
.chan_fixup = channel_stolen_cb,
.chan_breakdown = channel_replaced_cb,
}
static void channel_replaced_cb(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
Definition: res_stasis.c:1204
static void channel_stolen_cb(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan)
Definition: res_stasis.c:1173

Definition at line 1250 of file res_stasis.c.

Referenced by add_masquerade_store(), has_masquerade_store(), and remove_masquerade_store().

◆ replace_channel_store_info

const struct ast_datastore_info replace_channel_store_info
static
Initial value:
= {
.type = "replace-channel-store",
}
static void replace_channel_destroy(void *obj)
Definition: res_stasis.c:921

Definition at line 930 of file res_stasis.c.

Referenced by get_replace_channel_store().

◆ set_end_published_info

struct ast_datastore_info set_end_published_info
Initial value:
= {
.type = "stasis_end_published",
}

Definition at line 1328 of file res_stasis.c.

Referenced by remove_stasis_end_published(), stasis_app_channel_is_stasis_end_published(), and stasis_app_channel_set_stasis_end_published().

◆ stasis_internal_channel_info

const struct ast_datastore_info stasis_internal_channel_info
static
Initial value:
= {
.type = "stasis-internal-channel",
}

Definition at line 2348 of file res_stasis.c.

Referenced by set_internal_datastore(), and stasis_app_channel_is_internal().