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_source *	app_event_source_find (const char *uri)
static struct ast_json *	app_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_module *	AST_MODULE_SELF_SYM (void)
static struct ast_bridge *	bridge_create_common (const char *type, const char *name, const char *id, int invisible)
static struct ast_channel *	bridge_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	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_app *	find_app_by_name (const char *app_name)
static struct ast_channel_snapshot *	get_replace_channel_snapshot (struct ast_channel *chan)
static struct replace_channel_store *	get_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_channel *	prepare_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_bridge *	stasis_app_bridge_create (const char *type, const char *name, const char *id)
	Create a bridge of the specified type. More...
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. More...
void	stasis_app_bridge_destroy (const char *bridge_id)
	Destroy the bridge. More...
struct ast_bridge *	stasis_app_bridge_find_by_id (const char *bridge_id)
	Returns the bridge with the given id. More...
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. 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_channel *	stasis_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_control *	stasis_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_control *	stasis_app_control_find_by_channel (const struct ast_channel *chan)
	Returns the handler for the given channel. More...
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. 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_container *	stasis_app_get_all (void)
	Gets the names of all registered Stasis applications. More...
struct stasis_app *	stasis_app_get_by_name (const char *name)
	Retrieve a handle to a Stasis application by its name. More...
struct stasis_message_sanitizer *	stasis_app_get_sanitizer (void)
	Get the Stasis message sanitizer for app_stasis applications. More...
struct ast_json *	stasis_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_json *	stasis_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. 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_json *	stasis_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_json *	stasis_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_container *	app_bridges
struct ao2_container *	app_bridges_moh
struct ao2_container *	app_bridges_playback
struct ao2_container *	app_controls
struct stasis_message_sanitizer	app_sanitizer
	Sanitization callbacks for communication to Stasis applications. More...
struct ao2_container *	apps_registry
	Stasis application container. More...
static const struct ast_module_info *	ast_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 1897 of file res_stasis.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 2379 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 1726 of file res_stasis.c.

{
    RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
 
    if (!apps_registry) {
        return -1;
    }
 
    ao2_lock(apps_registry);
    app = ao2_find(apps_registry, app_name, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (app) {
        /*
         * We need to unlock the apps_registry before calling app_update to
         * prevent the possibility of a deadlock with the session.
         */
        ao2_unlock(apps_registry);
        app_update(app, handler, data);
        cleanup();
        return 0;
    }
 
    app = app_create(app_name, handler, data, all_events ? STASIS_APP_SUBSCRIBE_ALL : STASIS_APP_SUBSCRIBE_MANUAL);
    if (!app) {
        ao2_unlock(apps_registry);
        return -1;
    }
 
    if (all_events) {
        struct stasis_app_event_source *source;
 
        AST_RWLIST_RDLOCK(&event_sources);
        AST_LIST_TRAVERSE(&event_sources, source, next) {
            if (!source->subscribe) {
                continue;
            }
 
            source->subscribe(app, NULL);
        }
        AST_RWLIST_UNLOCK(&event_sources);
    }
    ao2_link_flags(apps_registry, app, OBJ_NOLOCK);
 
    ao2_unlock(apps_registry);
 
    /* We lazily clean up the apps_registry, because it's good enough to
     * prevent memory leaks, and we're lazy.
     */
    cleanup();
    return 0;
}

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 2379 of file res_stasis.c.

add_masquerade_store()

static int add_masquerade_store ( struct ast_channel *  chan )

static

Definition at line 1217 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    SCOPED_CHANNELLOCK(lock, chan);
    if (ast_channel_datastore_find(chan, &masquerade_store_info, NULL)) {
        return 0;
    }
 
    datastore = ast_datastore_alloc(&masquerade_store_info, NULL);
    if (!datastore) {
        return -1;
    }
 
    ast_channel_datastore_add(chan, datastore);
 
    return 0;
}

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.

{
    const struct stasis_app *object_left = obj;
    const struct stasis_app *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = stasis_app_name(object_right);
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(stasis_app_name(object_left), right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncmp(stasis_app_name(object_left), right_key, strlen(right_key));
        break;
    default:
        /*
         * What arg points to is specific to this traversal callback
         * and has no special meaning to astobj2.
         */
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    /*
     * At this point the traversal callback is identical to a sorted
     * container.
     */
    return CMP_MATCH;
}

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

app_event_source_find()

static struct stasis_app_event_source* app_event_source_find ( const char *  uri )

static

Definition at line 1897 of file res_stasis.c.

{
    struct stasis_app_event_source *source;
 
    AST_RWLIST_RDLOCK(&event_sources);
    AST_LIST_TRAVERSE(&event_sources, source, next) {
        if (ast_begins_with(uri, source->scheme)) {
            break;
        }
    }
    AST_RWLIST_UNLOCK(&event_sources);
 
    return source;
}

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

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 1850 of file res_stasis.c.

{
    struct stasis_app_event_source *source;
 
    AST_RWLIST_RDLOCK(&event_sources);
    AST_LIST_TRAVERSE(&event_sources, source, next) {
        if (source->to_json) {
            source->to_json(app, json);
        }
    }
    AST_RWLIST_UNLOCK(&event_sources);
 
    return json;
}

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

chan	The channel on which this will be set

Return values

NULL

on error

Returns

the name of the controlling app (must be ast_free()d)

Definition at line 967 of file res_stasis.c.

{
    struct replace_channel_store *replace = get_replace_channel_store(chan, 1);
    char *replace_channel_app;
 
    if (!replace) {
        return NULL;
    }
 
    replace_channel_app = replace->app;
    replace->app = NULL;
 
    return replace_channel_app;
}

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 1897 of file res_stasis.c.

{
    struct stasis_app *app = find_app_by_name(app_name);
    int i;
 
    ast_assert(handler != NULL);
 
    if (!app) {
        return STASIS_ASR_APP_NOT_FOUND;
    }
 
    for (i = 0; i < event_sources_count; ++i) {
        const char *uri = event_source_uris[i];
        struct stasis_app_event_source *event_source;
        enum stasis_app_subscribe_res res;
 
        event_source = app_event_source_find(uri);
        if (!event_source) {
            ast_log(LOG_WARNING, "Invalid scheme: %s\n", uri);
            ao2_ref(app, -1);
 
            return STASIS_ASR_EVENT_SOURCE_BAD_SCHEME;
        }
 
        res = handler(app, uri, event_source);
        if (res != STASIS_ASR_OK) {
            ao2_ref(app, -1);
 
            return res;
        }
    }
 
    if (json) {
        ast_debug(3, "%s: Successful; setting results\n", app_name);
        *json = stasis_app_object_to_json(app);
    }
 
    ao2_ref(app, -1);
 
    return STASIS_ASR_OK;
}

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.

{
    const struct stasis_app *app;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        app = obj;
        key = stasis_app_name(app);
        break;
    default:
        /* Hash can only work on something with a full key. */
        ast_assert(0);
        return 0;
    }
    return ast_str_hash(key);
}

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

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

app	The app that owns the channel
chan	The channel for which the message is being sent

Return values

zero	on success

Returns

non-zero on failure

Definition at line 1083 of file res_stasis.c.

{
    struct stasis_message_sanitizer *sanitize = stasis_app_get_sanitizer();
    struct ast_json *blob;
    struct stasis_message *msg;
 
    if (sanitize && sanitize->channel
        && sanitize->channel(chan)) {
        return 0;
    }
 
    blob = ast_json_pack("{s: s, s: o}",
        "app", stasis_app_name(app),
        "timestamp", ast_json_timeval(ast_tvnow(), NULL)
        );
    if (!blob) {
        ast_log(LOG_ERROR, "Error packing JSON for StasisEnd message\n");
        return -1;
    }
 
    remove_masquerade_store(chan);
    app_unsubscribe_channel(app, chan);
    msg = ast_channel_blob_create(chan, end_message_type(), blob);
    if (msg) {
        stasis_publish(ast_app_get_topic(app), msg);
    }
    ao2_cleanup(msg);
    ast_json_unref(blob);
 
    return 0;
}

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

chan	The channel on which this will be set
replace_app	The app that will be controlling this channel

Return values

zero	success
non-zero	failure

Definition at line 931 of file res_stasis.c.

