res_stasis_device_state.c File Reference

#include "asterisk.h"
#include "asterisk/astdb.h"
#include "asterisk/astobj2.h"
#include "asterisk/module.h"
#include "asterisk/stasis_app_impl.h"
#include "asterisk/stasis_app_device_state.h"

Include dependency graph for res_stasis_device_state.c:

Go to the source code of this file.

Data Structures
struct	device_state_subscription
	Device state subscription object. More...

Macros
#define	DEVICE_STATE_ALL   "__AST_DEVICE_STATE_ALL_TOPIC"
#define	DEVICE_STATE_BUCKETS   37
#define	DEVICE_STATE_FAMILY   "StasisDeviceState"
#define	DEVICE_STATE_PROVIDER_STASIS   "Stasis"
#define	DEVICE_STATE_SCHEME_STASIS   "Stasis:"
#define	DEVICE_STATE_SCHEME_SUB   "deviceState:"
#define	DEVICE_STATE_SIZE   64

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static void	device_state_cb (void *data, struct stasis_subscription *sub, struct stasis_message *msg)
static struct device_state_subscription *	device_state_subscription_create (const struct stasis_app *app, const char *device_name)
static void	device_state_subscription_destroy (void *obj)
static int	device_state_subscriptions_cmp (void *obj, void *arg, int flags)
static int	device_state_subscriptions_hash (const void *obj, const int flags)
static int	device_to_json_cb (void *obj, void *arg, void *data, int flags)
static void	devices_to_json (const struct stasis_app *app, struct ast_json *json)
static void *	find_device_state (const struct stasis_app *app, const char *name)
static struct device_state_subscription *	find_device_state_subscription (struct stasis_app *app, const char *name)
static int	is_subscribed_device_state (struct stasis_app *app, const char *name)
static int	is_subscribed_device_state_lock (struct stasis_app *app, const char *name)
static int	load_module (void)
static void	populate_cache (void)
static void	remove_device_state_subscription (struct device_state_subscription *sub)
static void	send_device_state (struct device_state_subscription *sub, const char *name, enum ast_device_state state)
enum stasis_device_state_result	stasis_app_device_state_delete (const char *name)
	Delete a device controlled by ARI.
struct ast_json *	stasis_app_device_state_to_json (const char *name, enum ast_device_state state)
	Convert device state to json.
enum stasis_device_state_result	stasis_app_device_state_update (const char *name, const char *value)
	Changes the state of a device controlled by ARI.
struct ast_json *	stasis_app_device_states_to_json (void)
	Convert device states to json array.
static enum ast_device_state	stasis_device_state_cb (const char *data)
static int	subscribe_device_state (struct stasis_app *app, void *obj)
static int	unload_module (void)
static int	unsubscribe_device_state (struct stasis_app *app, const char *name)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS , .description = "Stasis application device state support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", }
static const struct ast_module_info *	ast_module_info = &__mod_info
struct stasis_app_event_source	device_state_event_source
static struct ao2_container *	device_state_subscriptions

Macro Definition Documentation

DEVICE_STATE_ALL

#define DEVICE_STATE_ALL   "__AST_DEVICE_STATE_ALL_TOPIC"

The key used for tracking a subscription to all device states

Definition at line 46 of file res_stasis_device_state.c.

DEVICE_STATE_BUCKETS

#define DEVICE_STATE_BUCKETS   37

Number of hash buckets for device state subscriptions

Definition at line 43 of file res_stasis_device_state.c.

DEVICE_STATE_FAMILY

#define DEVICE_STATE_FAMILY   "StasisDeviceState"

astdb family name

Definition at line 34 of file res_stasis_device_state.c.

DEVICE_STATE_PROVIDER_STASIS

#define DEVICE_STATE_PROVIDER_STASIS   "Stasis"

Stasis device state provider

Definition at line 36 of file res_stasis_device_state.c.

DEVICE_STATE_SCHEME_STASIS

#define DEVICE_STATE_SCHEME_STASIS   "Stasis:"

Scheme for custom device states

Definition at line 38 of file res_stasis_device_state.c.

DEVICE_STATE_SCHEME_SUB

#define DEVICE_STATE_SCHEME_SUB   "deviceState:"

Scheme for device state subscriptions

Definition at line 40 of file res_stasis_device_state.c.

DEVICE_STATE_SIZE

#define DEVICE_STATE_SIZE   64

