res/stasis/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. More...

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. More...
void	app_deactivate (struct stasis_app *app)
	Deactivates an application. More...
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. More...
int	app_is_finished (struct stasis_app *app)
	Checks whether a deactivated app has no channels. More...
int	app_is_subscribed_bridge_id (struct stasis_app *app, const char *bridge_id)
	Test if an app is subscribed to a bridge. More...
int	app_is_subscribed_channel_id (struct stasis_app *app, const char *channel_id)
	Test if an app is subscribed to a channel. More...
int	app_is_subscribed_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Test if an app is subscribed to a endpoint. More...
void	app_send (struct stasis_app *app, struct ast_json *message)
	Send a message to the given application. More...
void	app_shutdown (struct stasis_app *app)
	Tears down an application. More...
int	app_subscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Add a bridge subscription to an existing channel subscription. More...
int	app_subscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Subscribes an application to a channel. More...
int	app_subscribe_endpoint (struct stasis_app *app, struct ast_endpoint *endpoint)
	Subscribes an application to a endpoint. More...
struct ast_json *	app_to_json (const struct stasis_app *app)
	Create a JSON representation of a stasis_app. More...
int	app_unsubscribe_bridge (struct stasis_app *app, struct ast_bridge *bridge)
	Cancel the bridge subscription for an application. More...
int	app_unsubscribe_bridge_id (struct stasis_app *app, const char *bridge_id)
	Cancel the subscription an app has for a bridge. More...
int	app_unsubscribe_channel (struct stasis_app *app, struct ast_channel *chan)
	Cancel the subscription an app has for a channel. More...
int	app_unsubscribe_channel_id (struct stasis_app *app, const char *channel_id)
	Cancel the subscription an app has for a channel. More...
int	app_unsubscribe_endpoint_id (struct stasis_app *app, const char *endpoint_id)
	Cancel the subscription an app has for a endpoint. More...
void	app_update (struct stasis_app *app, stasis_app_cb handler, void *data)
	Update the handler and data for a res_stasis application. More...
struct stasis_topic *	ast_app_get_topic (struct stasis_app *app)
	Returns the stasis topic for an app. More...
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. More...
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. More...
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. More...
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. More...
int	stasis_app_event_filter_set (struct stasis_app *app, struct ast_json *filter)
	Set the application's event type filter. More...
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. More...
int	stasis_app_get_debug (struct stasis_app *app)
	Get debug status of an application. More...
int	stasis_app_get_debug_by_name (const char *app_name)
	Get debug status of an application. More...
const char *	stasis_app_name (const struct stasis_app *app)
	Retrieve an application's name. More...
void	stasis_app_register_event_sources (void)
	Register core event sources. More...
void	stasis_app_set_debug (struct stasis_app *app, int debug)
	Enable/disable request/response and event logging on an application. More...
void	stasis_app_set_debug_by_name (const char *app_name, int debug)
	Enable/disable request/response and event logging on an application. More...
void	stasis_app_set_global_debug (int debug)
	Enable/disable request/response and event logging on all applications. More...
void	stasis_app_to_cli (const struct stasis_app *app, struct ast_cli_args *a)
	Dump properties of a stasis_app to the CLI. More...
void	stasis_app_unregister_event_sources (void)
	Unregister core event sources. More...
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.

Referenced by app_is_subscribed_bridge_id(), app_subscribe_bridge(), app_unsubscribe_bridge(), forwards_create_bridge(), and unsubscribe().

CHANNEL_ALL

#define CHANNEL_ALL   "__AST_CHANNEL_ALL_TOPIC"

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

Referenced by app_is_subscribed_channel_id(), app_subscribe_channel(), app_unsubscribe_channel(), forwards_create_channel(), and unsubscribe().

ENDPOINT_ALL

#define ENDPOINT_ALL   "__AST_ENDPOINT_ALL_TOPIC"

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

Referenced by app_is_subscribed_endpoint_id(), app_subscribe_endpoint(), forwards_create_endpoint(), and unsubscribe().

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

Returns

New res_stasis application.