{
    struct replace_channel_store *replace = get_replace_channel_store(chan, 0);
 
    if (!replace) {
        return -1;
    }
 
    ast_free(replace->app);
    replace->app = NULL;
 
    if (replace_app) {
        replace->app = ast_strdup(replace_app);
        if (!replace->app) {
            return -1;
        }
    }
 
    return 0;
}

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

chan	The channel on which this will be set
replace_snapshot	The snapshot of the channel that is being replaced

Return values

zero	success
non-zero	failure

Definition at line 919 of file res_stasis.c.

{
    struct replace_channel_store *replace = get_replace_channel_store(chan, 0);
 
    if (!replace) {
        return -1;
    }
 
    ao2_replace(replace->snapshot, replace_snapshot);
    return 0;
}

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 1897 of file res_stasis.c.

{
    const char *app_name = stasis_app_name(app);
    RAII_VAR(void *, obj, NULL, ao2_cleanup);
 
    ast_debug(3, "%s: Checking %s\n", app_name, uri);
 
    if (!ast_strlen_zero(uri + strlen(event_source->scheme)) &&
        (!event_source->find || (!(obj = event_source->find(app, uri + strlen(event_source->scheme)))))) {
        ast_log(LOG_WARNING, "Event source not found: %s\n", uri);
        return STASIS_ASR_EVENT_SOURCE_NOT_FOUND;
    }
 
    ast_debug(3, "%s: Subscribing to %s\n", app_name, uri);
 
    if (!event_source->subscribe || (event_source->subscribe(app, obj))) {
        ast_log(LOG_WARNING, "Error subscribing app '%s' to '%s'\n",
            app_name, uri);
        return STASIS_ASR_INTERNAL_ERROR;
    }
 
    return STASIS_ASR_OK;
}

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 1897 of file res_stasis.c.

{
    const char *app_name = stasis_app_name(app);
    const char *id = uri + strlen(event_source->scheme);
 
    if (!event_source->is_subscribed ||
        (!event_source->is_subscribed(app, id))) {
        return STASIS_ASR_EVENT_SOURCE_NOT_FOUND;
    }
 
    ast_debug(3, "%s: Unsubscribing from %s\n", app_name, uri);
 
    if (!event_source->unsubscribe || (event_source->unsubscribe(app, id))) {
        ast_log(LOG_WARNING, "Error unsubscribing app '%s' to '%s'\n",
            app_name, uri);
        return -1;
    }
    return 0;
}

append_name()

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

static

Definition at line 1699 of file res_stasis.c.

{
    struct stasis_app *app = obj;
    struct ao2_container *apps = arg;
 
    ast_str_container_add(apps, stasis_app_name(app));
    return 0;
}

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 2379 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 795 of file res_stasis.c.

{
    struct ast_bridge *bridge;
    char *requested_type, *requested_types = ast_strdupa(S_OR(type, "mixing"));
    int capabilities = 0;
    int flags = AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM | AST_BRIDGE_FLAG_MERGE_INHIBIT_TO
        | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM | AST_BRIDGE_FLAG_SWAP_INHIBIT_TO
        | AST_BRIDGE_FLAG_TRANSFER_BRIDGE_ONLY;
    enum ast_bridge_video_mode_type video_mode = AST_BRIDGE_VIDEO_MODE_TALKER_SRC;
 
    if (invisible) {
        flags |= AST_BRIDGE_FLAG_INVISIBLE;
    }
 
    while ((requested_type = strsep(&requested_types, ","))) {
        requested_type = ast_strip(requested_type);
 
        if (!strcmp(requested_type, "mixing")) {
            capabilities |= STASIS_BRIDGE_MIXING_CAPABILITIES;
            flags |= AST_BRIDGE_FLAG_SMART;
        } else if (!strcmp(requested_type, "holding")) {
            capabilities |= AST_BRIDGE_CAPABILITY_HOLDING;
        } else if (!strcmp(requested_type, "dtmf_events") ||
            !strcmp(requested_type, "proxy_media")) {
            capabilities &= ~AST_BRIDGE_CAPABILITY_NATIVE;
        } else if (!strcmp(requested_type, "video_sfu")) {
            video_mode = AST_BRIDGE_VIDEO_MODE_SFU;
        } else if (!strcmp(requested_type, "video_single")) {
            video_mode = AST_BRIDGE_VIDEO_MODE_SINGLE_SRC;
        }
    }
 
    /* For an SFU video bridge we ensure it always remains in multimix for the best experience. */
    if (video_mode == AST_BRIDGE_VIDEO_MODE_SFU) {
        capabilities = AST_BRIDGE_CAPABILITY_MULTIMIX;
        flags &= ~AST_BRIDGE_FLAG_SMART;
    }
 
    if (!capabilities
        /* Holding and mixing capabilities don't mix. */
        || ((capabilities & AST_BRIDGE_CAPABILITY_HOLDING)
            && (capabilities & (STASIS_BRIDGE_MIXING_CAPABILITIES)))) {
        return NULL;
    }
 
    bridge = bridge_stasis_new(capabilities, flags, name, id, video_mode);
    if (bridge) {
        if (!ao2_link(app_bridges, bridge)) {
            ast_bridge_destroy(bridge, 0);
            bridge = NULL;
        }
    }
 
    return bridge;
}

References ao2_link, app_bridges, AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_CAPABILITY_MULTIMIX, AST_BRIDGE_CAPABILITY_NATIVE, 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_strdupa, ast_strip(), bridge_stasis_new(), name, NULL, S_OR, 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 574 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *new_wrapper;
    struct ast_channel *chan;
    pthread_t threadid;
 
    chan = prepare_bridge_moh_channel();
    if (!chan) {
        return NULL;
    }
 
    if (stasis_app_channel_unreal_set_internal(chan)) {
        ast_hangup(chan);
        return NULL;
    }
 
    if (ast_unreal_channel_push_to_bridge(chan, bridge,
        AST_BRIDGE_CHANNEL_FLAG_IMMOVABLE | AST_BRIDGE_CHANNEL_FLAG_LONELY)) {
        ast_hangup(chan);
        return NULL;
    }
 
    new_wrapper = ao2_alloc_options(sizeof(*new_wrapper),
        stasis_app_bridge_channel_wrapper_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!new_wrapper) {
        ast_hangup(chan);
        return NULL;
    }
 
    if (ast_string_field_init(new_wrapper, AST_UUID_STR_LEN + AST_CHANNEL_NAME)
        || ast_string_field_set(new_wrapper, bridge_id, bridge->uniqueid)
        || ast_string_field_set(new_wrapper, channel_id, ast_channel_uniqueid(chan))) {
        ao2_ref(new_wrapper, -1);
        ast_hangup(chan);
        return NULL;
    }
 
    if (!ao2_link_flags(app_bridges_moh, new_wrapper, OBJ_NOLOCK)) {
        ao2_ref(new_wrapper, -1);
        ast_hangup(chan);
        return NULL;
    }
 
    /* Pass the new_wrapper ref to moh_channel_thread() */
    if (ast_pthread_create_detached(&threadid, NULL, moh_channel_thread, new_wrapper)) {
        ast_log(LOG_ERROR, "Failed to create channel thread. Abandoning MOH channel creation.\n");
        ao2_unlink_flags(app_bridges_moh, new_wrapper, OBJ_NOLOCK);
        ao2_ref(new_wrapper, -1);
        ast_hangup(chan);
        return NULL;
    }
 
    return chan;
}

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 429 of file res_stasis.c.

{
    const struct stasis_app_bridge_channel_wrapper *object_left = obj;
    const struct stasis_app_bridge_channel_wrapper *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
            right_key = object_right->bridge_id;
    case OBJ_SEARCH_KEY:
            cmp = strcmp(object_left->bridge_id, right_key);
            break;
    case OBJ_SEARCH_PARTIAL_KEY:
            cmp = strncmp(object_left->bridge_id, right_key, strlen(right_key));
            break;
    default:
            cmp = 0;
            break;
    }
    if (cmp) {
        return 0;
    }
    return CMP_MATCH;
}

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

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 462 of file res_stasis.c.

{
    const struct stasis_app_bridge_channel_wrapper *wrapper;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        wrapper = obj;
        key = wrapper->bridge_id;
        break;
    default:
        /* Hash can only work on something with a full key. */
        ast_assert(0);
        return 0;
    }
    return ast_str_hash(key);
}

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

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 483 of file res_stasis.c.