Definition at line 32 of file res_stasis_device_state.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 490 of file res_stasis_device_state.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 490 of file res_stasis_device_state.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 490 of file res_stasis_device_state.c.

device_state_cb()

static void device_state_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 301 of file res_stasis_device_state.c.

{
    struct ast_device_state_message *device_state;
 
    if (stasis_subscription_final_message(sub, msg)) {
        /* Remove stasis subscription's reference to device_state_subscription */
        ao2_ref(data, -1);
        return;
    }
 
    if (ast_device_state_message_type() != stasis_message_type(msg)) {
        return;
    }
 
    device_state = stasis_message_data(msg);
    if (device_state->eid) {
        /* ignore non-aggregate states */
        return;
    }
 
    send_device_state(data, device_state->device, device_state->state);
}

References ao2_ref, ast_device_state_message_type(), ast_device_state_message::device, ast_device_state_message::eid, send_device_state(), stasis_message_data(), stasis_subscription_final_message(), ast_device_state_message::state, and sub.

Referenced by subscribe_device_state().

device_state_subscription_create()

static struct device_state_subscription * device_state_subscription_create ( const struct stasis_app *  app, const char *  device_name  )

static

Definition at line 112 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub;
    const char *app_name = stasis_app_name(app);
    size_t size;
 
    if (ast_strlen_zero(device_name)) {
        device_name = DEVICE_STATE_ALL;
    }
 
    size = strlen(device_name) + strlen(app_name) + 2;
 
    sub = ao2_alloc(sizeof(*sub), device_state_subscription_destroy);
    if (!sub) {
        return NULL;
    }
 
    if (ast_string_field_init(sub, size)) {
        ao2_ref(sub, -1);
        return NULL;
    }
 
    ast_string_field_set(sub, app_name, app_name);
    ast_string_field_set(sub, device_name, device_name);
    return sub;
}

References ao2_alloc, ao2_ref, app, app_name(), ast_string_field_init, ast_string_field_set, ast_strlen_zero(), device_state_subscription::device_name, DEVICE_STATE_ALL, device_state_subscription_destroy(), NULL, stasis_app_name(), and sub.

Referenced by find_device_state(), and subscribe_device_state().

device_state_subscription_destroy()

static void device_state_subscription_destroy ( void *  obj )

static

Definition at line 106 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub = obj;
    ast_string_field_free_memory(sub);
}

References ast_string_field_free_memory, and sub.

Referenced by device_state_subscription_create().

device_state_subscriptions_cmp()

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

static

Definition at line 79 of file res_stasis_device_state.c.

{
    const struct device_state_subscription *object_left = obj;
    const struct device_state_subscription *object_right = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        /* find objects matching both device and app names */
        if (strcmp(object_left->device_name,
               object_right->device_name)) {
            return 0;
        }
        cmp = strcmp(object_left->app_name, object_right->app_name);
        break;
    case OBJ_SEARCH_KEY:
    case OBJ_SEARCH_PARTIAL_KEY:
        ast_assert(0); /* not supported by container */
        /* fall through */
    default:
        cmp = 0;
        break;
    }
 
    return cmp ? 0 : CMP_MATCH | CMP_STOP;
}

References device_state_subscription::app_name, ast_assert, CMP_MATCH, CMP_STOP, device_state_subscription::device_name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and OBJ_SEARCH_PARTIAL_KEY.

Referenced by load_module().

device_state_subscriptions_hash()

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

static

Definition at line 63 of file res_stasis_device_state.c.

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

References ast_assert, ast_str_hash(), device_state_subscription::device_name, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, and OBJ_SEARCH_OBJECT.

Referenced by load_module().

device_to_json_cb()

static int device_to_json_cb ( void *  obj, void *  arg, void *  data, int  flags  )

static

Definition at line 423 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub = obj;
    const char *app_name = arg;
    struct ast_json *array = data;
 
    if (strcmp(sub->app_name, app_name)) {
        return 0;
    }
 
    ast_json_array_append(
        array, ast_json_string_create(sub->device_name));
    return 0;
 
}

References app_name(), array(), ast_json_array_append(), ast_json_string_create(), and sub.

Referenced by devices_to_json().

devices_to_json()

static void devices_to_json ( const struct stasis_app *  app, struct ast_json *  json  )

static

Definition at line 439 of file res_stasis_device_state.c.

