app.c File Reference

Stasis application support. More...

#include "asterisk.h"
#include "app.h"
#include "control.h"
#include "messaging.h"
#include "asterisk/callerid.h"
#include "asterisk/cli.h"
#include "asterisk/stasis_app.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_endpoints.h"
#include "asterisk/stasis_message_router.h"

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

Go to the source code of this file.

Data Structures
struct	app_forwards
struct	stasis_app

Macros
#define	BRIDGE_ALL   "__AST_BRIDGE_ALL_TOPIC"
#define	CHANNEL_ALL   "__AST_CHANNEL_ALL_TOPIC"
#define	ENDPOINT_ALL   "__AST_ENDPOINT_ALL_TOPIC"

Typedefs
typedef struct ast_json *(*	channel_snapshot_monitor) (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)
	Typedef for callbacks that get called on channel snapshot updates.

Enumerations
enum	forward_type { FORWARD_CHANNEL , FORWARD_BRIDGE , FORWARD_ENDPOINT }

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.
static void	app_dtor (void *obj)
static int	app_event_filter_matched (struct ast_json *array, struct ast_json *event, int empty)
static int	app_event_filter_set (struct stasis_app *app, struct ast_json **member, struct ast_json *filter, const char *filter_type)
static int	app_events_allowed_set (struct stasis_app *app, struct ast_json *filter)
static int	app_events_disallowed_set (struct stasis_app *app, struct ast_json *filter)
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.
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.
struct stasis_topic *	ast_app_get_topic (struct stasis_app *app)
	Returns the stasis topic for an app.
static int	bridge_app_subscribed (struct stasis_app *app, const char *uniqueid)
	Helper function for determining if the application is subscribed to a given entity.
static int	bridge_app_subscribed_involved (struct stasis_app *app, struct ast_bridge_snapshot *snapshot)
	Callback function for checking if channels in a bridge are subscribed to.
static void	bridge_attended_transfer_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	bridge_blind_transfer_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void *	bridge_find (const struct stasis_app *app, const char *id)
static void	bridge_merge_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	bridge_subscription_change_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	call_forwarded_handler (struct stasis_app *app, struct stasis_message *message)
static struct ast_json *	channel_callerid (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)
static struct ast_json *	channel_connected_line (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)
static struct ast_json *	channel_created_event (struct ast_channel_snapshot *snapshot, const struct timeval *tv)
static struct ast_json *	channel_destroyed_event (struct ast_channel_snapshot *snapshot, const struct timeval *tv)
static struct ast_json *	channel_dialplan (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)
static void *	channel_find (const struct stasis_app *app, const char *id)
static struct ast_json *	channel_state (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)
	Handle channel state changes.
static struct ast_json *	channel_state_change_event (struct ast_channel_snapshot *snapshot, const struct timeval *tv)
static void *	endpoint_find (const struct stasis_app *app, const char *id)
static void	endpoint_state_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static struct app_forwards *	forwards_create (struct stasis_app *app, const char *id)
static struct app_forwards *	forwards_create_bridge (struct stasis_app *app, struct ast_bridge *bridge)
static struct app_forwards *	forwards_create_channel (struct stasis_app *app, struct ast_channel *chan)
static struct app_forwards *	forwards_create_endpoint (struct stasis_app *app, struct ast_endpoint *endpoint)
static void	forwards_dtor (void *obj)
static int	forwards_filter_by_type (void *obj, void *arg, int flags)
static int	forwards_sort (const void *obj_left, const void *obj_right, int flags)
static void	forwards_unsubscribe (struct app_forwards *forwards)
static int	message_received_handler (const char *endpoint_id, struct ast_json *json_msg, void *pvt)
static struct ast_json *	simple_bridge_event (const char *type, struct ast_bridge_snapshot *snapshot, const struct timeval *tv)
static struct ast_json *	simple_channel_event (const char *type, struct ast_channel_snapshot *snapshot, const struct timeval *tv)
static struct ast_json *	simple_endpoint_event (const char *type, struct ast_endpoint_snapshot *snapshot, const struct timeval *tv)
int	stasis_app_event_allowed (const char *app_name, struct ast_json *event)
	Check if the given event should be filtered.
int	stasis_app_event_filter_set (struct stasis_app *app, struct ast_json *filter)
	Set the application's event type filter.
struct ast_json *	stasis_app_event_filter_to_json (struct stasis_app *app, struct ast_json *json)
	Convert and add the app's event type filter(s) to the given json object.
int	stasis_app_get_debug (struct stasis_app *app)
	Get debug status of an application.
int	stasis_app_get_debug_by_name (const char *app_name)
	Get debug status of an application.
const char *	stasis_app_name (const struct stasis_app *app)
	Retrieve an application's name.
void	stasis_app_register_event_sources (void)
	Register core event sources.
void	stasis_app_set_debug (struct stasis_app *app, int debug)
	Enable/disable request/response and event logging on an application.
void	stasis_app_set_debug_by_name (const char *app_name, int debug)
	Enable/disable request/response and event logging on an application.
void	stasis_app_set_global_debug (int debug)
	Enable/disable request/response and event logging on all applications.
void	stasis_app_to_cli (const struct stasis_app *app, struct ast_cli_args *a)
	Dump properties of a stasis_app to the CLI.
void	stasis_app_unregister_event_sources (void)
	Unregister core event sources.