{
    const struct stasis_app_bridge_channel_wrapper *left = obj_left;
    const struct stasis_app_bridge_channel_wrapper *right = obj_right;
    const char *right_key = obj_right;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = right->bridge_id;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(left->bridge_id, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        cmp = strncmp(left->bridge_id, right_key, strlen(right_key));
        break;
    default:
        /* Sort can only work on something with a full or partial key. */
        ast_assert(0);
        cmp = 0;
        break;
    }
    return cmp;
}

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

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.

{
    const struct ast_bridge *object_left = obj;
    const struct ast_bridge *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = object_right->uniqueid;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(object_left->uniqueid, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncmp(object_left->uniqueid, right_key, strlen(right_key));
        break;
    default:
        /*
         * What arg points to is specific to this traversal callback
         * and has no special meaning to astobj2.
         */
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    /*
     * At this point the traversal callback is identical to a sorted
     * container.
     */
    return CMP_MATCH;
}

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

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.

{
    const struct ast_bridge *bridge;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        bridge = obj;
        key = bridge->uniqueid;
        break;
    default:
        /* Hash can only work on something with a full key. */
        ast_assert(0);
        return 0;
    }
    return ast_str_hash(key);
}

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

channel_id_sanitizer()

static int channel_id_sanitizer ( const char *  id )

static

Sanitization callback for channel unique IDs.

Definition at line 2245 of file res_stasis.c.

{
    struct ast_channel_snapshot *snapshot;
    int ret;
 
    snapshot = ast_channel_snapshot_get_latest(id);
    ret = channel_snapshot_sanitizer(snapshot);
    ao2_cleanup(snapshot);
 
    return ret;
}

channel_replaced_cb()

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

static

Definition at line 1159 of file res_stasis.c.

{
    RAII_VAR(struct ast_channel_snapshot *, new_snapshot, NULL, ao2_cleanup);
    RAII_VAR(struct ast_channel_snapshot *, old_snapshot, NULL, ao2_cleanup);
    struct stasis_app_control *control;
 
    /* At this point, new_chan is the channel pointer that is in Stasis() and
     * has the unknown channel's name in it while old_chan is the channel pointer
     * that is not in Stasis(), but has the guts of the channel that Stasis() knows
     * about */
 
    /* grab a snapshot for the channel that is jumping into Stasis() */
    new_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(new_chan));
    if (!new_snapshot) {
        ast_log(LOG_ERROR, "Could not get snapshot for masquerading channel\n");
        return;
    }
 
    /* grab a snapshot for the channel that has been kicked out of Stasis() */
    old_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(old_chan));
    if (!old_snapshot) {
        ast_log(LOG_ERROR, "Could not get snapshot for masqueraded channel\n");
        return;
    }
 
    /*
     * Find, unlink, and relink control since the channel has a new
     * name/uniqueid and its hash has changed.
     */
    control = ao2_callback(app_controls, OBJ_UNLINK, masq_match_cb, new_chan);
    if (!control) {
        ast_log(LOG_ERROR, "Could not find control for masquerading channel\n");
        return;
    }
    ao2_link(app_controls, control);
 
 
    /* send the StasisStart with replace_channel to the app */
    send_start_msg_snapshots(new_chan, control_app(control), 0, NULL, new_snapshot,
        old_snapshot);
    /* send the StasisEnd message to the app */
    app_send_end_msg(control_app(control), old_chan);
 
    ao2_cleanup(control);
}

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 2236 of file res_stasis.c.

{
    if (!chan || !(ast_channel_tech(chan)->properties & AST_CHAN_TP_INTERNAL)) {
        return 0;
    }
    return 1;
}

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 2227 of file res_stasis.c.

{
    if (!snapshot || !(snapshot->base->tech_properties & AST_CHAN_TP_INTERNAL)) {
        return 0;
    }
    return 1;
}

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

channel_stolen_cb()

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

static

Definition at line 1128 of file res_stasis.c.

{
    struct stasis_app_control *control;
 
    /*
     * At this point, old_chan is the channel pointer that is in Stasis() and
     * has the unknown channel's name in it while new_chan is the channel pointer
     * that is not in Stasis(), but has the guts of the channel that Stasis() knows
     * about.
     *
     * Find and unlink control since the channel has a new name/uniqueid
     * and its hash has changed.  Since the channel is leaving stasis don't
     * bother putting it back into the container.  Nobody is going to
     * remove it from the container later.
     */
    control = ao2_callback(app_controls, OBJ_UNLINK, masq_match_cb, old_chan);
    if (!control) {
        ast_log(LOG_ERROR, "Could not find control for masqueraded channel\n");
        return;
    }
 
    /* send the StasisEnd message to the app */
    stasis_app_channel_set_stasis_end_published(new_chan);
    app_send_end_msg(control_app(control), new_chan);
 
    /* remove the datastore */
    remove_masquerade_store(old_chan);
 
    ao2_cleanup(control);
}

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.

{
    ao2_callback(apps_registry, OBJ_MULTIPLE | OBJ_NODATA | OBJ_UNLINK,
        cleanup_cb, NULL);
}

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.

{
    struct stasis_app *app = obj;
 
    if (!app_is_finished(app)) {
        return 0;
    }
 
    ast_verb(1, "Shutting down application '%s'\n", stasis_app_name(app));
    app_shutdown(app);
 
    return CMP_MATCH;
 
}

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.

{
    const struct stasis_app_control *object_left = obj;
    const struct stasis_app_control *object_right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = stasis_app_control_get_channel_id(object_right);
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(stasis_app_control_get_channel_id(object_left), right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncmp(stasis_app_control_get_channel_id(object_left), right_key, strlen(right_key));
        break;
    default:
        /*
         * What arg points to is specific to this traversal callback
         * and has no special meaning to astobj2.
         */
        cmp = 0;
        break;
    }
    if (cmp) {
        return 0;
    }
    /*
     * At this point the traversal callback is identical to a sorted
     * container.
     */
    return CMP_MATCH;
}

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

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.

{
    const struct stasis_app_control *control;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        control = obj;
        key = stasis_app_control_get_channel_id(control);
        break;
    default:
        /* Hash can only work on something with a full key. */
        ast_assert(0);
        return 0;
    }
    return ast_str_hash(key);
}

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

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 785 of file res_stasis.c.

{
    if (!control) {
        return;
    }
 
    ao2_unlink(app_controls, control);
    ao2_cleanup(control);
}

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 1679 of file res_stasis.c.

{
    struct stasis_app *res = NULL;
 
    if (!apps_registry) {
        return NULL;
    }
 
    if (!ast_strlen_zero(app_name)) {
        res = ao2_find(apps_registry, app_name, OBJ_SEARCH_KEY);
    }
 
    return res;
}

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

Referenced by stasis_app_get_by_name(), and stasis_app_to_json().

get_replace_channel_snapshot()

static struct ast_channel_snapshot* get_replace_channel_snapshot ( struct ast_channel *  chan )

static

Definition at line 952 of file res_stasis.c.

{
    struct replace_channel_store *replace = get_replace_channel_store(chan, 1);
    struct ast_channel_snapshot *replace_channel_snapshot;
 
    if (!replace) {
        return NULL;
    }
 
    replace_channel_snapshot = replace->snapshot;
    replace->snapshot = NULL;
 
    return replace_channel_snapshot;
}

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 890 of file res_stasis.c.

{
    struct ast_datastore *datastore;
    struct replace_channel_store *ret;
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &replace_channel_store_info, NULL);
    if (!datastore && !no_create) {
        datastore = ast_datastore_alloc(&replace_channel_store_info, NULL);
        if (datastore) {
            ast_channel_datastore_add(chan, datastore);
        }
    }
 
    if (!datastore) {
        ast_channel_unlock(chan);
        return NULL;
    }
 
    if (!datastore->data) {
        datastore->data = ast_calloc(1, sizeof(struct replace_channel_store));
    }
 
    ret = datastore->data;
    ast_channel_unlock(chan);
 
    return ret;
}

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 1211 of file res_stasis.c.

{
    SCOPED_CHANNELLOCK(lock, chan);
    return !!ast_channel_datastore_find(chan, &masquerade_store_info, NULL);
}

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 2337 of file res_stasis.c.