{
    struct ast_json *array = ast_json_array_create();
    ao2_callback_data(device_state_subscriptions, OBJ_NODATA,
              device_to_json_cb, (void *)stasis_app_name(app), array);
    ast_json_object_set(json, "device_names", array);
}

References ao2_callback_data, app, array(), ast_json_array_create(), ast_json_object_set(), device_state_subscriptions, device_to_json_cb(), OBJ_NODATA, and stasis_app_name().

find_device_state()

static void * find_device_state ( const struct stasis_app *  app, const char *  name  )

static

Definition at line 325 of file res_stasis_device_state.c.

{
    return device_state_subscription_create(app, name);
}

References app, device_state_subscription_create(), and name.

find_device_state_subscription()

static struct device_state_subscription * find_device_state_subscription ( struct stasis_app *  app, const char *  name  )

static

Definition at line 140 of file res_stasis_device_state.c.

{
    struct device_state_subscription dummy_sub = {
        .app_name = stasis_app_name(app),
        .device_name = name
    };
 
    return ao2_find(device_state_subscriptions, &dummy_sub, OBJ_SEARCH_OBJECT | OBJ_NOLOCK);
}

References ao2_find, app, device_state_subscription::app_name, device_state_subscriptions, name, OBJ_NOLOCK, OBJ_SEARCH_OBJECT, and stasis_app_name().

Referenced by is_subscribed_device_state(), and unsubscribe_device_state().

is_subscribed_device_state()

static int is_subscribed_device_state ( struct stasis_app *  app, const char *  name  )

static

Definition at line 330 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub;
 
    sub = find_device_state_subscription(app, DEVICE_STATE_ALL);
    if (sub) {
        ao2_ref(sub, -1);
        return 1;
    }
 
    sub = find_device_state_subscription(app, name);
    if (sub) {
        ao2_ref(sub, -1);
        return 1;
    }
 
    return 0;
}

References ao2_ref, app, DEVICE_STATE_ALL, find_device_state_subscription(), name, and sub.

Referenced by is_subscribed_device_state_lock(), and subscribe_device_state().

is_subscribed_device_state_lock()

static int is_subscribed_device_state_lock ( struct stasis_app *  app, const char *  name  )

static

Definition at line 349 of file res_stasis_device_state.c.

{
    int is_subscribed;
 
    ao2_lock(device_state_subscriptions);
    is_subscribed = is_subscribed_device_state(app, S_OR(name, DEVICE_STATE_ALL));
    ao2_unlock(device_state_subscriptions);
 
    return is_subscribed;
}

References ao2_lock, ao2_unlock, app, DEVICE_STATE_ALL, device_state_subscriptions, is_subscribed_device_state(), name, and S_OR.

load_module()

static int load_module ( void  )

static

Definition at line 456 of file res_stasis_device_state.c.

