app.h File Reference

Internal API for the Stasis application controller. More...

#include "asterisk/channel.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_app.h"

Include dependency graph for res/stasis/app.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Enumerations
enum	stasis_app_subscription_model { STASIS_APP_SUBSCRIBE_MANUAL , STASIS_APP_SUBSCRIBE_ALL }

Functions
struct stasis_app *	app_create (const char *name, stasis_app_cb handler, void *data, enum stasis_app_subscription_model subscription_model)
	Create a res_stasis application.
void	app_deactivate (struct stasis_app *app)
	Deactivates an application.
char *	app_get_replace_channel_app (struct ast_channel *chan)
	Get the app that the replacement channel will be controlled by.
int	app_is_active (struct stasis_app *app)
	Checks whether an app is active.
int	app_is_finished (struct stasis_app *app)
	Checks whether a deactivated app has no channels.
int	app_is_subscribed_bridge_id (struct stasis_app *app, const char *bridge_id)
	Test if an app is subscribed to a bridge.
int	app_is_subscribed_channel_id (struct stasis_app *app, const char *channel_id)
	Test if an app is subscribed to a channel.
int	app_is_subscribed_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Test if an app is subscribed to a endpoint.
void	app_send (struct stasis_app *app, struct ast_json *message)
	Send a message to an application.
int	app_send_end_msg (struct stasis_app *app, struct ast_channel *chan)
	Send StasisEnd message to the listening 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.
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.
void	app_shutdown (struct stasis_app *app)
	Tears down an application.
int	app_subscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Add a bridge subscription to an existing channel subscription.
int	app_subscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Subscribes an application to a channel.
int	app_subscribe_endpoint (struct stasis_app *app, struct ast_endpoint *endpoint)
	Subscribes an application to a endpoint.
struct ast_json *	app_to_json (const struct stasis_app *app)
	Create a JSON representation of a stasis_app.
int	app_unsubscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Cancel the bridge subscription for an application.
int	app_unsubscribe_bridge_id (struct stasis_app *app, const char *bridge_id)
	Cancel the subscription an app has for a bridge.
int	app_unsubscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Cancel the subscription an app has for a channel.
int	app_unsubscribe_channel_id (struct stasis_app *app, const char *channel_id)
	Cancel the subscription an app has for a channel.
int	app_unsubscribe_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Cancel the subscription an app has for a endpoint.
void	app_update (struct stasis_app *app, stasis_app_cb handler, void *data)
	Update the handler and data for a res_stasis application.

Detailed Description

Internal API for the Stasis application controller.

Author

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

Since

12

Definition in file res/stasis/app.h.

Enumeration Type Documentation

stasis_app_subscription_model

enum stasis_app_subscription_model

Enumerator
STASIS_APP_SUBSCRIBE_MANUAL	An application must manually subscribe to each resource that it cares about. This is the default approach.
STASIS_APP_SUBSCRIBE_ALL	An application is automatically subscribed to all resources in Asterisk, even if it does not control them.

Definition at line 39 of file res/stasis/app.h.

                                   {
    /*!
     * \brief An application must manually subscribe to each
     * resource that it cares about. This is the default approach.
     */
    STASIS_APP_SUBSCRIBE_MANUAL,
    /*!
     * \brief An application is automatically subscribed to all
     * resources in Asterisk, even if it does not control them.
     */
    STASIS_APP_SUBSCRIBE_ALL
};

Function Documentation

app_create()

struct stasis_app * app_create	(	const char *	name,
		stasis_app_cb	handler,
		void *	data,
		enum stasis_app_subscription_model	subscription_model
	)

Create a res_stasis application.

Parameters

name	Name of the application.
handler	Callback for messages sent to the application.
data	Data pointer provided to the callback.
subscription_model

Returns

New res_stasis application.

Return values

NULL

on error.

Definition at line 928 of file res/stasis/app.c.