{
    if (STASIS_MESSAGE_TYPE_INIT(start_message_type) != 0) {
        return AST_MODULE_LOAD_DECLINE;
    }
    if (STASIS_MESSAGE_TYPE_INIT(end_message_type) != 0) {
        return AST_MODULE_LOAD_DECLINE;
    }
    apps_registry = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        APPS_NUM_BUCKETS, app_hash, NULL, app_compare);
    app_controls = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        CONTROLS_NUM_BUCKETS, control_hash, NULL, control_compare);
    app_bridges = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        BRIDGES_NUM_BUCKETS, bridges_hash, NULL, bridges_compare);
    app_bridges_moh = ao2_container_alloc_hash(
        AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        37, bridges_channel_hash_fn, NULL, bridges_channel_compare);
    app_bridges_playback = ao2_container_alloc_hash(
        AO2_ALLOC_OPT_LOCK_MUTEX, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT,
        37, bridges_channel_hash_fn, bridges_channel_sort_fn, NULL);
    if (!apps_registry || !app_controls || !app_bridges || !app_bridges_moh || !app_bridges_playback) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    if (messaging_init()) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    bridge_stasis_init();
 
    stasis_app_register_event_sources();
 
    return AST_MODULE_LOAD_SUCCESS;
}

masq_match_cb()

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

static

Definition at line 1115 of file res_stasis.c.

{
    struct stasis_app_control *control = obj;
    struct ast_channel *chan = data;
 
    if (!strcmp(ast_channel_uniqueid(chan),
        stasis_app_control_get_channel_id(control))) {
        return CMP_MATCH;
    }
 
    return 0;
}

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 529 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *moh_wrapper = data;
    struct ast_channel *moh_channel = ast_channel_get_by_name(moh_wrapper->channel_id);
    struct ast_frame *f;
 
    if (!moh_channel) {
        ao2_unlink(app_bridges_moh, moh_wrapper);
        ao2_ref(moh_wrapper, -1);
        return NULL;
    }
 
    /* Read and discard any frame coming from the stasis bridge. */
    for (;;) {
        if (ast_waitfor(moh_channel, -1) < 0) {
            /* Error or hungup */
            break;
        }
 
        f = ast_read(moh_channel);
        if (!f) {
            /* Hungup */
            break;
        }
        ast_frfree(f);
    }
 
    ao2_unlink(app_bridges_moh, moh_wrapper);
    ao2_ref(moh_wrapper, -1);
 
    ast_moh_stop(moh_channel);
    ast_hangup(moh_channel);
 
    return NULL;
}

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 698 of file res_stasis.c.

{
    char *bridge_id = data;
 
    remove_bridge_playback(bridge_id);
}

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 691 of file res_stasis.c.

{
    char *bridge_id = data;
 
    remove_bridge_playback(bridge_id);
}

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 510 of file res_stasis.c.

{
    struct ast_channel *chan;
    struct ast_format_cap *cap;
 
    cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    if (!cap) {
        return NULL;
    }
 
    ast_format_cap_append(cap, ast_format_slin, 0);
 
    chan = ast_request("Announcer", cap, NULL, NULL, "ARI_MOH", NULL);
    ao2_ref(cap, -1);
 
    return chan;
}

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 673 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *wrapper;
    struct stasis_app_control *control;
 
    wrapper = ao2_find(app_bridges_playback, bridge_id, OBJ_SEARCH_KEY | OBJ_UNLINK);
 
    if (wrapper) {
        control = stasis_app_control_find_by_channel_id(wrapper->channel_id);
        if (control) {
            ao2_unlink(app_controls, control);
            ao2_ref(control, -1);
        }
        ao2_ref(wrapper, -1);
    }
    ast_free(bridge_id);
}

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 1236 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    SCOPED_CHANNELLOCK(lock, chan);
    datastore = ast_channel_datastore_find(chan, &masquerade_store_info, NULL);
    if (!datastore) {
        return;
    }
 
    ast_channel_datastore_remove(chan, datastore);
    ast_datastore_free(datastore);
}

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 1310 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &set_end_published_info, NULL);
    if (datastore) {
        ast_channel_datastore_remove(chan, datastore);
        ast_datastore_free(datastore);
    }
    ast_channel_unlock(chan);
}

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 876 of file res_stasis.c.

{
    struct replace_channel_store *replace = obj;
 
    ao2_cleanup(replace->snapshot);
    ast_free(replace->app);
    ast_free(replace);
}

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 1057 of file res_stasis.c.

{
    int ret = -1;
    struct ast_channel_snapshot *snapshot;
    struct ast_channel_snapshot *replace_channel_snapshot;
 
    ast_assert(chan != NULL);
 
    replace_channel_snapshot = get_replace_channel_snapshot(chan);
 
    /* Set channel info */
    ast_channel_lock(chan);
    snapshot = ast_channel_snapshot_create(chan);
    ast_channel_unlock(chan);
    if (snapshot) {
        ret = send_start_msg_snapshots(chan, app, argc, argv, snapshot, replace_channel_snapshot);
        ao2_ref(snapshot, -1);
    }
    ao2_cleanup(replace_channel_snapshot);
 
    return ret;
}

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 991 of file res_stasis.c.

{
    struct ast_json *json_blob;
    struct ast_json *json_args;
    struct start_message_blob *payload;
    struct stasis_message *msg;
    int i;
 
    if (app_subscribe_channel(app, chan)) {
        ast_log(LOG_ERROR, "Error subscribing app '%s' to channel '%s'\n",
            stasis_app_name(app), ast_channel_name(chan));
        return -1;
    }
 
    payload = ao2_alloc(sizeof(*payload), start_message_blob_dtor);
    if (!payload) {
        ast_log(LOG_ERROR, "Error packing JSON for StasisStart message\n");
        return -1;
    }
 
    payload->channel = ao2_bump(snapshot);
    payload->replace_channel = ao2_bump(replace_channel_snapshot);
 
    json_blob = ast_json_pack("{s: s, s: o, s: []}",
        "app", stasis_app_name(app),
        "timestamp", ast_json_timeval(ast_tvnow(), NULL),
        "args");
    if (!json_blob) {
        ast_log(LOG_ERROR, "Error packing JSON for StasisStart message\n");
        ao2_ref(payload, -1);
        return -1;
    }
    payload->blob = json_blob;
 
 
    /* Append arguments to args array */
    json_args = ast_json_object_get(json_blob, "args");
    ast_assert(json_args != NULL);
    for (i = 0; i < argc; ++i) {
        int r = ast_json_array_append(json_args,
                          ast_json_string_create(argv[i]));
        if (r != 0) {
            ast_log(LOG_ERROR, "Error appending to StasisStart message\n");
            ao2_ref(payload, -1);
            return -1;
        }
    }
 
 
    msg = stasis_message_create(start_message_type(), payload);
    ao2_ref(payload, -1);
    if (!msg) {
        ast_log(LOG_ERROR, "Error sending StasisStart message\n");
        return -1;
    }
 
    if (replace_channel_snapshot) {
        app_unsubscribe_channel_id(app, replace_channel_snapshot->base->uniqueid);
    }
    stasis_publish(ast_app_get_topic(app), msg);
    ao2_ref(msg, -1);
    return 0;
}

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 2273 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_channel_datastore_find(chan, &stasis_internal_channel_info, NULL);
    if (!datastore) {
        datastore = ast_datastore_alloc(&stasis_internal_channel_info, NULL);
        if (!datastore) {
            return -1;
        }
        ast_channel_datastore_add(chan, datastore);
    }
    return 0;
}

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 982 of file res_stasis.c.

{
    struct start_message_blob *payload = obj;
 
    ao2_cleanup(payload->channel);
    ao2_cleanup(payload->replace_channel);
    ast_json_unref(payload->blob);
}

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 455 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *wrapper = obj;
    ast_string_field_free_memory(wrapper);
}

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

type	The type of bridge to be created
name	Optional name to give to the bridge
id	Optional Unique ID to give to the bridge

Returns

New bridge.

Return values

NULL

on error.

Definition at line 851 of file res_stasis.c.

{
    return bridge_create_common(type, name, id, 0);
}

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

type	The type of bridge to be created
name	Optional name to give to the bridge
id	Optional Unique ID to give to the bridge