{
    populate_cache();
    if (ast_devstate_prov_add(DEVICE_STATE_PROVIDER_STASIS,
                  stasis_device_state_cb)) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    device_state_subscriptions = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        DEVICE_STATE_BUCKETS, device_state_subscriptions_hash, NULL,
        device_state_subscriptions_cmp);
    if (!device_state_subscriptions) {
        ast_devstate_prov_del(DEVICE_STATE_PROVIDER_STASIS);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    stasis_app_register_event_source(&device_state_event_source);
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ast_devstate_prov_add(), ast_devstate_prov_del(), AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, DEVICE_STATE_BUCKETS, device_state_event_source, DEVICE_STATE_PROVIDER_STASIS, device_state_subscriptions, device_state_subscriptions_cmp(), device_state_subscriptions_hash(), NULL, populate_cache(), stasis_app_register_event_source(), and stasis_device_state_cb().

populate_cache()

static void populate_cache ( void  )

static

Definition at line 275 of file res_stasis_device_state.c.

{
    RAII_VAR(struct ast_db_entry *, tree,
         ast_db_gettree(DEVICE_STATE_FAMILY, NULL), ast_db_freetree);
    struct ast_db_entry *entry;
 
    for (entry = tree; entry; entry = entry->next) {
        const char *name = strrchr(entry->key, '/');
        if (!ast_strlen_zero(name)) {
            ast_devstate_changed(
                ast_devstate_val(entry->data),
                AST_DEVSTATE_CACHABLE, "%s%s",
                DEVICE_STATE_SCHEME_STASIS, name + 1);
        }
    }
}

References ast_db_freetree(), ast_db_gettree(), AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_devstate_val(), ast_strlen_zero(), ast_db_entry::data, DEVICE_STATE_FAMILY, DEVICE_STATE_SCHEME_STASIS, ast_db_entry::key, name, ast_db_entry::next, NULL, and RAII_VAR.

Referenced by load_module().

remove_device_state_subscription()

static void remove_device_state_subscription ( struct device_state_subscription *  sub )

static

Definition at line 151 of file res_stasis_device_state.c.

{
    if (sub->sub) {
        sub->sub = stasis_unsubscribe_and_join(sub->sub);
    }
    ao2_unlink_flags(device_state_subscriptions, sub, OBJ_NOLOCK);
}

References ao2_unlink_flags, device_state_subscriptions, OBJ_NOLOCK, stasis_unsubscribe_and_join(), and sub.

Referenced by unsubscribe_device_state().

send_device_state()

static void send_device_state ( struct device_state_subscription *  sub, const char *  name, enum ast_device_state  state  )

static

Definition at line 191 of file res_stasis_device_state.c.

{
    RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
 
    json = ast_json_pack("{s:s, s:s, s:o, s:o}",
                 "type", "DeviceStateChanged",
                 "application", sub->app_name,
                 "timestamp", ast_json_timeval(ast_tvnow(), NULL),
                 "device_state", stasis_app_device_state_to_json(
                     name, state));
 
    if (!json) {
        ast_log(LOG_ERROR, "Unable to create device state json object\n");
        return;
    }
 
    stasis_app_send(sub->app_name, json);
}

References ast_json_pack(), ast_json_timeval(), ast_json_unref(), ast_log, ast_tvnow(), LOG_ERROR, name, NULL, RAII_VAR, stasis_app_device_state_to_json(), stasis_app_send(), and sub.

Referenced by device_state_cb().

stasis_app_device_state_delete()

enum stasis_device_state_result stasis_app_device_state_delete

(

const char *

name

)

Delete a device controlled by ARI.

Parameters

name	the name of the ARI controlled device

Returns

stasis device state application result.

Definition at line 244 of file res_stasis_device_state.c.

{
    const char *full_name = name;
    size_t size = strlen(DEVICE_STATE_SCHEME_STASIS);
 
    if (strncasecmp(name, DEVICE_STATE_SCHEME_STASIS, size)) {
        ast_log(LOG_ERROR, "Can only delete '%s' device states!\n",
            DEVICE_STATE_SCHEME_STASIS);
        return STASIS_DEVICE_STATE_NOT_CONTROLLED;
    }
 
    name += size;
    if (ast_strlen_zero(name)) {
        ast_log(LOG_ERROR, "Delete requires a device name!\n");
        return STASIS_DEVICE_STATE_MISSING;
    }
 
    if (ast_device_state_clear_cache(full_name)) {
        return STASIS_DEVICE_STATE_UNKNOWN;
    }
 
    ast_db_del(DEVICE_STATE_FAMILY, name);
 
    /* send state change for delete */
    ast_devstate_changed(
        AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, "%s%s",
        DEVICE_STATE_SCHEME_STASIS, name);
 
    return STASIS_DEVICE_STATE_OK;
}

References ast_db_del(), ast_device_state_clear_cache(), AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_log, ast_strlen_zero(), DEVICE_STATE_FAMILY, DEVICE_STATE_SCHEME_STASIS, LOG_ERROR, name, STASIS_DEVICE_STATE_MISSING, STASIS_DEVICE_STATE_NOT_CONTROLLED, STASIS_DEVICE_STATE_OK, and STASIS_DEVICE_STATE_UNKNOWN.

Referenced by ast_ari_device_states_delete().

stasis_app_device_state_to_json()

struct ast_json * stasis_app_device_state_to_json	(	const char *	name,
		enum ast_device_state	state
	)

Convert device state to json.

Parameters

name	the name of the device
state	the device state

Returns

JSON representation.

Return values

NULL

on error.

Definition at line 160 of file res_stasis_device_state.c.

{
    return ast_json_pack("{s: s, s: s}",
                 "name", name,
                 "state", ast_devstate_str(state));
}

References ast_devstate_str(), ast_json_pack(), and name.

Referenced by ast_ari_device_states_get(), send_device_state(), and stasis_app_device_states_to_json().

stasis_app_device_state_update()

enum stasis_device_state_result stasis_app_device_state_update	(	const char *	name,
		const char *	value
	)

Changes the state of a device controlled by ARI.

Note

The controlled device must be prefixed with 'Stasis:'.

Implicitly creates the device state.

Parameters

name	the name of the ARI controlled device
value	a valid device state value

Returns

a stasis device state application result.

Definition at line 211 of file res_stasis_device_state.c.

{
    size_t size = strlen(DEVICE_STATE_SCHEME_STASIS);
    enum ast_device_state state;
 
    ast_debug(3, "Updating device name = %s, value = %s", name, value);
 
    if (strncasecmp(name, DEVICE_STATE_SCHEME_STASIS, size)) {
        ast_log(LOG_ERROR, "Update can only be used to set "
            "'%s' device state!\n", DEVICE_STATE_SCHEME_STASIS);
        return STASIS_DEVICE_STATE_NOT_CONTROLLED;
    }
 
    name += size;
    if (ast_strlen_zero(name)) {
        ast_log(LOG_ERROR, "Update requires custom device name!\n");
        return STASIS_DEVICE_STATE_MISSING;
    }
 
    if (!value || (state = ast_devstate_val(value)) == AST_DEVICE_UNKNOWN) {
        ast_log(LOG_ERROR, "Unknown device state "
            "value '%s'\n", value);
        return STASIS_DEVICE_STATE_UNKNOWN;
    }
 
    ast_db_put(DEVICE_STATE_FAMILY, name, value);
    ast_devstate_changed(state, AST_DEVSTATE_CACHABLE, "%s%s",
                 DEVICE_STATE_SCHEME_STASIS, name);
 
    return STASIS_DEVICE_STATE_OK;
}

References ast_db_put(), ast_debug, AST_DEVICE_UNKNOWN, AST_DEVSTATE_CACHABLE, ast_devstate_changed(), ast_devstate_val(), ast_log, ast_strlen_zero(), DEVICE_STATE_FAMILY, DEVICE_STATE_SCHEME_STASIS, LOG_ERROR, name, STASIS_DEVICE_STATE_MISSING, STASIS_DEVICE_STATE_NOT_CONTROLLED, STASIS_DEVICE_STATE_OK, STASIS_DEVICE_STATE_UNKNOWN, and value.

Referenced by ast_ari_device_states_update().

stasis_app_device_states_to_json()

struct ast_json * stasis_app_device_states_to_json

(

void

)

Convert device states to json array.

Returns

JSON representation.

Return values

NULL

on error.

Definition at line 168 of file res_stasis_device_state.c.

{
    struct ast_json *array = ast_json_array_create();
    struct ast_db_entry *tree;
    struct ast_db_entry *entry;
 
    tree = ast_db_gettree(DEVICE_STATE_FAMILY, NULL);
    for (entry = tree; entry; entry = entry->next) {
        const char *name = strrchr(entry->key, '/');
 
        if (!ast_strlen_zero(name)) {
            char device[DEVICE_STATE_SIZE];
 
            snprintf(device, sizeof(device), "%s%s", DEVICE_STATE_SCHEME_STASIS, ++name);
            ast_json_array_append(array,
                stasis_app_device_state_to_json(device, ast_device_state(device)));
        }
    }
    ast_db_freetree(tree);
 
    return array;
}

References array(), ast_db_freetree(), ast_db_gettree(), ast_json_array_append(), ast_json_array_create(), ast_strlen_zero(), DEVICE_STATE_FAMILY, DEVICE_STATE_SCHEME_STASIS, DEVICE_STATE_SIZE, ast_db_entry::key, name, ast_db_entry::next, NULL, and stasis_app_device_state_to_json().

Referenced by ast_ari_device_states_list().

stasis_device_state_cb()

static enum ast_device_state stasis_device_state_cb ( const char *  data )

static

Definition at line 292 of file res_stasis_device_state.c.

{
    char buf[DEVICE_STATE_SIZE];
 
    ast_db_get(DEVICE_STATE_FAMILY, data, buf, sizeof(buf));
 
    return ast_devstate_val(buf);
}

References ast_db_get(), ast_devstate_val(), buf, ast_db_entry::data, DEVICE_STATE_FAMILY, and DEVICE_STATE_SIZE.

Referenced by load_module().

subscribe_device_state()

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

static

Definition at line 360 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub = obj;
    struct stasis_topic *topic;
 
    if (!sub) {
        sub = device_state_subscription_create(app, NULL);
        if (!sub) {
            return -1;
        }
    }
 
    if (strcmp(sub->device_name, DEVICE_STATE_ALL)) {
        topic = ast_device_state_topic(sub->device_name);
    } else {
        topic = ast_device_state_topic_all();
    }
 
    ao2_lock(device_state_subscriptions);
 
    if (is_subscribed_device_state(app, sub->device_name)) {
        ao2_unlock(device_state_subscriptions);
        ast_debug(3, "App %s is already subscribed to %s\n", stasis_app_name(app), sub->device_name);
        return 0;
    }
 
    ast_debug(3, "Subscribing to device %s\n", sub->device_name);
 
    sub->sub = stasis_subscribe_pool(topic, device_state_cb, ao2_bump(sub));
    if (!sub->sub) {
        ao2_unlock(device_state_subscriptions);
        ast_log(LOG_ERROR, "Unable to subscribe to device %s\n",
            sub->device_name);
        /* Reference we added when attempting to stasis_subscribe_pool */
        ao2_ref(sub, -1);
        return -1;
    }
    stasis_subscription_accept_message_type(sub->sub, ast_device_state_message_type());
    stasis_subscription_accept_message_type(sub->sub, stasis_subscription_change_type());
    stasis_subscription_set_filter(sub->sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    ao2_link_flags(device_state_subscriptions, sub, OBJ_NOLOCK);
    ao2_unlock(device_state_subscriptions);
 
    return 0;
}

References ao2_bump, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, app, ast_debug, ast_device_state_message_type(), ast_device_state_topic(), ast_device_state_topic_all(), ast_log, DEVICE_STATE_ALL, device_state_cb(), device_state_subscription_create(), device_state_subscriptions, is_subscribed_device_state(), LOG_ERROR, NULL, OBJ_NOLOCK, stasis_app_name(), stasis_subscribe_pool, stasis_subscription_accept_message_type(), stasis_subscription_change_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), and sub.