{
    RAII_VAR(struct stasis_app *, app, NULL, ao2_cleanup);
    size_t size;
    int res = 0;
    size_t context_size = strlen("stasis-") + strlen(name) + 1;
    char context_name[context_size];
    char *topic_name;
    int ret;
 
    ast_assert(name != NULL);
    ast_assert(handler != NULL);
 
    ast_verb(1, "Creating Stasis app '%s'\n", name);
 
    size = sizeof(*app) + strlen(name) + 1;
    app = ao2_alloc_options(size, app_dtor, AO2_ALLOC_OPT_LOCK_MUTEX);
    if (!app) {
        return NULL;
    }
    app->subscription_model = subscription_model;
 
    app->forwards = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX,
        AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT,
        forwards_sort, NULL);
    if (!app->forwards) {
        return NULL;
    }
 
    ret = ast_asprintf(&topic_name, "ari:application/%s", name);
    if (ret < 0) {
        return NULL;
    }
 
    app->topic = stasis_topic_create(topic_name);
    ast_free(topic_name);
    if (!app->topic) {
        return NULL;
    }
 
    app->bridge_router = stasis_message_router_create(ast_bridge_topic_all());
    if (!app->bridge_router) {
        return NULL;
    }
 
    res |= stasis_message_router_add(app->bridge_router,
        ast_bridge_merge_message_type(), bridge_merge_handler, app);
 
    res |= stasis_message_router_add(app->bridge_router,
        ast_blind_transfer_type(), bridge_blind_transfer_handler, app);
 
    res |= stasis_message_router_add(app->bridge_router,
        ast_attended_transfer_type(), bridge_attended_transfer_handler, app);
 
    res |= stasis_message_router_add(app->bridge_router,
        stasis_subscription_change_type(), bridge_subscription_change_handler, app);
 
    if (res != 0) {
        return NULL;
    }
    /* Bridge router holds a reference */
    ao2_ref(app, +1);
 
    app->router = stasis_message_router_create(app->topic);
    if (!app->router) {
        return NULL;
    }
 
    res |= stasis_message_router_add(app->router,
        ast_bridge_snapshot_type(), sub_bridge_update_handler, app);
 
    res |= stasis_message_router_add(app->router,
        ast_channel_snapshot_type(), sub_channel_update_handler, app);
 
    res |= stasis_message_router_add_cache_update(app->router,
        ast_endpoint_snapshot_type(), sub_endpoint_update_handler, app);
 
    res |= stasis_message_router_add(app->router,
        stasis_subscription_change_type(), sub_subscription_change_handler, app);
 
    stasis_message_router_set_formatters_default(app->router,
        sub_default_handler, app, STASIS_SUBSCRIPTION_FORMATTER_JSON);
 
    if (res != 0) {
        return NULL;
    }
    /* Router holds a reference */
    ao2_ref(app, +1);
 
    strncpy(app->name, name, size - sizeof(*app));
    app->handler = handler;
    app->data = ao2_bump(data);
 
    /* Create a context, a match-all extension, and a 'h' extension for this application. Note that
     * this should only be done if a context does not already exist. */
    strcpy(context_name, "stasis-");
    strcat(context_name, name);
    if (!ast_context_find(context_name)) {
        if (!ast_context_find_or_create(NULL, NULL, context_name, "res_stasis")) {
            ast_log(LOG_WARNING, "Could not create context '%s' for Stasis application '%s'\n", context_name, name);
        } else {
            ast_add_extension(context_name, 0, "_.", 1, NULL, NULL, "Stasis", ast_strdup(name), ast_free_ptr, "res_stasis");
            ast_add_extension(context_name, 0, "h", 1, NULL, NULL, "NoOp", NULL, NULL, "res_stasis");
        }
    } else {
        ast_log(LOG_WARNING, "Not creating context '%s' for Stasis application '%s' because it already exists\n",
            context_name, name);
    }
 
    ao2_ref(app, +1);
    return app;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_alloc_options, ao2_bump, ao2_cleanup, AO2_CONTAINER_ALLOC_OPT_DUPS_OBJ_REJECT, ao2_container_alloc_rbtree, ao2_ref, app, app_dtor(), ast_add_extension(), ast_asprintf, ast_assert, ast_attended_transfer_type(), ast_blind_transfer_type(), ast_bridge_merge_message_type(), ast_bridge_snapshot_type(), ast_bridge_topic_all(), ast_channel_snapshot_type(), ast_context_find(), ast_context_find_or_create(), ast_endpoint_snapshot_type(), ast_free, ast_free_ptr(), ast_log, ast_strdup, ast_verb, bridge_attended_transfer_handler(), bridge_blind_transfer_handler(), bridge_merge_handler(), bridge_subscription_change_handler(), context_name, stasis_app::data, forwards_sort(), handler(), LOG_WARNING, name, NULL, RAII_VAR, stasis_message_router_add(), stasis_message_router_add_cache_update(), stasis_message_router_create, stasis_message_router_set_formatters_default(), stasis_subscription_change_type(), STASIS_SUBSCRIPTION_FORMATTER_JSON, stasis_topic_create(), sub_bridge_update_handler(), sub_channel_update_handler(), sub_default_handler(), sub_endpoint_update_handler(), sub_subscription_change_handler(), and stasis_app::subscription_model.