static void	sub_bridge_update_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	sub_channel_update_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	sub_default_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	sub_endpoint_update_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static void	sub_subscription_change_handler (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	subscribe_bridge (struct stasis_app *app, void *obj)
static int	subscribe_channel (struct stasis_app *app, void *obj)
static int	subscribe_endpoint (struct stasis_app *app, void *obj)
static int	unsubscribe (struct stasis_app *app, const char *kind, const char *id, int terminate)

Variables
struct stasis_app_event_source	bridge_event_source
struct stasis_app_event_source	channel_event_source
static channel_snapshot_monitor	channel_monitors []
struct stasis_app_event_source	endpoint_event_source
int	global_debug

Detailed Description

Stasis application support.

Author

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

Definition in file res/stasis/app.c.

Macro Definition Documentation

BRIDGE_ALL

#define BRIDGE_ALL   "__AST_BRIDGE_ALL_TOPIC"

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

CHANNEL_ALL

#define CHANNEL_ALL   "__AST_CHANNEL_ALL_TOPIC"

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

ENDPOINT_ALL

#define ENDPOINT_ALL   "__AST_ENDPOINT_ALL_TOPIC"

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

Typedef Documentation

channel_snapshot_monitor

typedef struct ast_json *(* channel_snapshot_monitor) (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot, const struct timeval *tv)

Typedef for callbacks that get called on channel snapshot updates.

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

Enumeration Type Documentation

forward_type

enum forward_type

Enumerator
FORWARD_CHANNEL
FORWARD_BRIDGE
FORWARD_ENDPOINT

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

                  {
    FORWARD_CHANNEL,
    FORWARD_BRIDGE,
    FORWARD_ENDPOINT,
};

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 932 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 1078 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_dtor()

static void app_dtor ( void *  obj )

static

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

{
    struct stasis_app *app = obj;
    size_t size = strlen("stasis-") + strlen(app->name) + 1;
    char context_name[size];
 
    ast_verb(1, "Destroying Stasis app %s\n", app->name);
 
    ast_assert(app->router == NULL);
    ast_assert(app->bridge_router == NULL);
    ast_assert(app->endpoint_router == NULL);
 
    /* If we created a context for this application, remove it */
    strcpy(context_name, "stasis-");
    strcat(context_name, app->name);
    ast_context_destroy_by_name(context_name, "res_stasis");
 
    ao2_cleanup(app->topic);
    app->topic = NULL;
    ao2_cleanup(app->forwards);
    app->forwards = NULL;
    ao2_cleanup(app->data);
    app->data = NULL;
 
    ast_json_unref(app->events_allowed);
    app->events_allowed = NULL;
    ast_json_unref(app->events_disallowed);
    app->events_disallowed = NULL;
 
}

References ao2_cleanup, app, ast_assert, ast_context_destroy_by_name(), ast_json_unref(), ast_verb, context_name, and NULL.

Referenced by app_create().

app_event_filter_matched()

static int app_event_filter_matched ( struct ast_json *  array, struct ast_json *  event, int  empty  )

static

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

{
    struct ast_json *obj;
    int i;
 
    if (!array || !ast_json_array_size(array)) {
        return empty;
    }
 
    for (i = 0; i < ast_json_array_size(array) &&
            (obj = ast_json_array_get(array, i)); ++i) {
 
        if (ast_strings_equal(ast_json_object_string_get(obj, "type"),
                ast_json_object_string_get(event, "type"))) {
            return 1;
        }
    }
 
    return 0;
}

References array(), ast_json_array_get(), ast_json_array_size(), ast_json_object_string_get, and ast_strings_equal().

Referenced by stasis_app_event_allowed().

app_event_filter_set()

static int app_event_filter_set ( struct stasis_app *  app, struct ast_json **  member, struct ast_json *  filter, const char *  filter_type  )

static

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

{
    if (filter && ast_json_typeof(filter) == AST_JSON_OBJECT) {
        if (!ast_json_object_size(filter)) {
            /* If no filters are specified then reset this filter type */
            filter = NULL;
        } else {
            /* Otherwise try to get the filter array for this type */
            filter = ast_json_object_get(filter, filter_type);
            if (!filter) {
                /* A filter type exists, but not this one, so don't update */
                return 0;
            }
        }
    }
 
    /* At this point the filter object should be an array */
    if (filter && ast_json_typeof(filter) != AST_JSON_ARRAY) {
        ast_log(LOG_ERROR, "Invalid json type event filter - app: %s, filter: %s\n",
                app->name, filter_type);
        return -1;
    }
 
    if (filter) {
        /* Confirm that at least the type names are specified */
        struct ast_json *obj;
        int i;
 
        for (i = 0; i < ast_json_array_size(filter) &&
                 (obj = ast_json_array_get(filter, i)); ++i) {
 
            if (ast_strlen_zero(ast_json_object_string_get(obj, "type"))) {
                ast_log(LOG_ERROR, "Filter event must have a type - app: %s, "
                        "filter: %s\n", app->name, filter_type);
                return -1;
            }
        }
    }
 
    ao2_lock(app);
    ast_json_unref(*member);
    *member = filter ? ast_json_ref(filter) : NULL;
    ao2_unlock(app);
 
    return 0;
}

References ao2_lock, ao2_unlock, app, AST_JSON_ARRAY, ast_json_array_get(), ast_json_array_size(), AST_JSON_OBJECT, ast_json_object_get(), ast_json_object_size(), ast_json_object_string_get, ast_json_ref(), ast_json_typeof(), ast_json_unref(), ast_log, ast_strlen_zero(), filter(), LOG_ERROR, and NULL.

Referenced by app_events_allowed_set(), and app_events_disallowed_set().

app_events_allowed_set()

static int app_events_allowed_set ( struct stasis_app *  app, struct ast_json *  filter  )

static

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

{
    return app_event_filter_set(app, &app->events_allowed, filter, "allowed");
}

References app, app_event_filter_set(), and filter().

Referenced by stasis_app_event_filter_set().

app_events_disallowed_set()

static int app_events_disallowed_set ( struct stasis_app *  app, struct ast_json *  filter  )

static

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

{
    return app_event_filter_set(app, &app->events_disallowed, filter, "disallowed");
}

References app, app_event_filter_set(), and filter().

Referenced by stasis_app_event_filter_set().

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 1106 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 1117 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 1516 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 1414 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 1613 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 1050 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_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 1090 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 1440 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 1293 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 1543 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 1240 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 1498 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 1507 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 1396 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 1405 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 1604 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 1128 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().

ast_app_get_topic()

struct stasis_topic * ast_app_get_topic

(

struct stasis_app *

app

)

Returns the stasis topic for an app.

Parameters

app	Stasis app to get topic of

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

{
    return app->topic;
}

References app.

Referenced by app_send_end_msg(), send_start_msg_snapshots(), and stasis_app_user_event().

bridge_app_subscribed()

static int bridge_app_subscribed ( struct stasis_app *  app, const char *  uniqueid  )

static

Helper function for determining if the application is subscribed to a given entity.

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

{
    struct app_forwards *forwards = NULL;
 
    forwards = ao2_find(app->forwards, uniqueid, OBJ_SEARCH_KEY);
    if (!forwards) {
        return 0;
    }
 
    ao2_ref(forwards, -1);
    return 1;
}

References ao2_find, ao2_ref, app, NULL, and OBJ_SEARCH_KEY.

Referenced by bridge_app_subscribed_involved(), bridge_attended_transfer_handler(), bridge_blind_transfer_handler(), and bridge_merge_handler().

bridge_app_subscribed_involved()

static int bridge_app_subscribed_involved ( struct stasis_app *  app, struct ast_bridge_snapshot *  snapshot  )

static

Callback function for checking if channels in a bridge are subscribed to.

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

{
    int subscribed = 0;
    struct ao2_iterator iter;
    char *uniqueid;
 
    if (bridge_app_subscribed(app, snapshot->uniqueid)) {
        return 1;
    }
 
    iter = ao2_iterator_init(snapshot->channels, 0);
    for (; (uniqueid = ao2_iterator_next(&iter)); ao2_ref(uniqueid, -1)) {
        if (bridge_app_subscribed(app, uniqueid)) {
            subscribed = 1;
            ao2_ref(uniqueid, -1);
            break;
        }
    }
    ao2_iterator_destroy(&iter);
 
    return subscribed;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, app, bridge_app_subscribed(), ast_bridge_snapshot::channels, subscribed, and ast_bridge_snapshot::uniqueid.

Referenced by bridge_attended_transfer_handler(), and bridge_blind_transfer_handler().

bridge_attended_transfer_handler()

static void bridge_attended_transfer_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct ast_attended_transfer_message *transfer_msg = stasis_message_data(message);
    int subscribed = 0;
 
    subscribed = bridge_app_subscribed(app, transfer_msg->to_transferee.channel_snapshot->base->uniqueid);
    if (!subscribed) {
        subscribed = bridge_app_subscribed(app, transfer_msg->to_transfer_target.channel_snapshot->base->uniqueid);
    }
    if (!subscribed && transfer_msg->to_transferee.bridge_snapshot) {
        subscribed = bridge_app_subscribed_involved(app, transfer_msg->to_transferee.bridge_snapshot);
    }
    if (!subscribed && transfer_msg->to_transfer_target.bridge_snapshot) {
        subscribed = bridge_app_subscribed_involved(app, transfer_msg->to_transfer_target.bridge_snapshot);
    }
 
    if (!subscribed) {
        switch (transfer_msg->dest_type) {
        case AST_ATTENDED_TRANSFER_DEST_BRIDGE_MERGE:
            subscribed = bridge_app_subscribed(app, transfer_msg->dest.bridge);
            break;
        case AST_ATTENDED_TRANSFER_DEST_LINK:
            subscribed = bridge_app_subscribed(app, transfer_msg->dest.links[0]->base->uniqueid);
            if (!subscribed) {
                subscribed = bridge_app_subscribed(app, transfer_msg->dest.links[1]->base->uniqueid);
            }
            break;
        break;
        case AST_ATTENDED_TRANSFER_DEST_THREEWAY:
            subscribed = bridge_app_subscribed_involved(app, transfer_msg->dest.threeway.bridge_snapshot);
            if (!subscribed) {
                subscribed = bridge_app_subscribed(app, transfer_msg->dest.threeway.channel_snapshot->base->uniqueid);
            }
            break;
        default:
            break;
        }
    }
 
    if (subscribed) {
        stasis_publish(app->topic, message);
    }
}

References app, AST_ATTENDED_TRANSFER_DEST_BRIDGE_MERGE, AST_ATTENDED_TRANSFER_DEST_LINK, AST_ATTENDED_TRANSFER_DEST_THREEWAY, ast_channel_snapshot::base, ast_attended_transfer_message::bridge, bridge_app_subscribed(), bridge_app_subscribed_involved(), ast_bridge_channel_snapshot_pair::bridge_snapshot, ast_bridge_channel_snapshot_pair::channel_snapshot, stasis_app::data, ast_attended_transfer_message::dest, ast_attended_transfer_message::dest_type, ast_attended_transfer_message::links, stasis_message_data(), stasis_publish(), subscribed, ast_attended_transfer_message::threeway, ast_attended_transfer_message::to_transfer_target, ast_attended_transfer_message::to_transferee, and ast_channel_snapshot_base::uniqueid.

Referenced by app_create().

bridge_blind_transfer_handler()

static void bridge_blind_transfer_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct ast_blind_transfer_message *transfer_msg = stasis_message_data(message);
    struct ast_bridge_snapshot *bridge = transfer_msg->bridge;
 
    if (bridge_app_subscribed(app, transfer_msg->transferer->base->uniqueid) ||
        (bridge && bridge_app_subscribed_involved(app, bridge))) {
        stasis_publish(app->topic, message);
    }
}