NULL on error.

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

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, forwards_sort(), stasis_app::handler, LOG_WARNING, 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().

{
   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;
}

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 1066 of file res/stasis/app.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_verb, stasis_app::data, stasis_app::handler, stasis_app::name, and NULL.

Referenced by stasis_app_unregister().

{
   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);
}

app_dtor()

static void app_dtor ( void *  obj )

static

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

References ao2_cleanup, app, ast_assert, ast_context_destroy_by_name(), ast_json_unref(), ast_verb, stasis_app::bridge_router, context_name, stasis_app::data, stasis_app::endpoint_router, stasis_app::events_allowed, stasis_app::events_disallowed, stasis_app::forwards, stasis_app::name, NULL, stasis_app::router, and stasis_app::topic.

Referenced by app_create().

{
   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;

}

app_event_filter_matched()

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

static

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

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

Referenced by stasis_app_event_allowed().

{
   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;
}

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 1655 of file res/stasis/app.c.

References ao2_lock, ao2_unlock, 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, LOG_ERROR, stasis_app::name, and NULL.

Referenced by app_events_allowed_set(), and app_events_disallowed_set().

{
   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;
}

app_events_allowed_set()

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

static

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

References app_event_filter_set(), and stasis_app::events_allowed.

Referenced by stasis_app_event_filter_set().

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

app_events_disallowed_set()

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

static

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

References app_event_filter_set(), and stasis_app::events_disallowed.

Referenced by stasis_app_event_filter_set().

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

app_is_active()

int app_is_active

(

struct stasis_app *

app

)

Checks whether an app is active.

Parameters

app	Application to check.

Returns

True (non-zero) if app is active.

False (zero) if app has been deactivated.

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

References ao2_lock, ao2_unlock, stasis_app::handler, and NULL.

Referenced by stasis_app_exec().

{
   int ret;

   ao2_lock(app);
   ret = app->handler != NULL;
   ao2_unlock(app);

   return ret;
}

app_is_finished()

int app_is_finished

(

struct stasis_app *

app

)

Checks whether a deactivated app has no channels.

Parameters

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

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

References ao2_container_count(), ao2_lock, ao2_unlock, stasis_app::forwards, stasis_app::handler, and NULL.

Referenced by app_shutdown(), and cleanup_cb().

{
   int ret;

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

   return ret;
}

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.

Returns

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

False (zero) if bridge is not subscribed.

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

References ao2_cleanup, ao2_find, ast_strlen_zero, BRIDGE_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   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;
}

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.

Returns

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

False (zero) if channel is not subscribed.

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

References ao2_cleanup, ao2_find, ast_strlen_zero, CHANNEL_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   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;
}

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.

Returns

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

False (zero) if endpoint is not subscribed.

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

References ao2_cleanup, ao2_find, ast_strlen_zero, ENDPOINT_ALL, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

{
   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;
}

app_send()

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

Send a message to the given application.

Send a message to an application.

Parameters

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

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

References ao2_bump, ao2_cleanup, ao2_lock, ao2_unlock, 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, stasis_app::data, stasis_app::handler, and stasis_app::name.

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

{
   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);
}

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 1078 of file res/stasis/app.c.

References ao2_lock, ao2_unlock, app_is_finished(), ast_assert, stasis_app::bridge_router, stasis_app::endpoint_router, NULL, stasis_app::router, and stasis_message_router_unsubscribe().

Referenced by cleanup_cb().

{
   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);
}

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.

Returns

0 on success.

Non-zero on error.

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

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

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

{
   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;
}

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.

Returns

0 on success.

Non-zero on error.

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

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

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

{
   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;
}

app_subscribe_endpoint()

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

Subscribes an application to a endpoint.

Parameters

app	Application.
chan	Endpoint to subscribe to.

Returns

0 on success.

Non-zero on error.

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

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

Referenced by subscribe_endpoint().

{
   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;
}

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

NULL on error

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

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, 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, stasis_app::forwards, app_forwards::id, LOG_ERROR, stasis_app::name, and NULL.