Referenced by __stasis_app_register().

app_deactivate()

void app_deactivate

(

struct stasis_app *

app

)

Deactivates an application.

Any channels currently in the application remain active (since the app might come back), but new channels are rejected.

Parameters

app	Application to deactivate.

Definition at line 1074 of file res/stasis/app.c.

{
    ao2_lock(app);
 
    ast_verb(1, "Deactivating Stasis app '%s'\n", app->name);
    app->handler = NULL;
    ao2_cleanup(app->data);
    app->data = NULL;
 
    ao2_unlock(app);
}

References ao2_cleanup, ao2_lock, ao2_unlock, app, ast_verb, and NULL.

Referenced by stasis_app_unregister().

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 1012 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_is_active()

int app_is_active

(

struct stasis_app *

app

)

Checks whether an app is active.

Parameters

app	Application to check.

Return values

True	(non-zero) if app is active.
False	(zero) if app has been deactivated.

Definition at line 1102 of file res/stasis/app.c.

{
    int ret;
 
    ao2_lock(app);
    ret = app->handler != NULL;
    ao2_unlock(app);
 
    return ret;
}

References ao2_lock, ao2_unlock, app, and NULL.

Referenced by stasis_app_exec().

app_is_finished()

int app_is_finished

(

struct stasis_app *

app

)

Checks whether a deactivated app has no channels.

Parameters

app	Application to check.

Return values

True	(non-zero) if app is deactivated, and has no associated channels.
False	(zero) otherwise.

Definition at line 1113 of file res/stasis/app.c.

{
    int ret;
 
    ao2_lock(app);
    ret = app->handler == NULL && ao2_container_count(app->forwards) == 0;
    ao2_unlock(app);
 
    return ret;
}

References ao2_container_count(), ao2_lock, ao2_unlock, app, and NULL.

Referenced by app_shutdown(), and cleanup_cb().

app_is_subscribed_bridge_id()

int app_is_subscribed_bridge_id	(	struct stasis_app *	app,
		const char *	bridge_id
	)

Test if an app is subscribed to a bridge.

Parameters

app	Subscribing application.
bridge_id	Id of bridge to check.

Return values

True	(non-zero) if bridge is subscribed to app.
False	(zero) if bridge is not subscribed.

Definition at line 1512 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (ast_strlen_zero(bridge_id)) {
        bridge_id = BRIDGE_ALL;
    }
 
    forwards = ao2_find(app->forwards, bridge_id, OBJ_SEARCH_KEY);
    ao2_cleanup(forwards);
 
    return forwards != NULL;
}

References ao2_cleanup, ao2_find, app, ast_strlen_zero(), BRIDGE_ALL, NULL, and OBJ_SEARCH_KEY.

app_is_subscribed_channel_id()

int app_is_subscribed_channel_id	(	struct stasis_app *	app,
		const char *	channel_id
	)

Test if an app is subscribed to a channel.

Parameters

app	Subscribing application.
channel_id	Id of channel to check.

Return values