References app, ast_channel_snapshot::base, ast_blind_transfer_message::bridge, bridge_app_subscribed(), bridge_app_subscribed_involved(), stasis_app::data, stasis_message_data(), stasis_publish(), ast_blind_transfer_message::transferer, and ast_channel_snapshot_base::uniqueid.

Referenced by app_create().

bridge_find()

static void * bridge_find ( const struct stasis_app *  app, const char *  id  )

static

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

{
    return stasis_app_bridge_find_by_id(id);
}

References stasis_app_bridge_find_by_id().

bridge_merge_handler()

static void bridge_merge_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct ast_bridge_merge_message *merge;
 
    merge = stasis_message_data(message);
 
    /* Find out if we're subscribed to either bridge */
    if (bridge_app_subscribed(app, merge->from->uniqueid) ||
        bridge_app_subscribed(app, merge->to->uniqueid)) {
        /* Forward the message to the app */
        stasis_publish(app->topic, message);
    }
}

References app, bridge_app_subscribed(), stasis_app::data, ast_bridge_merge_message::from, stasis_message_data(), stasis_publish(), ast_bridge_merge_message::to, and ast_bridge_snapshot::uniqueid.

Referenced by app_create().

bridge_subscription_change_handler()

static void bridge_subscription_change_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
 
    if (stasis_subscription_final_message(sub, message)) {
        ao2_cleanup(app);
    }
}

References ao2_cleanup, app, stasis_app::data, stasis_subscription_final_message(), and sub.

Referenced by app_create().

call_forwarded_handler()

static void call_forwarded_handler ( struct stasis_app *  app, struct stasis_message *  message  )

static

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

{
    struct ast_multi_channel_blob *payload = stasis_message_data(message);
    struct ast_channel_snapshot *snapshot = ast_multi_channel_blob_get_channel(payload, "forwarded");
    struct ast_channel *chan;
 
    if (!snapshot) {
        return;
    }
 
    chan = ast_channel_get_by_name(snapshot->base->uniqueid);
    if (!chan) {
        return;
    }
 
    app_subscribe_channel(app, chan);
    ast_channel_unref(chan);
}

References app, app_subscribe_channel(), ast_channel_get_by_name(), ast_channel_unref, ast_multi_channel_blob_get_channel(), ast_channel_snapshot::base, ast_channel::snapshot, stasis_message_data(), and ast_channel_snapshot_base::uniqueid.

channel_callerid()

static struct ast_json * channel_callerid ( struct ast_channel_snapshot *  old_snapshot, struct ast_channel_snapshot *  new_snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_channel;
 
    /* No NewCallerid event on first channel snapshot */
    if (!old_snapshot) {
        return NULL;
    }
 
    if (ast_channel_snapshot_caller_id_equal(old_snapshot, new_snapshot)) {
        return NULL;
    }
 
    json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: i, s: s, s: o}",
        "type", "ChannelCallerId",
        "timestamp", ast_json_timeval(*tv, NULL),
        "caller_presentation", new_snapshot->caller->pres,
        "caller_presentation_txt", ast_describe_caller_presentation(
            new_snapshot->caller->pres),
        "channel", json_channel);
}

References ast_channel_snapshot_caller_id_equal(), ast_channel_snapshot_to_json(), ast_describe_caller_presentation(), ast_json_pack(), ast_json_timeval(), ast_channel_snapshot::caller, NULL, ast_channel_snapshot_caller::pres, and stasis_app_get_sanitizer().

channel_connected_line()