Referenced by stasis_app_object_to_json().

{
   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;
}

app_unsubscribe_bridge()

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

Cancel the bridge subscription for an application.

Parameters

forwards	Return from app_subscribe_channel().
bridge	Bridge to subscribe to.

Returns

0 on success.

Non-zero on error.

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

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

Referenced by internal_bridge_after_cb(), and stasis_app_exec().

{
   if (!app) {
      return -1;
   }

   return app_unsubscribe_bridge_id(app, bridge ? bridge->uniqueid : BRIDGE_ALL);
}

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.

Returns

0 on success.

Non-zero on error.

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

References unsubscribe().

Referenced by app_unsubscribe_bridge().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "bridge", bridge_id, 0);
}

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.

Returns

0 on success.

Non-zero on error.

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

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

Referenced by app_send_end_msg().

{
   if (!app) {
      return -1;
   }

   return app_unsubscribe_channel_id(app, chan ? ast_channel_uniqueid(chan) : CHANNEL_ALL);
}

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.

Returns

0 on success.

Non-zero on error.

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

References unsubscribe().

Referenced by app_unsubscribe_channel(), and send_start_msg_snapshots().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "channel", channel_id, 0);
}

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.

Returns

0 on success.

Non-zero on error.

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

References unsubscribe().

{
   if (!app) {
      return -1;
   }

   return unsubscribe(app, "endpoint", endpoint_id, 0);
}

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 1116 of file res/stasis/app.c.

References ao2_lock, ao2_replace, ao2_unlock, app_send(), ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_tvnow(), ast_verb, stasis_app::data, stasis_app::handler, stasis_app::name, and NULL.

Referenced by __stasis_app_register().

{
   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);
}

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 1028 of file res/stasis/app.c.

References stasis_app::topic.

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

{
   return app->topic;
}

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 720 of file res/stasis/app.c.

References ao2_find, ao2_ref, stasis_app::forwards, NULL, and OBJ_SEARCH_KEY.

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

{
   struct app_forwards *forwards = NULL;

   forwards = ao2_find(app->forwards, uniqueid, OBJ_SEARCH_KEY);
   if (!forwards) {
      return 0;
   }

   ao2_ref(forwards, -1);
   return 1;
}

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 750 of file res/stasis/app.c.

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

Referenced by bridge_attended_transfer_handler(), and bridge_blind_transfer_handler().

{
   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;
}

bridge_attended_transfer_handler()

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

static

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

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, stasis_app::topic, and ast_channel_snapshot_base::uniqueid.

Referenced by app_create().

{
   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);
   }
}

bridge_blind_transfer_handler()

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

static

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

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(), stasis_app::topic, ast_blind_transfer_message::transferer, and ast_channel_snapshot_base::uniqueid.

Referenced by app_create().

{
   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);
   }
}

bridge_find()

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

static

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

References stasis_app_bridge_find_by_id().

{
   return stasis_app_bridge_find_by_id(id);
}

bridge_merge_handler()

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

static

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

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

Referenced by app_create().

{
   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);
   }
}

bridge_subscription_change_handler()

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

static

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

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

Referenced by app_create().

{
   struct stasis_app *app = data;

   if (stasis_subscription_final_message(sub, message)) {
      ao2_cleanup(app);
   }
}

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.

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

Referenced by sub_default_handler().

{
   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);
}

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 479 of file res/stasis/app.c.

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

{
   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);
}

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 509 of file res/stasis/app.c.

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

{
   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);
}

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.

References simple_channel_event().

Referenced by channel_state().

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

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.

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

Referenced by channel_state().

{
   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: i, s: s, s: o}",
      "type", "ChannelDestroyed",
      "timestamp", ast_json_timeval(*tv, NULL),
      "cause", snapshot->hangup->cause,
      "cause_txt", ast_cause2str(snapshot->hangup->cause),
      "channel", json_channel);
}

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 445 of file res/stasis/app.c.

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

{
   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);
}

channel_find()

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

static

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

References ast_channel_get_by_name().

{
   return ast_channel_get_by_name(id);
}

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.

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

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.