True	(non-zero) if channel is subscribed to app.
False	(zero) if channel is not subscribed.

Definition at line 1410 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (ast_strlen_zero(channel_id)) {
        channel_id = CHANNEL_ALL;
    }
    forwards = ao2_find(app->forwards, channel_id, OBJ_SEARCH_KEY);
    ao2_cleanup(forwards);
 
    return forwards != NULL;
}

References ao2_cleanup, ao2_find, app, ast_strlen_zero(), CHANNEL_ALL, NULL, and OBJ_SEARCH_KEY.

app_is_subscribed_endpoint_id()

int app_is_subscribed_endpoint_id	(	struct stasis_app *	app,
		const char *	endpoint_id
	)

Test if an app is subscribed to a endpoint.

Parameters

app	Subscribing application.
endpoint_id	Id of endpoint to check.

Return values

True	(non-zero) if endpoint is subscribed to app.
False	(zero) if endpoint is not subscribed.

Definition at line 1609 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (ast_strlen_zero(endpoint_id)) {
        endpoint_id = ENDPOINT_ALL;
    }
    forwards = ao2_find(app->forwards, endpoint_id, OBJ_SEARCH_KEY);
    ao2_cleanup(forwards);
 
    return forwards != NULL;
}

References ao2_cleanup, ao2_find, app, ast_strlen_zero(), ENDPOINT_ALL, NULL, and OBJ_SEARCH_KEY.

app_send()

void app_send	(	struct stasis_app *	app,
		struct ast_json *	message
	)

Send a message to an application.

Parameters

app	App to send the message to.
message	Message to send.

Definition at line 1046 of file res/stasis/app.c.

{
    stasis_app_cb handler;
    char eid[20];
    void *data;
 
    if (ast_json_object_set(message, "asterisk_id", ast_json_string_create(
            ast_eid_to_str(eid, sizeof(eid), &ast_eid_default)))) {
        ast_log(AST_LOG_WARNING, "Failed to append EID to outgoing event %s\n",
            ast_json_string_get(ast_json_object_get(message, "type")));
    }
 
    /* Copy off mutable state with lock held */
    ao2_lock(app);
    handler = app->handler;
    data = ao2_bump(app->data);
    ao2_unlock(app);
    /* Name is immutable; no need to copy */
 
    if (handler) {
        handler(data, app->name, message);
    } else {
        ast_verb(3,
            "Inactive Stasis app '%s' missed message\n", app->name);
    }
    ao2_cleanup(data);
}

References ao2_bump, ao2_cleanup, ao2_lock, ao2_unlock, app, ast_eid_default, ast_eid_to_str(), ast_json_object_get(), ast_json_object_set(), ast_json_string_create(), ast_json_string_get(), ast_log, AST_LOG_WARNING, ast_verb, and handler().

Referenced by app_update(), message_received_handler(), stasis_app_exec(), stasis_app_send(), sub_bridge_update_handler(), sub_channel_update_handler(), and sub_endpoint_update_handler().

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 1128 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 976 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 964 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_shutdown()

void app_shutdown

(

struct stasis_app *

app

)

Tears down an application.

It should be finished before calling this.

Parameters

app	Application to unsubscribe.

Definition at line 1086 of file res/stasis/app.c.

{
    ao2_lock(app);
 
    ast_assert(app_is_finished(app));
 
    stasis_message_router_unsubscribe(app->router);
    app->router = NULL;
    stasis_message_router_unsubscribe(app->bridge_router);
    app->bridge_router = NULL;
    stasis_message_router_unsubscribe(app->endpoint_router);
    app->endpoint_router = NULL;
 
    ao2_unlock(app);
}

References ao2_lock, ao2_unlock, app, app_is_finished(), ast_assert, NULL, and stasis_message_router_unsubscribe().

Referenced by cleanup_cb().

app_subscribe_bridge()

int app_subscribe_bridge	(	struct stasis_app *	app,
		struct ast_bridge *	bridge
	)

Add a bridge subscription to an existing channel subscription.

Parameters

app	Application.
bridge	Bridge to subscribe to.