static struct ast_json * channel_connected_line ( struct ast_channel_snapshot *  old_snapshot, struct ast_channel_snapshot *  new_snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_channel;
 
    /* No ChannelConnectedLine event on first channel snapshot */
    if (!old_snapshot) {
        return NULL;
    }
 
    if (ast_channel_snapshot_connected_line_equal(old_snapshot, new_snapshot)) {
        return NULL;
    }
 
    json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: o}",
        "type", "ChannelConnectedLine",
        "timestamp", ast_json_timeval(*tv, NULL),
        "channel", json_channel);
}

References ast_channel_snapshot_connected_line_equal(), ast_channel_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), NULL, and stasis_app_get_sanitizer().

channel_created_event()

static struct ast_json * channel_created_event ( struct ast_channel_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    return simple_channel_event("ChannelCreated", snapshot, tv);
}

References simple_channel_event().

Referenced by channel_state().

channel_destroyed_event()

static struct ast_json * channel_destroyed_event ( struct ast_channel_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
    struct ast_json *blob;
 
    if (!json_channel) {
        return NULL;
    }
 
    blob = ast_json_pack("{s: s, s: o, s: i, s: s}",
        "type", "ChannelDestroyed",
        "timestamp", ast_json_timeval(*tv, NULL),
        "cause", snapshot->hangup->cause,
        "cause_txt", ast_cause2str(snapshot->hangup->cause));
 
    if (!blob) {
        return NULL;
    }
 
    if (snapshot->hangup->tech_cause) {
        ast_json_object_set(blob, "tech_cause",
            ast_json_integer_create(snapshot->hangup->tech_cause));
    }
 
    ast_json_object_set(blob, "channel", json_channel);
 
    return blob;
}

References ast_cause2str(), ast_channel_snapshot_to_json(), ast_json_integer_create(), ast_json_object_set(), ast_json_pack(), ast_json_timeval(), ast_channel_snapshot_hangup::cause, ast_channel_snapshot::hangup, NULL, stasis_app_get_sanitizer(), and ast_channel_snapshot_hangup::tech_cause.

Referenced by channel_state().

channel_dialplan()

static struct ast_json * channel_dialplan ( struct ast_channel_snapshot *  old_snapshot, struct ast_channel_snapshot *  new_snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_channel;
 
    /* No Newexten event on first channel snapshot */
    if (!old_snapshot) {
        return NULL;
    }
 
    /* Empty application is not valid for a Newexten event */
    if (ast_strlen_zero(new_snapshot->dialplan->appl)) {
        return NULL;
    }
 
    if (ast_channel_snapshot_cep_equal(old_snapshot, new_snapshot)) {
        return NULL;
    }
 
    json_channel = ast_channel_snapshot_to_json(new_snapshot, stasis_app_get_sanitizer());
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: s, s: s, s: o}",
        "type", "ChannelDialplan",
        "timestamp", ast_json_timeval(*tv, NULL),
        "dialplan_app", new_snapshot->dialplan->appl,
        "dialplan_app_data", AST_JSON_UTF8_VALIDATE(new_snapshot->dialplan->data),
        "channel", json_channel);
}

References ast_channel_snapshot_dialplan::appl, ast_channel_snapshot_cep_equal(), ast_channel_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), AST_JSON_UTF8_VALIDATE, ast_strlen_zero(), ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, NULL, and stasis_app_get_sanitizer().

channel_find()

static void * channel_find ( const struct stasis_app *  app, const char *  id  )

static

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

{
    return ast_channel_get_by_name(id);
}

References ast_channel_get_by_name().

channel_state()

static struct ast_json * channel_state ( struct ast_channel_snapshot *  old_snapshot, struct ast_channel_snapshot *  new_snapshot, const struct timeval *  tv  )

static

Handle channel state changes.

Note

For channel snapshot updates, new_snapshot is guaranteed to be non-NULL. A channel going away is indicated by AST_FLAG_DEAD on the new snapshot. See stasis_channels.h for the invariant.

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

{
 
    if (!old_snapshot) {
        return channel_created_event(new_snapshot, tv);
    } else if (ast_test_flag(&new_snapshot->flags, AST_FLAG_DEAD)) {
        return channel_destroyed_event(new_snapshot, tv);
    } else if (old_snapshot->state != new_snapshot->state) {
        return channel_state_change_event(new_snapshot, tv);
    }
 
    return NULL;
}

References AST_FLAG_DEAD, ast_test_flag, channel_created_event(), channel_destroyed_event(), channel_state_change_event(), ast_channel_snapshot::flags, NULL, and ast_channel_snapshot::state.

channel_state_change_event()

static struct ast_json * channel_state_change_event ( struct ast_channel_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    return simple_channel_event("ChannelStateChange", snapshot, tv);
}

References simple_channel_event().

Referenced by channel_state().

endpoint_find()

static void * endpoint_find ( const struct stasis_app *  app, const char *  id  )

static

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

{
    return ast_endpoint_find_by_id(id);
}

References ast_endpoint_find_by_id().

endpoint_state_cb()

static void endpoint_state_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
 
    stasis_publish(app->topic, message);
}

References app, stasis_app::data, and stasis_publish().

Referenced by forwards_create_endpoint().

forwards_create()

static struct app_forwards * forwards_create ( struct stasis_app *  app, const char *  id  )

static

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

{
    struct app_forwards *forwards;
 
    if (!app || ast_strlen_zero(id)) {
        return NULL;
    }
 
    forwards = ao2_t_alloc(sizeof(*forwards) + strlen(id) + 1, forwards_dtor, id);
    if (!forwards) {
        return NULL;
    }
 
    strcpy(forwards->id, id); /* SAFE */
 
    return forwards;
}

References ao2_t_alloc, app, ast_strlen_zero(), forwards_dtor(), app_forwards::id, and NULL.

Referenced by forwards_create_bridge(), forwards_create_channel(), and forwards_create_endpoint().

forwards_create_bridge()

static struct app_forwards * forwards_create_bridge ( struct stasis_app *  app, struct ast_bridge *  bridge  )

static

Forward a bridge's topics to an app

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

{
    struct app_forwards *forwards;
 
    if (!app) {
        return NULL;
    }
 
    forwards = forwards_create(app, bridge ? bridge->uniqueid : BRIDGE_ALL);
    if (!forwards) {
        return NULL;
    }
 
    forwards->forward_type = FORWARD_BRIDGE;
    forwards->topic_forward = stasis_forward_all(ast_bridge_topic(bridge), app->topic);
 
    if (!forwards->topic_forward && bridge) {
        forwards_unsubscribe(forwards);
        ao2_ref(forwards, -1);
        return NULL;
    }
 
    return forwards;
}

References ao2_ref, app, ast_bridge_topic(), BRIDGE_ALL, FORWARD_BRIDGE, app_forwards::forward_type, forwards_create(), forwards_unsubscribe(), NULL, stasis_forward_all(), app_forwards::topic_forward, and ast_bridge::uniqueid.

Referenced by app_subscribe_bridge().

forwards_create_channel()

static struct app_forwards * forwards_create_channel ( struct stasis_app *  app, struct ast_channel *  chan  )