{
   struct ast_channel_snapshot *snapshot = new_snapshot ?
      new_snapshot : old_snapshot;

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

   return NULL;
}

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 418 of file res/stasis/app.c.

References simple_channel_event().

Referenced by channel_state().

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

endpoint_find()

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

static

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

References ast_endpoint_find_by_id().

{
   return ast_endpoint_find_by_id(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.

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

Referenced by forwards_create_endpoint().

{
   struct stasis_app *app = data;

   stasis_publish(app->topic, message);
}

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.

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

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

{
   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;
}

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.

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

Referenced by app_subscribe_bridge().

{
   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;
}

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.

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

Referenced by app_subscribe_channel().

{
   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;
}

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.

References ao2_ref, 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, stasis_app::endpoint_router, endpoint_state_cb(), FORWARD_ENDPOINT, app_forwards::forward_type, stasis_app::forwards, forwards_create(), forwards_unsubscribe(), NULL, stasis_forward_all(), stasis_message_router_add(), stasis_message_router_create, stasis_app::topic, app_forwards::topic_cached_forward, and app_forwards::topic_forward.

Referenced by app_subscribe_endpoint().

{
   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;
}

forwards_dtor()

static void forwards_dtor ( void *  obj )

static

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

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

Referenced by forwards_create().

{
#ifdef AST_DEVMODE
   struct app_forwards *forwards = obj;
#endif /* AST_DEVMODE */

   ast_assert(forwards->topic_forward == NULL);
   ast_assert(forwards->topic_cached_forward == NULL);
}

forwards_filter_by_type()

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

static

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

References CMP_MATCH, and app_forwards::forward_type.

Referenced by stasis_app_to_cli().

{
   struct app_forwards *forward = obj;
   enum forward_type *forward_type = arg;

   if (forward->forward_type == *forward_type) {
      return CMP_MATCH;
   }

   return 0;
}

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.

References ast_assert, app_forwards::id, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by app_create().

{
   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;
}

forwards_unsubscribe()

static void forwards_unsubscribe ( struct app_forwards *  forwards )

static

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

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

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

message_received_handler()

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

static

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

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

{
   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;
}

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 666 of file res/stasis/app.c.

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

Referenced by sub_bridge_update_handler().

{
   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);
}

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.

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

Referenced by channel_created_event(), and channel_state_change_event().

{
   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);
}

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 567 of file res/stasis/app.c.

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

Referenced by sub_endpoint_update_handler().

{
   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);
}

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 1739 of file res/stasis/app.c.

References ao2_lock, ao2_ref, ao2_unlock, app, app_event_filter_matched(), stasis_app::events_allowed, stasis_app::events_disallowed, and stasis_app_get_by_name().

Referenced by stasis_app_message_handler().

{
   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;
}

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 1713 of file res/stasis/app.c.

References app_events_allowed_set(), and app_events_disallowed_set().

Referenced by ast_ari_applications_filter().

{
   return app_events_disallowed_set(app, filter) || app_events_allowed_set(app, 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 1641 of file res/stasis/app.c.

References ast_json_array_create(), ast_json_object_set(), ast_json_ref(), stasis_app::events_allowed, and stasis_app::events_disallowed.

Referenced by stasis_app_object_to_json().

{
   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;
}

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 863 of file res/stasis/app.c.

References stasis_app::debug, and global_debug.

{
   return (app ? app->debug : 0) || 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 868 of file res/stasis/app.c.

References ao2_ref, app, stasis_app::debug, global_debug, and stasis_app_get_by_name().

Referenced by ast_ari_callback(), and stasis_app_message_handler().

{
   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;
}

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 1156 of file res/stasis/app.c.

References stasis_app::name.

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

{
   return app->name;
}

stasis_app_register_event_sources()

void stasis_app_register_event_sources

(

void

)

Register core event sources.

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

References stasis_app_register_event_source().

Referenced by load_module().

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

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 842 of file res/stasis/app.c.

References stasis_app::debug.

Referenced by ari_set_debug(), and stasis_app_set_global_debug().

{
   if (!app) {
      return;
   }

   app->debug = 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 851 of file res/stasis/app.c.

References ao2_cleanup, app, stasis_app::debug, and stasis_app_get_by_name().

{
   struct stasis_app *app = stasis_app_get_by_name(app_name);

   if (!app) {
      return;
   }

   app->debug = debug;
   ao2_cleanup(app);
}

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 887 of file res/stasis/app.c.

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

Referenced by ari_set_debug().

{
   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);
   }
}

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 1173 of file res/stasis/app.c.

References ao2_callback, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_next, ao2_ref, ast_cli(), bridges, channels, stasis_app::debug, endpoints, ast_cli_args::fd, FORWARD_BRIDGE, FORWARD_CHANNEL, FORWARD_ENDPOINT, stasis_app::forwards, forwards_filter_by_type(), app_forwards::id, app_forwards::interested, stasis_app::name, OBJ_MULTIPLE, STASIS_APP_SUBSCRIBE_ALL, and stasis_app::subscription_model.

Referenced by ari_show_app().

{
   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);
   }
}