Returns

New bridge.

Return values

NULL

on error.

Definition at line 856 of file res_stasis.c.

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

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_id

Uniqueid of bridge to be destroyed

Definition at line 861 of file res_stasis.c.

{
    struct ast_bridge *bridge = stasis_app_bridge_find_by_id(bridge_id);
    if (!bridge) {
        return;
    }
    ao2_unlink(app_bridges, bridge);
    ast_bridge_destroy(bridge, 0);
}

References ao2_unlink, app_bridges, ast_bridge_destroy(), 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_id

Uniqueid of the bridge.

Returns

NULL bridge not created by a Stasis application, or bridge does not exist.

Pointer to bridge.

Definition at line 774 of file res_stasis.c.

{
    return ao2_find(app_bridges, bridge_id, OBJ_SEARCH_KEY);
}

References ao2_find, app_bridges, and OBJ_SEARCH_KEY.

Referenced by 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

bridge

Bridge 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 629 of file res_stasis.c.

{
    struct ast_channel *chan;
    struct stasis_app_bridge_channel_wrapper *moh_wrapper;
 
    ao2_lock(app_bridges_moh);
    moh_wrapper = ao2_find(app_bridges_moh, bridge->uniqueid, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!moh_wrapper) {
        chan = bridge_moh_create(bridge);
    }
    ao2_unlock(app_bridges_moh);
 
    if (moh_wrapper) {
        chan = ast_channel_get_by_name(moh_wrapper->channel_id);
        ao2_ref(moh_wrapper, -1);
    }
 
    return chan;
}

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

bridge

Bridge we want to stop the MOH on

Returns

-1 if no moh channel could be found and stopped

0 on success

Definition at line 649 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *moh_wrapper;
    struct ast_channel *chan;
 
    moh_wrapper = ao2_find(app_bridges_moh, bridge->uniqueid, OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (!moh_wrapper) {
        return -1;
    }
 
    chan = ast_channel_get_by_name(moh_wrapper->channel_id);
    ao2_ref(moh_wrapper, -1);
    if (!chan) {
        return -1;
    }
 
    ast_moh_stop(chan);
    ast_softhangup(chan, AST_CAUSE_NORMAL_CLEARING);
    ao2_cleanup(chan);
 
    return 0;
}

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

bridge	Bridge we are adding the playback channel for
chan	Channel being added as a playback channel (must be ;1)
control	The app control structure for the playback channel

Return values

-1	failed to add channel for any reason
0	on success

Definition at line 705 of file res_stasis.c.

{
    RAII_VAR(struct stasis_app_bridge_channel_wrapper *, new_wrapper, NULL, ao2_cleanup);
    char *bridge_id = ast_strdup(bridge->uniqueid);
 
    if (!bridge_id) {
        return -1;
    }
 
    if (ast_bridge_set_after_callback(chan,
        playback_after_bridge_cb, playback_after_bridge_cb_failed, bridge_id)) {
        ast_free(bridge_id);
        return -1;
    }
 
    new_wrapper = ao2_alloc_options(sizeof(*new_wrapper),
        stasis_app_bridge_channel_wrapper_destructor, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!new_wrapper) {
        return -1;
    }
 
    if (ast_string_field_init(new_wrapper, 32)) {
        return -1;
    }
 
    ast_string_field_set(new_wrapper, bridge_id, bridge->uniqueid);
    ast_string_field_set(new_wrapper, channel_id, ast_channel_uniqueid(chan));
 
    if (!ao2_link(app_bridges_playback, new_wrapper)) {
        return -1;
    }
 
    ao2_link(app_controls, control);
    return 0;
}

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

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

bridge

Bridge 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 759 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *playback_wrapper;
    struct ast_channel *chan;
 
    playback_wrapper = ao2_find(app_bridges_playback, bridge->uniqueid, OBJ_SEARCH_KEY);
    if (!playback_wrapper) {
        return NULL;
    }
 
    chan = ast_channel_get_by_name(playback_wrapper->channel_id);
    ao2_ref(playback_wrapper, -1);
    return chan;
}

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_id	The unique ID of the bridge the playback channel is in.
control	The app control structure for the playback channel

Definition at line 743 of file res_stasis.c.

{
    struct stasis_app_bridge_channel_wrapper *wrapper;
 
    wrapper = ao2_find(app_bridges_playback, bridge_id, OBJ_SEARCH_KEY | OBJ_UNLINK);
    if (wrapper) {
        /* If wrapper is not found, then that means the after bridge callback has been
         * called or is in progress. No need to unlink the control here since that has
         * been done or is about to be done in the after bridge callback
         */
        ao2_unlink(app_controls, control);
        ao2_ref(wrapper, -1);
    }
}

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_found(), 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

chan	The channel to check.

Return values

0	No
1	Yes

Definition at line 2322 of file res_stasis.c.

{
    struct ast_datastore *datastore;
    int res = 0;
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &stasis_internal_channel_info, NULL);
    if (datastore) {
        res = 1;
    }
    ast_channel_unlock(chan);
 
    return res;
}

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

chan	The channel upon which the query rests.

Return values

0	No
1	Yes

Definition at line 1299 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &set_end_published_info, NULL);
    ast_channel_unlock(chan);
 
    return datastore ? 1 : 0;
}

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

chan	The channel to mark.

Return values

zero	Success
non-zero	Failure

Definition at line 2311 of file res_stasis.c.

{
    int res;
 
    ast_channel_lock(chan);
    res = set_internal_datastore(chan);
    ast_channel_unlock(chan);
 
    return res;
}

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

chan	The channel that is exiting Stasis.

Definition at line 1287 of file res_stasis.c.

{
    struct ast_datastore *datastore;
 
    datastore = ast_datastore_alloc(&set_end_published_info, NULL);
    if (datastore) {
        ast_channel_lock(chan);
        ast_channel_datastore_add(chan, datastore);
        ast_channel_unlock(chan);
    }
}

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

chan	The channel to mark.

Return values

zero	Success
non-zero	Failure

Definition at line 2288 of file res_stasis.c.

{
    struct ast_channel *outchan = NULL, *outowner = NULL;
    int res = 0;
    struct ast_unreal_pvt *unreal_pvt = ast_channel_tech_pvt(chan);
 
    ao2_ref(unreal_pvt, +1);
    ast_unreal_lock_all(unreal_pvt, &outowner, &outchan);
    if (outowner) {
        res |= set_internal_datastore(outowner);
        ast_channel_unlock(outowner);
        ast_channel_unref(outowner);
    }
    if (outchan) {
        res |= set_internal_datastore(outchan);
        ast_channel_unlock(outchan);
        ast_channel_unref(outchan);
    }
    ao2_unlock(unreal_pvt);
    ao2_ref(unreal_pvt, -1);
    return res;
}

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

chan	Channel 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.

{
    return control_create(chan, NULL);
}

References control_create(), and NULL.

Referenced by ari_bridges_play_found(), 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

chan	Channel to handle
control	Control object to execute

Definition at line 1250 of file res_stasis.c.

{
    while (!control_is_done(control)) {
        int command_count;
        command_count = control_dispatch_all(control, chan);
 
        ao2_lock(control);
 
        if (control_command_count(control)) {
            /* If the command queue isn't empty, something added to the queue before it was locked. */
            ao2_unlock(control);
            continue;
        }
 
        if (command_count == 0 || ast_channel_fdno(chan) == -1) {
            control_mark_done(control);
            ao2_unlock(control);
            break;
        }
        ao2_unlock(control);
    }
}

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

chan	Channel to handle.

Returns

NULL channel not in Stasis application.

Pointer to res_stasis handler.

Definition at line 338 of file res_stasis.c.

{
    if (chan == NULL) {
        return NULL;
    }
 
    return stasis_app_control_find_by_channel_id(
        ast_channel_uniqueid(chan));
}

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

Referenced by 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_id

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

{
    return ao2_find(app_controls, channel_id, OBJ_SEARCH_KEY);
}

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

control

Control object to flush command queue.

Definition at line 1278 of file res_stasis.c.

{
    control_flush_queue(control);
}

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

control

Which control object is being evaluated

Definition at line 1273 of file res_stasis.c.

{
    return control_is_done(control);
}

References control_is_done().

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 1324 of file res_stasis.c.