static

Forward a channel's topics to an app

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

{
    struct app_forwards *forwards;
 
    if (!app) {
        return NULL;
    }
 
    forwards = forwards_create(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
    if (!forwards) {
        return NULL;
    }
 
    forwards->forward_type = FORWARD_CHANNEL;
    forwards->topic_forward = stasis_forward_all(
        chan ? ast_channel_topic(chan) : ast_channel_topic_all(),
        app->topic);
 
    if (!forwards->topic_forward) {
        ao2_ref(forwards, -1);
        return NULL;
    }
 
    return forwards;
}

References ao2_ref, app, ast_channel_topic(), ast_channel_topic_all(), ast_channel_uniqueid(), CHANNEL_ALL, FORWARD_CHANNEL, app_forwards::forward_type, forwards_create(), NULL, stasis_forward_all(), and app_forwards::topic_forward.

Referenced by app_subscribe_channel().

forwards_create_endpoint()

static struct app_forwards * forwards_create_endpoint ( struct stasis_app *  app, struct ast_endpoint *  endpoint  )

static

Forward a endpoint's topics to an app

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

{
    struct app_forwards *forwards;
    int ret = 0;
 
    if (!app) {
        return NULL;
    }
 
    forwards = forwards_create(app, endpoint ? ast_endpoint_get_id(endpoint) : ENDPOINT_ALL);
    if (!forwards) {
        return NULL;
    }
 
    forwards->forward_type = FORWARD_ENDPOINT;
    if (endpoint) {
        forwards->topic_forward = stasis_forward_all(ast_endpoint_topic(endpoint),
            app->topic);
        forwards->topic_cached_forward = stasis_forward_all(
            ast_endpoint_topic_cached(endpoint), app->topic);
 
        if (!forwards->topic_forward || !forwards->topic_cached_forward) {
            /* Half-subscribed is a bad thing */
            forwards_unsubscribe(forwards);
            ao2_ref(forwards, -1);
            return NULL;
        }
    } else {
        /* Since endpoint subscriptions also subscribe to channels, in the case
         * of all endpoint subscriptions, we only want messages for the endpoints.
         * As such, we route those particular messages and then re-publish them
         * on the app's topic.
         */
        ast_assert(app->endpoint_router == NULL);
        app->endpoint_router = stasis_message_router_create(ast_endpoint_topic_all_cached());
        if (!app->endpoint_router) {
            forwards_unsubscribe(forwards);
            ao2_ref(forwards, -1);
            return NULL;
        }
 
        ret |= stasis_message_router_add(app->endpoint_router,
            ast_endpoint_state_type(), endpoint_state_cb, app);
        ret |= stasis_message_router_add(app->endpoint_router,
            ast_endpoint_contact_state_type(), endpoint_state_cb, app);
 
        if (ret) {
            ao2_ref(app->endpoint_router, -1);
            app->endpoint_router = NULL;
            ao2_ref(forwards, -1);
            return NULL;
        }
    }
 
    return forwards;
}

References ao2_ref, app, ast_assert, ast_endpoint_contact_state_type(), ast_endpoint_get_id(), ast_endpoint_state_type(), ast_endpoint_topic(), ast_endpoint_topic_all_cached(), ast_endpoint_topic_cached(), ENDPOINT_ALL, endpoint_state_cb(), FORWARD_ENDPOINT, app_forwards::forward_type, forwards_create(), forwards_unsubscribe(), NULL, stasis_forward_all(), stasis_message_router_add(), stasis_message_router_create, app_forwards::topic_cached_forward, and app_forwards::topic_forward.

Referenced by app_subscribe_endpoint().

forwards_dtor()

static void forwards_dtor ( void *  obj )

static

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

{
#ifdef AST_DEVMODE
    struct app_forwards *forwards = obj;
#endif /* AST_DEVMODE */
 
    ast_assert(forwards->topic_forward == NULL);
    ast_assert(forwards->topic_cached_forward == NULL);
}

References ast_assert, NULL, app_forwards::topic_cached_forward, and app_forwards::topic_forward.

Referenced by forwards_create().

forwards_filter_by_type()

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

static

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

{
    struct app_forwards *forward = obj;
    enum forward_type *forward_type = arg;
 
    if (forward->forward_type == *forward_type) {
        return CMP_MATCH;
    }
 
    return 0;
}

References CMP_MATCH, and app_forwards::forward_type.

Referenced by stasis_app_to_cli().

forwards_sort()

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

static

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

{
    const struct app_forwards *object_left = obj_left;
    const struct app_forwards *object_right = obj_right;
    const char *right_key = obj_right;
    int cmp;
 
    switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
    case OBJ_POINTER:
        right_key = object_right->id;
        /* Fall through */
    case OBJ_KEY:
        cmp = strcmp(object_left->id, right_key);
        break;
    case OBJ_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->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, app_forwards::id, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by app_create().

forwards_unsubscribe()

static void forwards_unsubscribe ( struct app_forwards *  forwards )

static

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

{
    stasis_forward_cancel(forwards->topic_forward);
    forwards->topic_forward = NULL;
    stasis_forward_cancel(forwards->topic_cached_forward);
    forwards->topic_cached_forward = NULL;
}

References NULL, stasis_forward_cancel(), app_forwards::topic_cached_forward, and app_forwards::topic_forward.

Referenced by forwards_create_bridge(), forwards_create_endpoint(), and unsubscribe().

message_received_handler()

static int message_received_handler ( const char *  endpoint_id, struct ast_json *  json_msg, void *  pvt  )

static

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

{
    struct ast_endpoint_snapshot *snapshot;
    struct ast_json *json_endpoint;
    struct ast_json *message;
    struct stasis_app *app = pvt;
    char *tech;
    char *resource;
 
    tech = ast_strdupa(endpoint_id);
    resource = strchr(tech, '/');
    if (resource) {
        resource[0] = '\0';
        resource++;
    }
 
    if (ast_strlen_zero(tech) || ast_strlen_zero(resource)) {
        return -1;
    }
 
    snapshot = ast_endpoint_latest_snapshot(tech, resource);
    if (!snapshot) {
        return -1;
    }
 
    json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
    ao2_ref(snapshot, -1);
    if (!json_endpoint) {
        return -1;
    }
 
    message = ast_json_pack("{s: s, s: o, s: o, s: o}",
        "type", "TextMessageReceived",
        "timestamp", ast_json_timeval(ast_tvnow(), NULL),
        "endpoint", json_endpoint,
        "message", ast_json_ref(json_msg));
    if (message) {
        app_send(app, message);
        ast_json_unref(message);
    }
 
    return 0;
}

References ao2_ref, app, app_send(), ast_endpoint_latest_snapshot(), ast_endpoint_snapshot_to_json(), ast_json_pack(), ast_json_ref(), ast_json_timeval(), ast_json_unref(), ast_strdupa, ast_strlen_zero(), ast_tvnow(), NULL, and stasis_app_get_sanitizer().

Referenced by app_subscribe_endpoint().

simple_bridge_event()

static struct ast_json * simple_bridge_event ( const char *  type, struct ast_bridge_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_bridge = ast_bridge_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
    if (!json_bridge) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: o}",
        "type", type,
        "timestamp", ast_json_timeval(*tv, NULL),
        "bridge", json_bridge);
}