Return values

0	on success.
Non-zero	on error.

Definition at line 1436 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (!app) {
        return -1;
    }
 
    ao2_lock(app->forwards);
    /* If subscribed to all, don't subscribe again */
    forwards = ao2_find(app->forwards, BRIDGE_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (forwards) {
        ao2_unlock(app->forwards);
        ao2_ref(forwards, -1);
 
        return 0;
    }
 
    forwards = ao2_find(app->forwards,
        bridge ? bridge->uniqueid : BRIDGE_ALL,
        OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!forwards) {
        int res;
 
        /* Forwards not found, create one */
        forwards = forwards_create_bridge(app, bridge);
        if (!forwards) {
            ao2_unlock(app->forwards);
 
            return -1;
        }
 
        res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
        if (!res) {
            ao2_unlock(app->forwards);
            ao2_ref(forwards, -1);
 
            return -1;
        }
    }
 
    ++forwards->interested;
    ast_debug(3, "Bridge '%s' is %d interested in %s\n",
        bridge ? bridge->uniqueid : "ALL",
        forwards->interested,
        app->name);
 
    ao2_unlock(app->forwards);
    ao2_ref(forwards, -1);
 
    return 0;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, app, ast_debug, BRIDGE_ALL, forwards_create_bridge(), app_forwards::interested, OBJ_NOLOCK, OBJ_SEARCH_KEY, and ast_bridge::uniqueid.

Referenced by control_swap_channel_in_bridge(), stasis_app_exec(), and subscribe_bridge().

app_subscribe_channel()

int app_subscribe_channel	(	struct stasis_app *	app,
		struct ast_channel *	chan
	)

Subscribes an application to a channel.

Parameters

app	Application.
chan	Channel to subscribe to.

Return values

0	on success.
Non-zero	on error.

Definition at line 1289 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (!app) {
        return -1;
    }
 
    ao2_lock(app->forwards);
    /* If subscribed to all, don't subscribe again */
    forwards = ao2_find(app->forwards, CHANNEL_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (forwards) {
        ao2_unlock(app->forwards);
        ao2_ref(forwards, -1);
 
        return 0;
    }
 
    forwards = ao2_find(app->forwards,
        chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL,
        OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!forwards) {
        int res;
 
        /* Forwards not found, create one */
        forwards = forwards_create_channel(app, chan);
        if (!forwards) {
            ao2_unlock(app->forwards);
 
            return -1;
        }
 
        res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
        if (!res) {
            ao2_unlock(app->forwards);
            ao2_ref(forwards, -1);
 
            return -1;
        }
    }
 
    ++forwards->interested;
    ast_debug(3, "Channel '%s' is %d interested in %s\n",
        chan ? ast_channel_uniqueid(chan) : "ALL",
        forwards->interested,
        app->name);
 
    ao2_unlock(app->forwards);
    ao2_ref(forwards, -1);
 
    return 0;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, app, ast_channel_uniqueid(), ast_debug, CHANNEL_ALL, forwards_create_channel(), app_forwards::interested, OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by call_forwarded_handler(), send_start_msg_snapshots(), stasis_app_subscribe_channel(), and subscribe_channel().

app_subscribe_endpoint()

int app_subscribe_endpoint	(	struct stasis_app *	app,
		struct ast_endpoint *	endpoint
	)

Subscribes an application to a endpoint.

Parameters

app	Application.
endpoint	Endpoint to subscribe to.

Return values

0	on success.
Non-zero	on error.

Definition at line 1539 of file res/stasis/app.c.

{
    struct app_forwards *forwards;
 
    if (!app) {
        return -1;
    }
 
    ao2_lock(app->forwards);
    /* If subscribed to all, don't subscribe again */
    forwards = ao2_find(app->forwards, ENDPOINT_ALL, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (forwards) {
        ao2_unlock(app->forwards);
        ao2_ref(forwards, -1);
 
        return 0;
    }
 
    forwards = ao2_find(app->forwards,
        endpoint ? ast_endpoint_get_id(endpoint) : ENDPOINT_ALL,
        OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!forwards) {
        int res;
 
        /* Forwards not found, create one */
        forwards = forwards_create_endpoint(app, endpoint);
        if (!forwards) {
            ao2_unlock(app->forwards);
 
            return -1;
        }
 
        res = ao2_link_flags(app->forwards, forwards, OBJ_NOLOCK);
        if (!res) {
            ao2_unlock(app->forwards);
            ao2_ref(forwards, -1);
 
            return -1;
        }
 
        /* Subscribe for messages */
        messaging_app_subscribe_endpoint(app->name, endpoint, &message_received_handler, app);
    }
 
    ++forwards->interested;
    ast_debug(3, "Endpoint '%s' is %d interested in %s\n",
        endpoint ? ast_endpoint_get_id(endpoint) : "ALL",
        forwards->interested,
        app->name);
 
    ao2_unlock(app->forwards);
    ao2_ref(forwards, -1);
 
    return 0;
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, app, ast_debug, ast_endpoint_get_id(), ENDPOINT_ALL, forwards_create_endpoint(), app_forwards::interested, message_received_handler(), messaging_app_subscribe_endpoint(), OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by subscribe_endpoint().

app_to_json()

struct ast_json * app_to_json

(

const struct stasis_app *

app

)

Create a JSON representation of a stasis_app.

Parameters

app	The application

Returns

JSON blob on success

Return values

NULL

on error

Definition at line 1236 of file res/stasis/app.c.

{
    struct ast_json *json;
    struct ast_json *channels;
    struct ast_json *bridges;
    struct ast_json *endpoints;
    struct ao2_iterator i;
    struct app_forwards *forwards;
 
    json = ast_json_pack("{s: s, s: [], s: [], s: []}",
        "name", app->name,
        "channel_ids", "bridge_ids", "endpoint_ids");
    if (!json) {
        return NULL;
    }
    channels = ast_json_object_get(json, "channel_ids");
    bridges = ast_json_object_get(json, "bridge_ids");
    endpoints = ast_json_object_get(json, "endpoint_ids");
 
    i = ao2_iterator_init(app->forwards, 0);
    while ((forwards = ao2_iterator_next(&i))) {
        struct ast_json *array = NULL;
        int append_res;
 
        switch (forwards->forward_type) {
        case FORWARD_CHANNEL:
            array = channels;
            break;
        case FORWARD_BRIDGE:
            array = bridges;
            break;
        case FORWARD_ENDPOINT:
            array = endpoints;
            break;
        }
 
        /* If forward_type value is unexpected this will safely return an error. */
        append_res = ast_json_array_append(array, ast_json_string_create(forwards->id));
        ao2_ref(forwards, -1);
 
        if (append_res != 0) {
            ast_log(LOG_ERROR, "Error building response\n");
            ao2_iterator_destroy(&i);
            ast_json_unref(json);
 
            return NULL;
        }
    }
    ao2_iterator_destroy(&i);
 
    return json;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, app, array(), ast_json_array_append(), ast_json_object_get(), ast_json_pack(), ast_json_string_create(), ast_json_unref(), ast_log, bridges, channels, endpoints, FORWARD_BRIDGE, FORWARD_CHANNEL, FORWARD_ENDPOINT, app_forwards::forward_type, app_forwards::id, LOG_ERROR, and NULL.

Referenced by stasis_app_object_to_json().

app_unsubscribe_bridge()

int app_unsubscribe_bridge	(	struct stasis_app *	app,
		struct ast_bridge *	bridge
	)

Cancel the bridge subscription for an application.

Parameters

app	Subscribing application.
bridge	Bridge to subscribe to.

Return values

0	on success.
Non-zero	on error.

Definition at line 1494 of file res/stasis/app.c.

{
    if (!app) {
        return -1;
    }
 
    return app_unsubscribe_bridge_id(app, bridge ? bridge->uniqueid : BRIDGE_ALL);
}

References app, app_unsubscribe_bridge_id(), BRIDGE_ALL, and ast_bridge::uniqueid.

Referenced by internal_bridge_after_cb(), and stasis_app_exec().

app_unsubscribe_bridge_id()

int app_unsubscribe_bridge_id	(	struct stasis_app *	app,
		const char *	bridge_id
	)

Cancel the subscription an app has for a bridge.

Parameters

app	Subscribing application.
bridge_id	Id of bridge to unsubscribe from.

Return values

0	on success.
Non-zero	on error.

Definition at line 1503 of file res/stasis/app.c.

{
    if (!app) {
        return -1;
    }
 
    return unsubscribe(app, "bridge", bridge_id, 0);
}

References app, and unsubscribe().

Referenced by app_unsubscribe_bridge().

app_unsubscribe_channel()

int app_unsubscribe_channel	(	struct stasis_app *	app,
		struct ast_channel *	chan
	)

Cancel the subscription an app has for a channel.

Parameters

app	Subscribing application.
chan	Channel to unsubscribe from.

Return values

0	on success.
Non-zero	on error.

Definition at line 1392 of file res/stasis/app.c.

{
    if (!app) {
        return -1;
    }
 
    return app_unsubscribe_channel_id(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
}

References app, app_unsubscribe_channel_id(), ast_channel_uniqueid(), and CHANNEL_ALL.

Referenced by app_send_end_msg().

app_unsubscribe_channel_id()

int app_unsubscribe_channel_id	(	struct stasis_app *	app,
		const char *	channel_id
	)

Cancel the subscription an app has for a channel.

Parameters

app	Subscribing application.
channel_id	Id of channel to unsubscribe from.

Return values

0	on success.
Non-zero	on error.

Definition at line 1401 of file res/stasis/app.c.

{
    if (!app) {
        return -1;
    }
 
    return unsubscribe(app, "channel", channel_id, 0);
}

References app, and unsubscribe().

Referenced by app_unsubscribe_channel(), and send_start_msg_snapshots().

app_unsubscribe_endpoint_id()

int app_unsubscribe_endpoint_id	(	struct stasis_app *	app,
		const char *	endpoint_id
	)

Cancel the subscription an app has for a endpoint.

Parameters

app	Subscribing application.
endpoint_id	Id of endpoint to unsubscribe from.

Return values

0	on success.
Non-zero	on error.

Definition at line 1600 of file res/stasis/app.c.

{
    if (!app) {
        return -1;
    }
 
    return unsubscribe(app, "endpoint", endpoint_id, 0);
}

References app, and unsubscribe().

app_update()

void app_update	(	struct stasis_app *	app,
		stasis_app_cb	handler,
		void *	data
	)

Update the handler and data for a res_stasis application.

If app has been deactivated, this will reactivate it.

Parameters

app	Application to update.
handler	New application callback.
data	New data pointer for the callback.

Definition at line 1124 of file res/stasis/app.c.

{
    ao2_lock(app);
    if (app->handler && app->data) {
        struct ast_json *msg;
 
        ast_verb(1, "Replacing Stasis app '%s'\n", app->name);
 
        msg = ast_json_pack("{s: s, s: o?, s: s}",
            "type", "ApplicationReplaced",
            "timestamp", ast_json_timeval(ast_tvnow(), NULL),
            "application", app->name);
        if (msg) {
            /*
             * The app must be unlocked before calling 'send' since a handler may
             * subsequently attempt to grab the app lock after first obtaining a
             * lock for another object, thus causing a deadlock.
             */
            ao2_unlock(app);
            app_send(app, msg);
            ao2_lock(app);
            ast_json_unref(msg);
            if (!app->handler) {
                /*
                 * If the handler disappeared then the app was deactivated. In that
                 * case don't replace. Re-activation will reset the handler later.
                 */
                ao2_unlock(app);
                return;
            }
        }
    } else {
        ast_verb(1, "Activating Stasis app '%s'\n", app->name);
    }
 
    app->handler = handler;
    ao2_replace(app->data, data);
    ao2_unlock(app);
}

References ao2_lock, ao2_replace, ao2_unlock, app, app_send(), ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_tvnow(), ast_verb, handler(), and NULL.

Referenced by __stasis_app_register().