{
    RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_app_control *, control, NULL, control_unlink);
    struct ast_bridge *bridge = NULL;
    int res = 0;
    int needs_depart;
 
    ast_assert(chan != NULL);
 
    /* Just in case there's a lingering indication that the channel has had a stasis
     * end published on it, remove that now.
     */
    remove_stasis_end_published(chan);
 
    if (!apps_registry) {
        return -1;
    }
 
    app = ao2_find(apps_registry, app_name, OBJ_SEARCH_KEY);
    if (!app) {
        ast_log(LOG_ERROR,
            "Stasis app '%s' not registered\n", app_name);
        return -1;
    }
    if (!app_is_active(app)) {
        ast_log(LOG_ERROR,
            "Stasis app '%s' not active\n", app_name);
        return -1;
    }
 
    control = control_create(chan, app);
    if (!control) {
        ast_log(LOG_ERROR, "Control allocation failed or Stasis app '%s' not registered\n", app_name);
        return -1;
    }
 
    if (!control_app(control)) {
        ast_log(LOG_ERROR, "Stasis app '%s' not registered\n", app_name);
        return -1;
    }
 
    if (!app_is_active(control_app(control))) {
        ast_log(LOG_ERROR, "Stasis app '%s' not active\n", app_name);
        return -1;
    }
    ao2_link(app_controls, control);
 
    if (add_masquerade_store(chan)) {
        ast_log(LOG_ERROR, "Failed to attach masquerade detector\n");
        return -1;
    }
 
    res = send_start_msg(control_app(control), chan, argc, argv);
    if (res != 0) {
        ast_log(LOG_ERROR,
            "Error sending start message to '%s'\n", app_name);
        remove_masquerade_store(chan);
        return -1;
    }
 
    /* Pull queued prestart commands and execute */
    control_prestart_dispatch_all(control, chan);
 
    while (!control_is_done(control)) {
        RAII_VAR(struct ast_frame *, f, NULL, ast_frame_dtor);
        int r;
        int command_count;
        RAII_VAR(struct ast_bridge *, last_bridge, NULL, ao2_cleanup);
 
        /* Check to see if a bridge absorbed our hangup frame */
        if (ast_check_hangup_locked(chan)) {
            control_mark_done(control);
            break;
        }
 
        /* control->next_app is only modified within the control thread, so this is safe */
        if (control_next_app(control)) {
            struct stasis_app *next_app = ao2_find(apps_registry, control_next_app(control), OBJ_SEARCH_KEY);
 
            if (next_app && app_is_active(next_app)) {
                int idx;
                int next_argc;
                char **next_argv;
 
                /* If something goes wrong in this conditional, res will need to be non-zero
                 * so that the code below the exec loop knows something went wrong during a move.
                 */
                if (!stasis_app_channel_is_stasis_end_published(chan)) {
                    res = has_masquerade_store(chan) && app_send_end_msg(control_app(control), chan);
                    if (res != 0) {
                        ast_log(LOG_ERROR,
                            "Error sending end message to %s\n", stasis_app_name(control_app(control)));
                        control_mark_done(control);
                        ao2_ref(next_app, -1);
                        break;
                    }
                } else {
                    remove_stasis_end_published(chan);
                }
 
                /* This will ao2_bump next_app, and unref the previous app by 1 */
                control_set_app(control, next_app);
 
                /* There's a chance that the previous application is ready for clean up, so go ahead
                 * and do that now.
                 */
                cleanup();
 
                /* We need to add another masquerade store, otherwise the leave message will
                 * not show up for the correct application.
                 */
                if (add_masquerade_store(chan)) {
                    ast_log(LOG_ERROR, "Failed to attach masquerade detector\n");
                    res = -1;
                    control_mark_done(control);
                    ao2_ref(next_app, -1);
                    break;
                }
 
                /* We MUST get the size before the list, as control_next_app_args steals the elements
                 * from the string vector.
                 */
                next_argc = control_next_app_args_size(control);
                next_argv = control_next_app_args(control);
 
                res = send_start_msg(control_app(control), chan, next_argc, next_argv);
 
                /* Even if res != 0, we still need to free the memory we got from control_argv */
                if (next_argv) {
                    for (idx = 0; idx < next_argc; idx++) {
                        ast_free(next_argv[idx]);
                    }
                    ast_free(next_argv);
                }
 
                if (res != 0) {
                    ast_log(LOG_ERROR,
                        "Error sending start message to '%s'\n", stasis_app_name(control_app(control)));
                    remove_masquerade_store(chan);
                    control_mark_done(control);
                    ao2_ref(next_app, -1);
                    break;
                }
 
                /* Done switching applications, free memory and clean up */
                control_move_cleanup(control);
            } else {
                /* If we can't switch applications, do nothing */
                struct ast_json *msg;
                RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
 
                if (!next_app) {
                    ast_log(LOG_ERROR, "Could not move to Stasis app '%s' - not registered\n",
                        control_next_app(control));
                } else {
                    ast_log(LOG_ERROR, "Could not move to Stasis app '%s' - not active\n",
                        control_next_app(control));
                }
 
                snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan));
                if (!snapshot) {
                    ast_log(LOG_ERROR, "Could not get channel shapshot for '%s'\n",
                        ast_channel_name(chan));
                } else {
                    struct ast_json *json_args;
                    int next_argc = control_next_app_args_size(control);
                    char **next_argv = control_next_app_args(control);
 
                    msg = ast_json_pack("{s: s, s: o, s: o, s: s, s: []}",
                        "type", "ApplicationMoveFailed",
                        "timestamp", ast_json_timeval(ast_tvnow(), NULL),
                        "channel", ast_channel_snapshot_to_json(snapshot, NULL),
                        "destination", control_next_app(control),
                        "args");
                    if (!msg) {
                        ast_log(LOG_ERROR, "Failed to pack JSON for ApplicationMoveFailed message\n");
                    } else {
                        json_args = ast_json_object_get(msg, "args");
                        if (!json_args) {
                            ast_log(LOG_ERROR, "Could not get args json array");
                        } else {
                            int r = 0;
                            int idx;
                            for (idx = 0; idx < next_argc; ++idx) {
                                r = ast_json_array_append(json_args,
                                    ast_json_string_create(next_argv[idx]));
                                if (r != 0) {
                                    ast_log(LOG_ERROR, "Error appending to ApplicationMoveFailed message\n");
                                    break;
                                }
                            }
                            if (r == 0) {
                                app_send(control_app(control), msg);
                            }
                        }
                        ast_json_unref(msg);
                    }
                }
            }
            control_move_cleanup(control);
            ao2_cleanup(next_app);
        }
 
        last_bridge = bridge;
        bridge = ao2_bump(stasis_app_get_bridge(control));
 
        if (bridge != last_bridge) {
            if (last_bridge) {
                app_unsubscribe_bridge(control_app(control), last_bridge);
            }
            if (bridge) {
                app_subscribe_bridge(control_app(control), bridge);
            }
        }
 
        if (bridge) {
            /* Bridge/dial is handling channel frames */
            control_wait(control);
            control_dispatch_all(control, chan);
            continue;
        }
 
        r = ast_waitfor(chan, MAX_WAIT_MS);
 
        if (r < 0) {
            ast_debug(3, "%s: Poll error\n",
                  ast_channel_uniqueid(chan));
            control_mark_done(control);
            break;
        }
 
        command_count = control_dispatch_all(control, chan);
 
        if (command_count > 0 && ast_channel_fdno(chan) == -1) {
            /* Command drained the channel; wait for next frame */
            continue;
        }
 
        if (r == 0) {
            /* Timeout */
            continue;
        }
 
        f = ast_read(chan);
        if (!f) {
            /* Continue on in the dialplan */
            ast_debug(3, "%s: Hangup (no more frames)\n",
                ast_channel_uniqueid(chan));
            control_mark_done(control);
            break;
        }
 
        if (f->frametype == AST_FRAME_CONTROL) {
            if (f->subclass.integer == AST_CONTROL_HANGUP) {
                /* Continue on in the dialplan */
                ast_debug(3, "%s: Hangup\n",
                    ast_channel_uniqueid(chan));
                control_mark_done(control);
                break;
            }
        }
    }
 
    ast_channel_lock(chan);
    needs_depart = (ast_channel_internal_bridge_channel(chan) != NULL);
    ast_channel_unlock(chan);
    if (needs_depart) {
        ast_bridge_depart(chan);
    }
 
    if (stasis_app_get_bridge(control)) {
        app_unsubscribe_bridge(control_app(control), stasis_app_get_bridge(control));
    }
    ao2_cleanup(bridge);
 
    /* Only publish a stasis_end event if it hasn't already been published */
    if (!res && !stasis_app_channel_is_stasis_end_published(chan)) {
        /* A masquerade has occurred and this message will be wrong so it
         * has already been sent elsewhere. */
        res = has_masquerade_store(chan) && app_send_end_msg(control_app(control), chan);
        if (res != 0) {
            ast_log(LOG_ERROR,
                "Error sending end message to %s\n", stasis_app_name(control_app(control)));
            return res;
        }
    } else {
        remove_stasis_end_published(chan);
    }
 
    control_flush_queue(control);
 
    /* Stop any lingering silence generator */
    control_silence_stop_now(control);
 
    /* There's an off chance that app is ready for cleanup. Go ahead
     * and clean up, just in case
     */
    cleanup();
 
    /* The control needs to be removed from the controls container in
     * case a new PBX is started and ends up coming back into Stasis.
     */
    control_unlink(control);
    control = NULL;
 
    if (!res && !ast_channel_pbx(chan)) {
        int chan_hungup;
 
        /* The ASYNCGOTO softhangup flag may have broken the channel out of
         * its bridge to run dialplan, so if there's no pbx on the channel
         * let it run dialplan here. Otherwise, it will run when this
         * application exits. */
        ast_channel_lock(chan);
        ast_channel_clear_softhangup(chan, AST_SOFTHANGUP_ASYNCGOTO);
        chan_hungup = ast_check_hangup(chan);
        ast_channel_unlock(chan);
 
        if (!chan_hungup) {
            struct ast_pbx_args pbx_args;
 
            memset(&pbx_args, 0, sizeof(pbx_args));
            pbx_args.no_hangup_chan = 1;
 
            res = ast_pbx_run_args(chan, &pbx_args);
        }
    }
 
    return res;
}

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_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