References ast_bridge_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), NULL, stasis_app_get_sanitizer(), and type.

Referenced by sub_bridge_update_handler().

simple_channel_event()

static struct ast_json * simple_channel_event ( const char *  type, struct ast_channel_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_channel = ast_channel_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
 
    if (!json_channel) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: o}",
        "type", type,
        "timestamp", ast_json_timeval(*tv, NULL),
        "channel", json_channel);
}

References ast_channel_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), NULL, stasis_app_get_sanitizer(), and type.

Referenced by channel_created_event(), and channel_state_change_event().

simple_endpoint_event()

static struct ast_json * simple_endpoint_event ( const char *  type, struct ast_endpoint_snapshot *  snapshot, const struct timeval *  tv  )

static

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

{
    struct ast_json *json_endpoint = ast_endpoint_snapshot_to_json(snapshot, stasis_app_get_sanitizer());
 
    if (!json_endpoint) {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o, s: o}",
        "type", type,
        "timestamp", ast_json_timeval(*tv, NULL),
        "endpoint", json_endpoint);
}

References ast_endpoint_snapshot_to_json(), ast_json_pack(), ast_json_timeval(), NULL, stasis_app_get_sanitizer(), and type.

Referenced by sub_endpoint_update_handler().

stasis_app_event_allowed()

int stasis_app_event_allowed	(	const char *	app_name,
		struct ast_json *	event
	)

Check if the given event should be filtered.

Attempts first to find the event in the application's disallowed events list. If found then the event won't be sent to the remote. If not found in the disallowed list then a search is done to see if it can be found in the allowed list. If found the event message is sent, otherwise it is not sent.

Parameters

app_name	The application name
event	The event to check

Returns

True if allowed, false otherwise

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

{
    struct stasis_app *app = stasis_app_get_by_name(app_name);
    int res;
 
    if (!app) {
        return 0;
    }
 
    ao2_lock(app);
    res = !app_event_filter_matched(app->events_disallowed, event, 0) &&
        app_event_filter_matched(app->events_allowed, event, 1);
    ao2_unlock(app);
    ao2_ref(app, -1);
 
    return res;
}

References ao2_lock, ao2_ref, ao2_unlock, app, app_event_filter_matched(), app_name(), and stasis_app_get_by_name().

Referenced by ari_websocket_send_event().

stasis_app_event_filter_set()

int stasis_app_event_filter_set	(	struct stasis_app *	app,
		struct ast_json *	filter
	)

Set the application's event type filter.

Parameters

app	The application
filter	The allowed and/or disallowed event filter

Returns

0 if successfully set

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

{
    return app_events_disallowed_set(app, filter) || app_events_allowed_set(app, filter);
}

References app, app_events_allowed_set(), app_events_disallowed_set(), and filter().

Referenced by ast_ari_applications_filter().

stasis_app_event_filter_to_json()

struct ast_json * stasis_app_event_filter_to_json	(	struct stasis_app *	app,
		struct ast_json *	json
	)

Convert and add the app's event type filter(s) to the given json object.

Parameters

app	The application
json	The json object to add the filter data to

Returns

The given json object

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

{
    if (!app || !json) {
        return json;
    }
 
    ast_json_object_set(json, "events_allowed", app->events_allowed ?
        ast_json_ref(app->events_allowed) : ast_json_array_create());
    ast_json_object_set(json, "events_disallowed", app->events_disallowed ?
        ast_json_ref(app->events_disallowed) : ast_json_array_create());
 
    return json;
}

References app, ast_json_array_create(), ast_json_object_set(), and ast_json_ref().

Referenced by stasis_app_object_to_json().

stasis_app_get_debug()

int stasis_app_get_debug

(

struct stasis_app *

app

)

Get debug status of an application.

Parameters

app	The app to check

Returns

The debug flag for the app || the global debug flag

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

{
    return (app ? app->debug : 0) || global_debug;
}

References app, and global_debug.

stasis_app_get_debug_by_name()

int stasis_app_get_debug_by_name

(

const char *

app_name

)

Get debug status of an application.

Parameters

app_name

The app_name to check

Returns

The debug flag for the app || the global debug flag

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

{
    int debug_enabled = 0;
 
    if (global_debug) {
        debug_enabled = 1;
    } else {
        struct stasis_app *app = stasis_app_get_by_name(app_name);
 
        if (app) {
            if (app->debug) {
                debug_enabled = 1;
            }
            ao2_ref(app, -1);
        }
    }
    return debug_enabled;
}

References ao2_ref, app, app_name(), global_debug, and stasis_app_get_by_name().

Referenced by ari_websocket_process_request(), ast_ari_callback(), session_send_app_event(), and stasis_app_message_handler().

stasis_app_name()

const char * stasis_app_name

(

const struct stasis_app *

app

)

Retrieve an application's name.

Parameters

app	An application

Returns

The name of the application.

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

{
    return app->name;
}

References app.

Referenced by app_compare(), app_hash(), app_send_end_msg(), app_subscribe(), app_unsubscribe(), append_name(), ari_set_debug(), bridge_stasis_push_peek(), cleanup_cb(), device_state_subscription_create(), devices_to_json(), find_device_state_subscription(), send_start_msg_snapshots(), stasis_app_exec(), and subscribe_device_state().

stasis_app_register_event_sources()

void stasis_app_register_event_sources

(

void

)

Register core event sources.

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

{
    stasis_app_register_event_source(&channel_event_source);
    stasis_app_register_event_source(&bridge_event_source);
    stasis_app_register_event_source(&endpoint_event_source);
}

References bridge_event_source, channel_event_source, endpoint_event_source, and stasis_app_register_event_source().

Referenced by load_module().

stasis_app_set_debug()

void stasis_app_set_debug	(	struct stasis_app *	app,
		int	debug
	)

Enable/disable request/response and event logging on an application.

Parameters

app	The app to debug
debug	If non-zero, enable debugging. If zero, disable.

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

{
    if (!app) {
        return;
    }
 
    app->debug = debug;
}

References app, and debug.

Referenced by ari_set_debug(), and stasis_app_set_global_debug().

stasis_app_set_debug_by_name()

void stasis_app_set_debug_by_name	(	const char *	app_name,
		int	debug
	)

Enable/disable request/response and event logging on an application.

Parameters

app_name	The app name to debug
debug	If non-zero, enable debugging. If zero, disable.

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

{
    struct stasis_app *app = stasis_app_get_by_name(app_name);
 
    if (!app) {
        return;
    }
 
    app->debug = debug;
    ao2_cleanup(app);
}