unload_module()

static int unload_module ( void  )

static

Definition at line 476 of file res_stasis_device_state.c.

{
    ast_devstate_prov_del(DEVICE_STATE_PROVIDER_STASIS);
    stasis_app_unregister_event_source(&device_state_event_source);
    ao2_cleanup(device_state_subscriptions);
    device_state_subscriptions = NULL;
    return 0;
}

References ao2_cleanup, ast_devstate_prov_del(), device_state_event_source, DEVICE_STATE_PROVIDER_STASIS, device_state_subscriptions, NULL, and stasis_app_unregister_event_source().

unsubscribe_device_state()

static int unsubscribe_device_state ( struct stasis_app *  app, const char *  name  )

static

Definition at line 407 of file res_stasis_device_state.c.

{
    struct device_state_subscription *sub;
 
    ao2_lock(device_state_subscriptions);
    sub = find_device_state_subscription(app, S_OR(name, DEVICE_STATE_ALL));
    if (sub) {
        remove_device_state_subscription(sub);
    }
    ao2_unlock(device_state_subscriptions);
 
    ao2_cleanup(sub);
 
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_unlock, app, DEVICE_STATE_ALL, device_state_subscriptions, find_device_state_subscription(), name, remove_device_state_subscription(), S_OR, and sub.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS , .description = "Stasis application device state support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", }

static

Definition at line 490 of file res_stasis_device_state.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 490 of file res_stasis_device_state.c.

device_state_event_source

struct stasis_app_event_source device_state_event_source

Definition at line 447 of file res_stasis_device_state.c.

                                                           {
    .scheme = DEVICE_STATE_SCHEME_SUB,
    .find = find_device_state,
    .subscribe = subscribe_device_state,
    .unsubscribe = unsubscribe_device_state,
    .is_subscribed = is_subscribed_device_state_lock,
    .to_json = devices_to_json
};

Referenced by load_module(), and unload_module().

device_state_subscriptions

struct ao2_container* device_state_subscriptions

static

Container for subscribed device states

Definition at line 49 of file res_stasis_device_state.c.

Referenced by devices_to_json(), find_device_state_subscription(), is_subscribed_device_state_lock(), load_module(), remove_device_state_subscription(), subscribe_device_state(), unload_module(), and unsubscribe_device_state().