NULL

on error.

Definition at line 1708 of file res_stasis.c.

{
    struct ao2_container *apps;
 
    if (!apps_registry) {
        return NULL;
    }
 
    apps = ast_str_container_alloc(1);
    if (!apps) {
        return NULL;
    }
 
    ao2_callback(apps_registry, OBJ_NODATA, append_name, apps);
 
    return apps;
}

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

name	The name of the registered Stasis application

Returns

stasis_app on success.

Return values

NULL

on error.

Definition at line 1694 of file res_stasis.c.

{
    return find_app_by_name(name);
}

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

The	stasis message sanitizer

Definition at line 2264 of file res_stasis.c.

{
    return &app_sanitizer;
}

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_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

app	The application.

Returns

JSON representation of app with given name.

Return values

NULL

on error.

Definition at line 1866 of file res_stasis.c.

{
    if (!app) {
        return NULL;
    }
 
    return stasis_app_event_filter_to_json(
        app, app_event_sources_to_json(app, app_to_json(app)));
}

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

Referenced by 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_name	Name of this application.
handler	Callback for application messages.
data	Data blob to pass to the callback. Must be AO2 managed.

Returns

0 for success

-1 for error.

Definition at line 1777 of file res_stasis.c.

{
    return __stasis_app_register(app_name, handler, data, 0);
}

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

Referenced by AST_TEST_DEFINE(), and event_session_alloc().

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_name	Name of this application.
handler	Callback for application messages.
data	Data blob to pass to the callback. Must be AO2 managed.

Returns

0 for success

-1 for error.

Definition at line 1782 of file res_stasis.c.

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

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

Referenced by event_session_alloc().

stasis_app_register_event_source()

void stasis_app_register_event_source

(

struct stasis_app_event_source *

obj

)

Register an application event source.

Parameters

obj	the event source to register

Definition at line 1816 of file res_stasis.c.

{
    AST_RWLIST_WRLOCK(&event_sources);
    AST_LIST_INSERT_TAIL(&event_sources, obj, next);
    AST_RWLIST_UNLOCK(&event_sources);
}

References AST_LIST_INSERT_TAIL, AST_RWLIST_UNLOCK, and AST_RWLIST_WRLOCK.

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_name	Name of the application to invoke.
message	Message to send (borrowed reference)

Returns

0 for success.

-1 for error.

Definition at line 1656 of file res_stasis.c.

{
    struct stasis_app *app;
 
    if (!apps_registry) {
        return -1;
    }
 
    app = ao2_find(apps_registry, app_name, OBJ_SEARCH_KEY);
    if (!app) {
        /* XXX We can do a better job handling late binding, queueing up
         * the call for a few seconds to wait for the app to register.
         */
        ast_log(LOG_WARNING,
            "Stasis app '%s' not registered\n", app_name);
        return -1;
    }
    app_send(app, message);
    ao2_ref(app, -1);
 
    return 0;
}

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_name	Name of the application to subscribe.
event_source_uris	URIs for the event sources to subscribe to.
event_sources_count	Array size of event_source_uris.
json	Optional 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 1897 of file res_stasis.c.