References ao2_cleanup, app, app_name(), debug, and stasis_app_get_by_name().

stasis_app_set_global_debug()

void stasis_app_set_global_debug

(

int

debug

)

Enable/disable request/response and event logging on all applications.

Parameters

debug

If non-zero, enable debugging. If zero, disable.

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

{
    global_debug = debug;
    if (!global_debug) {
        struct ao2_container *app_names = stasis_app_get_all();
        struct ao2_iterator it_app_names;
        char *app_name;
        struct stasis_app *app;
 
        if (!app_names || !ao2_container_count(app_names)) {
            ao2_cleanup(app_names);
            return;
        }
 
        it_app_names = ao2_iterator_init(app_names, 0);
        while ((app_name = ao2_iterator_next(&it_app_names))) {
            if ((app = stasis_app_get_by_name(app_name))) {
                stasis_app_set_debug(app, 0);
            }
 
            ao2_cleanup(app_name);
            ao2_cleanup(app);
        }
        ao2_iterator_cleanup(&it_app_names);
        ao2_cleanup(app_names);
    }
}

References ao2_cleanup, ao2_container_count(), ao2_iterator_cleanup(), ao2_iterator_init(), ao2_iterator_next, app, app_name(), debug, global_debug, stasis_app_get_all(), stasis_app_get_by_name(), and stasis_app_set_debug().

Referenced by ari_set_debug().

stasis_app_to_cli()

void stasis_app_to_cli	(	const struct stasis_app *	app,
		struct ast_cli_args *	a
	)

Dump properties of a stasis_app to the CLI.

Parameters

app	The application
a	The CLI arguments

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

{
    struct ao2_iterator *channels;
    struct ao2_iterator *endpoints;
    struct ao2_iterator *bridges;
    struct app_forwards *forward;
    enum forward_type forward_type;
 
    ast_cli(a->fd, "Name: %s\n"
        "  Debug: %s\n"
        "  Subscription Model: %s\n",
        app->name,
        app->debug ? "Yes" : "No",
        app->subscription_model == STASIS_APP_SUBSCRIBE_ALL ?
            "Global Resource Subscription" :
            "Application/Explicit Resource Subscription");
    ast_cli(a->fd, "  Subscriptions: %d\n", ao2_container_count(app->forwards));
 
    ast_cli(a->fd, "    Channels:\n");
    forward_type = FORWARD_CHANNEL;
    channels = ao2_callback(app->forwards, OBJ_MULTIPLE,
        forwards_filter_by_type, &forward_type);
    if (channels) {
        while ((forward = ao2_iterator_next(channels))) {
            ast_cli(a->fd, "      %s (%d)\n", forward->id, forward->interested);
            ao2_ref(forward, -1);
        }
        ao2_iterator_destroy(channels);
    }
 
    ast_cli(a->fd, "    Bridges:\n");
    forward_type = FORWARD_BRIDGE;
    bridges = ao2_callback(app->forwards, OBJ_MULTIPLE,
        forwards_filter_by_type, &forward_type);
    if (bridges) {
        while ((forward = ao2_iterator_next(bridges))) {
            ast_cli(a->fd, "      %s (%d)\n", forward->id, forward->interested);
            ao2_ref(forward, -1);
        }
        ao2_iterator_destroy(bridges);
    }
 
    ast_cli(a->fd, "    Endpoints:\n");
    forward_type = FORWARD_ENDPOINT;
    endpoints = ao2_callback(app->forwards, OBJ_MULTIPLE,
        forwards_filter_by_type, &forward_type);
    if (endpoints) {
        while ((forward = ao2_iterator_next(endpoints))) {
            ast_cli(a->fd, "      %s (%d)\n", forward->id, forward->interested);
            ao2_ref(forward, -1);
        }
        ao2_iterator_destroy(endpoints);
    }
}

References a, ao2_callback, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_next, ao2_ref, app, ast_cli(), bridges, channels, endpoints, FORWARD_BRIDGE, FORWARD_CHANNEL, FORWARD_ENDPOINT, forwards_filter_by_type(), app_forwards::id, app_forwards::interested, test_val::name, OBJ_MULTIPLE, and STASIS_APP_SUBSCRIBE_ALL.

Referenced by ari_show_app().

stasis_app_unregister_event_sources()

void stasis_app_unregister_event_sources

(

void

)

Unregister core event sources.

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

{
    stasis_app_unregister_event_source(&endpoint_event_source);
    stasis_app_unregister_event_source(&bridge_event_source);
    stasis_app_unregister_event_source(&channel_event_source);
}

References bridge_event_source, channel_event_source, endpoint_event_source, and stasis_app_unregister_event_source().

Referenced by unload_module().

sub_bridge_update_handler()

static void sub_bridge_update_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct ast_json *json = NULL;
    struct stasis_app *app = data;
    struct ast_bridge_snapshot_update *update;
    const struct timeval *tv;
 
    update = stasis_message_data(message);
 
    tv = stasis_message_timestamp(message);
 
    if (!update->new_snapshot) {
        json = simple_bridge_event("BridgeDestroyed", update->old_snapshot, tv);
    } else if (!update->old_snapshot) {
        json = simple_bridge_event("BridgeCreated", update->new_snapshot, tv);
    } else if (update->new_snapshot && update->old_snapshot
        && strcmp(update->new_snapshot->video_source_id, update->old_snapshot->video_source_id)) {
        json = simple_bridge_event("BridgeVideoSourceChanged", update->new_snapshot, tv);
        if (json && !ast_strlen_zero(update->old_snapshot->video_source_id)) {
            ast_json_object_set(json, "old_video_source_id",
                ast_json_string_create(update->old_snapshot->video_source_id));
        }
    }
 
    if (json) {
        app_send(app, json);
        ast_json_unref(json);
    }
 
    if (!update->new_snapshot && update->old_snapshot) {
        unsubscribe(app, "bridge", update->old_snapshot->uniqueid, 1);
    }
}

References app, app_send(), ast_json_object_set(), ast_json_string_create(), ast_json_unref(), ast_strlen_zero(), stasis_app::data, NULL, simple_bridge_event(), stasis_message_data(), stasis_message_timestamp(), unsubscribe(), and update().

Referenced by app_create().

sub_channel_update_handler()

static void sub_channel_update_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct ast_channel_snapshot_update *update = stasis_message_data(message);
    int i;
 
    for (i = 0; i < ARRAY_LEN(channel_monitors); ++i) {
        struct ast_json *msg;
 
        msg = channel_monitors[i](update->old_snapshot, update->new_snapshot,
            stasis_message_timestamp(message));
        if (msg) {
            app_send(app, msg);
            ast_json_unref(msg);
        }
    }
 
    if (ast_test_flag(&update->new_snapshot->flags, AST_FLAG_DEAD)) {
        unsubscribe(app, "channel", update->new_snapshot->base->uniqueid, 1);
    }
}