stasis_app_unregister_event_sources()

void stasis_app_unregister_event_sources

(

void

)

Unregister core event sources.

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

References stasis_app_unregister_event_source().

Referenced by unload_module().

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

sub_bridge_update_handler()

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

static

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

References app, app_send(), ast_json_object_set(), ast_json_string_create(), ast_json_unref(), ast_strlen_zero, stasis_app::data, ast_bridge_snapshot_update::new_snapshot, NULL, ast_bridge_snapshot_update::old_snapshot, simple_bridge_event(), stasis_message_data(), stasis_message_timestamp(), ast_bridge_snapshot::uniqueid, unsubscribe(), update(), and ast_bridge_snapshot::video_source_id.

Referenced by app_create().

{
   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);
   }
}

sub_channel_update_handler()

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

static

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

References app, app_send(), ARRAY_LEN, AST_FLAG_DEAD, ast_json_unref(), ast_test_flag, ast_channel_snapshot::base, channel_monitors, stasis_app::data, ast_channel_snapshot::flags, ast_channel_snapshot_update::new_snapshot, ast_channel_snapshot_update::old_snapshot, stasis_message_data(), stasis_message_timestamp(), ast_channel_snapshot_base::uniqueid, unsubscribe(), and update().

Referenced by app_create().

{
   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);
   }
}

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.

References app, app_send(), ast_channel_dial_type(), ast_json_unref(), call_forwarded_handler(), stasis_app::data, stasis_app_get_sanitizer(), stasis_message_to_json(), and stasis_message_type().

Referenced by app_create().

{
   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);
}

sub_endpoint_update_handler()

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

static

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

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

Referenced by app_create().

{
   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);
   }
}

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.

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

Referenced by app_create().

{
   struct stasis_app *app = data;

   if (stasis_subscription_final_message(sub, message)) {
      ao2_cleanup(app);
   }
}

subscribe_bridge()

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

static

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

References app_subscribe_bridge().

{
   return app_subscribe_bridge(app, obj);
}

subscribe_channel()

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

static

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

References app_subscribe_channel().

{
   return app_subscribe_channel(app, obj);
}

subscribe_endpoint()

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

static

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

References app_subscribe_endpoint().

{
   return app_subscribe_endpoint(app, obj);
}

unsubscribe()

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

static

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

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_debug, ast_log, BRIDGE_ALL, CHANNEL_ALL, ENDPOINT_ALL, stasis_app::forwards, forwards_unsubscribe(), app_forwards::interested, LOG_WARNING, messaging_app_unsubscribe_endpoint(), stasis_app::name, 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().

{
   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;
}

Variable Documentation

bridge_event_source

struct stasis_app_event_source bridge_event_source

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

channel_event_source

struct stasis_app_event_source channel_event_source

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

channel_monitors

channel_snapshot_monitor channel_monitors[]

static

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

Referenced by sub_channel_update_handler().

endpoint_event_source

struct stasis_app_event_source endpoint_event_source

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

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