{
    return app_handle_subscriptions(
        app_name, event_source_uris, event_sources_count,
        json, 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_name	Name of the application to subscribe.
chan	The 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 1897 of file res_stasis.c.

{
    struct stasis_app *app = find_app_by_name(app_name);
    int res;
 
    if (!app) {
        return STASIS_ASR_APP_NOT_FOUND;
    }
 
    ast_debug(3, "%s: Subscribing to %s\n", app_name, ast_channel_uniqueid(chan));
 
    res = app_subscribe_channel(app, chan);
    ao2_ref(app, -1);
 
    if (res != 0) {
        ast_log(LOG_ERROR, "Error subscribing app '%s' to channel '%s'\n",
            app_name, ast_channel_uniqueid(chan));
        return STASIS_ASR_INTERNAL_ERROR;
    }
 
    return 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_name

Name of the application.

Returns

JSON representation of app with given name.

Return values

NULL

on error.

Definition at line 1876 of file res_stasis.c.

{
    struct stasis_app *app = find_app_by_name(app_name);
    struct ast_json *json = stasis_app_object_to_json(app);
 
    ao2_cleanup(app);
 
    return json;
}

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.

Parameters

app_name

Name of the application to unregister.

Definition at line 1787 of file res_stasis.c.

{
    struct stasis_app *app;
 
    if (!app_name) {
        return;
    }
 
    if (!apps_registry) {
        return;
    }
 
    app = ao2_find(apps_registry, app_name, OBJ_SEARCH_KEY);
    if (!app) {
        ast_log(LOG_ERROR,
            "Stasis app '%s' not registered\n", app_name);
        return;
    }
 
    app_deactivate(app);
 
    /* There's a decent chance that app is ready for cleanup. Go ahead
     * and clean up, just in case
     */
    cleanup();
 
    ao2_ref(app, -1);
}

References ao2_find, ao2_ref, app, app_deactivate(), app_name(), apps_registry, ast_log, cleanup(), LOG_ERROR, and OBJ_SEARCH_KEY.

Referenced by AST_TEST_DEFINE(), and event_session_shutdown().

stasis_app_unregister_event_source()

void stasis_app_unregister_event_source

(

struct stasis_app_event_source *

obj

)

Unregister an application event source.

Parameters

obj	the event source to unregister

Definition at line 1823 of file res_stasis.c.

{
    struct stasis_app_event_source *source;
 
    AST_RWLIST_WRLOCK(&event_sources);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&event_sources, source, next) {
        if (source == obj) {
            AST_RWLIST_REMOVE_CURRENT(next);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&event_sources);
}

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

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_name	Name of the application to subscribe.
event_source_uris	URIs for the event sources to subscribe to.
event_sources_count	Array size of event_source_uris.
json	Optional output pointer for JSON representation of the app after adding the subscription.

Returns

stasis_app_subscribe_res return code.

Definition at line 1897 of file res_stasis.c.

{
    return app_handle_subscriptions(
        app_name, event_source_uris, event_sources_count,
        json, 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_name	Name of the application to generate event for/to.
event_name	Name of the Userevent.
source_uris	URIs for the source objects to attach to event.
sources_count	Array size of source_uris.
json_variables	event blob variables.

Returns

stasis_app_user_event_res return code.

Definition at line 1897 of file res_stasis.c.

{
    RAII_VAR(struct stasis_app *, app, find_app_by_name(app_name), ao2_cleanup);
    struct ast_json *blob = NULL;
    struct ast_multi_object_blob *multi;
    struct stasis_message *message;
    enum stasis_app_user_event_res res = STASIS_APP_USER_INTERNAL_ERROR;
    int have_channel = 0;
    int i;
 
    if (!app) {
        ast_log(LOG_WARNING, "App %s not found\n", app_name);
        return STASIS_APP_USER_APP_NOT_FOUND;
    }
 
    if (!ast_multi_user_event_type()) {
        return res;
    }
 
    if (json_variables) {
        struct ast_json *json_value = ast_json_string_create(event_name);
 
        if (json_value && !ast_json_object_set(json_variables, "eventname", json_value)) {
            blob = ast_json_ref(json_variables);
        }
    } else {
        blob = ast_json_pack("{s: s}", "eventname", event_name);
    }
 
    if (!blob) {
        ast_log(LOG_ERROR, "Failed to initialize blob\n");
 
        return res;
    }
 
    multi = ast_multi_object_blob_create(blob);
    ast_json_unref(blob);
    if (!multi) {
        ast_log(LOG_ERROR, "Failed to initialize multi\n");
 
        return res;
    }
 
    for (i = 0; i < sources_count; ++i) {
        const char *uri = source_uris[i];
        void *snapshot=NULL;
        enum stasis_user_multi_object_snapshot_type type;
 
        if (ast_begins_with(uri, "channel:")) {
            type = STASIS_UMOS_CHANNEL;
            snapshot = ast_channel_snapshot_get_latest(uri + 8);
            have_channel = 1;
        } else if (ast_begins_with(uri, "bridge:")) {
            type = STASIS_UMOS_BRIDGE;
            snapshot = ast_bridge_get_snapshot_by_uniqueid(uri + 7);
        } else if (ast_begins_with(uri, "endpoint:")) {
            type = STASIS_UMOS_ENDPOINT;
            snapshot = ast_endpoint_latest_snapshot(uri + 9, NULL);
        } else {
            ast_log(LOG_WARNING, "Invalid scheme: %s\n", uri);
            ao2_ref(multi, -1);
 
            return STASIS_APP_USER_EVENT_SOURCE_BAD_SCHEME;
        }
        if (!snapshot) {
            ast_log(LOG_ERROR, "Unable to get snapshot for %s\n", uri);
            ao2_ref(multi, -1);
 
            return STASIS_APP_USER_EVENT_SOURCE_NOT_FOUND;
        }
        ast_multi_object_blob_add(multi, type, snapshot);
    }
 
    message = stasis_message_create(ast_multi_user_event_type(), multi);
    ao2_ref(multi, -1);
 
    if (!message) {
        ast_log(LOG_ERROR, "Unable to create stasis user event message\n");
        return res;
    }
 
    /*
     * Publishing to two different topics is normally to be avoided -- except
     * in this case both are final destinations with no forwards (only listeners).
     * The message has to be delivered to the application topic for ARI, but a
     * copy is also delivered directly to the manager for AMI if there is a channel.
     */
    stasis_publish(ast_app_get_topic(app), message);
 
    if (have_channel) {
        stasis_publish(ast_manager_get_topic(), message);
    }
    ao2_ref(message, -1);
 
    return STASIS_APP_USER_OK;
}

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.

{
    struct ast_channel_blob *payload = stasis_message_data(message);
    struct ast_json *msg;
 
    if (sanitize && sanitize->channel_snapshot &&
            sanitize->channel_snapshot(payload->snapshot)) {
        return NULL;
    }
 
    msg = ast_json_pack("{s: s, s: O, s: o}",
        "type", "StasisEnd",
        "timestamp", ast_json_object_get(payload->blob, "timestamp"),
        "channel", ast_channel_snapshot_to_json(payload->snapshot, sanitize));
    if (!msg) {
        ast_log(LOG_ERROR, "Failed to pack JSON for StasisEnd message\n");
        return NULL;
    }
 
    return msg;
}

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.

{
    struct start_message_blob *payload = stasis_message_data(message);
    struct ast_json *msg;
 
    if (sanitize && sanitize->channel_snapshot &&
            sanitize->channel_snapshot(payload->channel)) {
        return NULL;
    }
 
    msg = ast_json_pack("{s: s, s: O, s: O, s: o}",
        "type", "StasisStart",
        "timestamp", ast_json_object_get(payload->blob, "timestamp"),
        "args", ast_json_object_get(payload->blob, "args"),
        "channel", ast_channel_snapshot_to_json(payload->channel, NULL));
    if (!msg) {
        ast_log(LOG_ERROR, "Failed to pack JSON for StasisStart message\n");
        return NULL;
    }
 
    if (payload->replace_channel) {
        int res = ast_json_object_set(msg, "replace_channel",
            ast_channel_snapshot_to_json(payload->replace_channel, NULL));
 
        if (res) {
            ast_json_unref(msg);
            ast_log(LOG_ERROR, "Failed to append JSON for StasisStart message\n");
            return NULL;
        }
    }
 
    return msg;
}

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 2195 of file res_stasis.c.

{
    stasis_app_unregister_event_sources();
 
    messaging_cleanup();
 
    cleanup();
 
    stasis_app_control_shutdown();
 
    ao2_cleanup(apps_registry);
    apps_registry = NULL;
 
    ao2_cleanup(app_controls);
    app_controls = NULL;
 
    ao2_cleanup(app_bridges);
    app_bridges = NULL;
 
    ao2_cleanup(app_bridges_moh);
    app_bridges_moh = NULL;
 
    ao2_cleanup(app_bridges_playback);
    app_bridges_playback = NULL;
 
    STASIS_MESSAGE_TYPE_CLEANUP(end_message_type);
    STASIS_MESSAGE_TYPE_CLEANUP(start_message_type);
 
    return 0;
}

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.

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 2337 of file res_stasis.c.

app_bridges

struct ao2_container* app_bridges

Definition at line 104 of file res_stasis.c.

Referenced by bridge_create_common(), stasis_app_bridge_destroy(), stasis_app_bridge_find_by_id(), and unload_module().

app_bridges_moh

struct ao2_container* app_bridges_moh

Definition at line 106 of file res_stasis.c.

Referenced by bridge_moh_create(), moh_channel_thread(), stasis_app_bridge_moh_channel(), stasis_app_bridge_moh_stop(), and unload_module().

app_bridges_playback

struct ao2_container* app_bridges_playback

Definition at line 108 of file res_stasis.c.

Referenced by remove_bridge_playback(), stasis_app_bridge_playback_channel_add(), stasis_app_bridge_playback_channel_find(), stasis_app_bridge_playback_channel_remove(), and unload_module().

app_controls

struct ao2_container* app_controls

Definition at line 102 of file res_stasis.c.

Referenced by channel_replaced_cb(), channel_stolen_cb(), control_unlink(), remove_bridge_playback(), stasis_app_bridge_playback_channel_add(), stasis_app_bridge_playback_channel_remove(), stasis_app_control_find_by_channel_id(), stasis_app_exec(), and unload_module().

app_sanitizer

struct stasis_message_sanitizer app_sanitizer

Initial value:

= {
    .channel_id = channel_id_sanitizer,
    .channel_snapshot = channel_snapshot_sanitizer,
    .channel = channel_sanitizer,
}

Sanitization callbacks for communication to Stasis applications.

Definition at line 2245 of file res_stasis.c.

Referenced by stasis_app_get_sanitizer().

apps_registry

struct ao2_container* apps_registry

Stasis application container.

Definition at line 100 of file res_stasis.c.

Referenced by __stasis_app_register(), cleanup(), find_app_by_name(), stasis_app_exec(), stasis_app_get_all(), stasis_app_send(), stasis_app_unregister(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 2379 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,
}

Definition at line 1159 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",
    .destroy = replace_channel_destroy,
}

Definition at line 876 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 1278 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 2264 of file res_stasis.c.

Referenced by set_internal_datastore(), and stasis_app_channel_is_internal().