References app, app_send(), ARRAY_LEN, AST_FLAG_DEAD, ast_json_unref(), ast_test_flag, channel_monitors, stasis_app::data, stasis_message_data(), stasis_message_timestamp(), unsubscribe(), and update().

Referenced by app_create().

sub_default_handler()

static void sub_default_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct ast_json *json;
 
    /* The dial type can be converted to JSON so it will always be passed
     * here.
     */
    if (stasis_message_type(message) == ast_channel_dial_type()) {
        call_forwarded_handler(app, message);
    }
 
    /* By default, send any message that has a JSON representation */
    json = stasis_message_to_json(message, stasis_app_get_sanitizer());
    if (!json) {
        return;
    }
 
    app_send(app, json);
    ast_json_unref(json);
}

Referenced by app_create().

sub_endpoint_update_handler()

static void sub_endpoint_update_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
    struct stasis_cache_update *update;
    struct ast_endpoint_snapshot *new_snapshot;
    struct ast_endpoint_snapshot *old_snapshot;
    const struct timeval *tv;
 
    ast_assert(stasis_message_type(message) == stasis_cache_update_type());
 
    update = stasis_message_data(message);
 
    ast_assert(update->type == ast_endpoint_snapshot_type());
 
    new_snapshot = stasis_message_data(update->new_snapshot);
    old_snapshot = stasis_message_data(update->old_snapshot);
 
    if (new_snapshot) {
        struct ast_json *json;
 
        tv = stasis_message_timestamp(update->new_snapshot);
 
        json = simple_endpoint_event("EndpointStateChange", new_snapshot, tv);
        if (!json) {
            return;
        }
 
        app_send(app, json);
        ast_json_unref(json);
    }
 
    if (!new_snapshot && old_snapshot) {
        unsubscribe(app, "endpoint", old_snapshot->id, 1);
    }
}

References app, app_send(), ast_assert, ast_endpoint_snapshot_type(), ast_json_unref(), stasis_app::data, ast_endpoint_snapshot::id, simple_endpoint_event(), stasis_cache_update_type(), stasis_message_data(), stasis_message_timestamp(), unsubscribe(), and update().

Referenced by app_create().

sub_subscription_change_handler()

static void sub_subscription_change_handler ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

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

{
    struct stasis_app *app = data;
 
    if (stasis_subscription_final_message(sub, message)) {
        ao2_cleanup(app);
    }
}

References ao2_cleanup, app, stasis_app::data, stasis_subscription_final_message(), and sub.

Referenced by app_create().

subscribe_bridge()

static int subscribe_bridge ( struct stasis_app *  app, void *  obj  )

static

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

{
    return app_subscribe_bridge(app, obj);
}

References app, and app_subscribe_bridge().

subscribe_channel()

static int subscribe_channel ( struct stasis_app *  app, void *  obj  )

static

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

{
    return app_subscribe_channel(app, obj);
}

References app, and app_subscribe_channel().

subscribe_endpoint()

static int subscribe_endpoint ( struct stasis_app *  app, void *  obj  )

static

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

{
    return app_subscribe_endpoint(app, obj);
}

References app, and app_subscribe_endpoint().

unsubscribe()

static int unsubscribe ( struct stasis_app *  app, const char *  kind, const char *  id, int  terminate  )

static

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

{
    struct app_forwards *forwards;
 
    if (!id) {
        if (!strcmp(kind, "bridge")) {
            id = BRIDGE_ALL;
        } else if (!strcmp(kind, "channel")) {
            id = CHANNEL_ALL;
        } else if (!strcmp(kind, "endpoint")) {
            id = ENDPOINT_ALL;
        } else {
            ast_log(LOG_WARNING, "Unknown subscription kind '%s'\n", kind);
            return -1;
        }
    }
 
    ao2_lock(app->forwards);
    forwards = ao2_find(app->forwards, id, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!forwards) {
        ao2_unlock(app->forwards);
        ast_debug(3, "App '%s' not subscribed to %s '%s'\n", app->name, kind, id);
        return -1;
    }
    forwards->interested--;
 
    ast_debug(3, "%s '%s': is %d interested in %s\n", kind, id, forwards->interested, app->name);
    if (forwards->interested == 0 || terminate) {
        /* No one is interested any more; unsubscribe */
        ast_debug(3, "%s '%s' unsubscribed from %s\n", kind, id, app->name);
        forwards_unsubscribe(forwards);
        ao2_find(app->forwards, forwards,
            OBJ_POINTER | OBJ_NOLOCK | OBJ_UNLINK |
            OBJ_NODATA);
 
        if (!strcmp(kind, "endpoint")) {
            messaging_app_unsubscribe_endpoint(app->name, id);
        }
    }
    ao2_unlock(app->forwards);
    ao2_ref(forwards, -1);
 
    return 0;
}

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, app, ast_debug, ast_log, BRIDGE_ALL, CHANNEL_ALL, ENDPOINT_ALL, forwards_unsubscribe(), app_forwards::interested, LOG_WARNING, messaging_app_unsubscribe_endpoint(), OBJ_NODATA, OBJ_NOLOCK, OBJ_POINTER, OBJ_SEARCH_KEY, and OBJ_UNLINK.

Referenced by app_unsubscribe_bridge_id(), app_unsubscribe_channel_id(), app_unsubscribe_endpoint_id(), sub_bridge_update_handler(), sub_channel_update_handler(), and sub_endpoint_update_handler().

Variable Documentation

bridge_event_source

struct stasis_app_event_source bridge_event_source

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

                                                     {
    .scheme = "bridge:",
    .find = bridge_find,
    .subscribe = subscribe_bridge,
    .unsubscribe = app_unsubscribe_bridge_id,
    .is_subscribed = app_is_subscribed_bridge_id
};

Referenced by stasis_app_register_event_sources(), and stasis_app_unregister_event_sources().

channel_event_source

struct stasis_app_event_source channel_event_source

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

                                                      {
    .scheme = "channel:",
    .find = channel_find,
    .subscribe = subscribe_channel,
    .unsubscribe = app_unsubscribe_channel_id,
    .is_subscribed = app_is_subscribed_channel_id
};

Referenced by stasis_app_register_event_sources(), and stasis_app_unregister_event_sources().

channel_monitors

channel_snapshot_monitor channel_monitors[]

static

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

                                                     {
    channel_state,
    channel_dialplan,
    channel_callerid,
    channel_connected_line,
};

Referenced by sub_channel_update_handler().

endpoint_event_source

struct stasis_app_event_source endpoint_event_source

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

                                                       {
    .scheme = "endpoint:",
    .find = endpoint_find,
    .subscribe = subscribe_endpoint,
    .unsubscribe = app_unsubscribe_endpoint_id,
    .is_subscribed = app_is_subscribed_endpoint_id
};

Referenced by stasis_app_register_event_sources(), and stasis_app_unregister_event_sources().

global_debug

int global_debug

Global debug flag. No need for locking

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

Referenced by stasis_app_get_debug(), stasis_app_get_debug_by_name(), and stasis_app_set_global_debug().