extension_state.c File Reference

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/module.h"
#include "asterisk/extension_state.h"
#include "asterisk/pbx.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/astobj2.h"
#include "asterisk/cli.h"
#include "pbx_private.h"

Include dependency graph for extension_state.c:

Go to the source code of this file.

Data Structures
struct	cfextension_states
struct	device_state_sources_vector
struct	extension_state
	Extension state information. More...
struct	extension_state_device_source
	Device state source feeding an extension state. More...

Macros
#define	DEVICE_SOURCE_ELEM_VERSION_CMP(elem, value)   ((elem)->version != (value))
	device source non-matching version comparator for AST_VECTOR_REMOVE_CMP_UNORDERED()
#define	EXTENSION_STATE_BUCKETS   563
	Number of buckets for extension states.
#define	HINTDEVICE_DATA_LENGTH   16

Functions
static int	action_extensionstatelist (struct mansession *s, const struct message *m)
enum ast_extension_states	ast_devstate_to_extenstate (enum ast_device_state devstate)
	Map devstate to an extension state.
const char *	ast_extension_state2str (int extension_state)
	Return string representation of the state of an extension.
struct ast_channel *	ast_extension_state_get_device_causing_channel (const char *device, enum ast_device_state device_state)
	Get the channel that is causing the device to be in the given state, if any.
struct ast_extension_state_device_snapshot *	ast_extension_state_get_latest_device_snapshot (struct ast_channel *chan, const char *exten, const char *context)
	Get the latest device state message for an extension.
struct ast_extension_state_presence_snapshot *	ast_extension_state_get_latest_presence_snapshot (struct ast_channel *chan, const char *exten, const char *context)
	Get the latest presence state message for an extension.
int	ast_extension_state_init (void)
struct stasis_topic *	ast_extension_state_topic (const char *exten, const char *context)
	Get the Stasis topic to receive extension state messages for a specific extension.
struct stasis_topic *	ast_extension_state_topic_all (void)
	Get the Stasis topic to receive all extension state messages.
	AST_THREADSTORAGE_CUSTOM_SCOPE (hintdevice_data, NULL, ast_free_ptr, static)
static char *	complete_core_show_hint (const char *line, const char *word, int pos, int state)
static struct extension_state *	extension_state_alloc (struct ast_exten *exten, struct ast_context *context)
static void	extension_state_cleanup (void)
static int	extension_state_cleanup_individual (void *obj, void *arg, int flags)
static void	extension_state_destroy (void *obj)
static struct ast_extension_state_device_snapshot *	extension_state_device_snapshot_create (enum ast_extension_states device_state, struct device_state_sources_vector *device_state_sources, struct ast_extension_state_device_state_info *causing_device)
static void	extension_state_device_snapshot_destroy (void *obj)
static void	extension_state_device_snapshot_refresh (struct extension_state *state)
static struct extension_state_device_source *	extension_state_device_source_alloc (struct extension_state *state, const char *device)
static void	extension_state_device_source_destroy (struct extension_state_device_source *source)
static void	extension_state_device_state_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static struct ast_extension_state_device_state_info *	extension_state_device_state_info_alloc (const char *device, enum ast_device_state state)
static struct extension_state *	extension_state_get (struct ast_channel *chan, const char *context, const char *extension)
static struct ast_extension_state_presence_snapshot *	extension_state_presence_snapshot_create (enum ast_presence_state presence_state, const char *presence_subtype, const char *presence_message)
static void	extension_state_presence_snapshot_destroy (void *obj)
static void	extension_state_presence_snapshot_refresh (struct extension_state *state)
static void	extension_state_presence_state_cb (void *unused, struct stasis_subscription *sub, struct stasis_message *msg)
static struct stasis_message *	extension_state_remove_message_create (const char *context, const char *extension)
static void	extension_state_shutdown (struct extension_state *state)
static struct ast_extension_state_update_message *	extension_state_update_message_create (const char *context, const char *extension, struct ast_extension_state_device_snapshot *old_device_snapshot, struct ast_extension_state_device_snapshot *new_device_snapshot, struct ast_extension_state_presence_snapshot *old_presence_snapshot, struct ast_extension_state_presence_snapshot *new_presence_snapshot)
static void	extension_state_update_message_destroy (void *obj)
static int	extension_state_update_sources (struct extension_state *state, struct ast_exten *exten)
static char *	handle_show_hint (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_show_hints (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
void	pbx_extension_state_hint_remove (struct ast_exten *exten, struct ast_context *context)
void	pbx_extension_state_hint_set (struct ast_exten *exten, struct ast_context *context)
	STASIS_MESSAGE_TYPE_DEFN (ast_extension_state_remove_message_type)
	Stasis message type for extension state remove messages.
	STASIS_MESSAGE_TYPE_DEFN (ast_extension_state_update_message_type)
	Sort function for extension states.

Variables
static struct ast_cli_entry	extension_state_cli []
static const struct cfextension_states	extension_state_mappings []
static struct stasis_topic *	extension_state_topic_all
	Topic which receives all extension state updates.
static struct ao2_container *	extension_states
	The global container of extension states.
static struct stasis_subscription *	presence_state_sub
	Single presence state subscription, for all extension states.

Macro Definition Documentation

DEVICE_SOURCE_ELEM_VERSION_CMP

#define DEVICE_SOURCE_ELEM_VERSION_CMP	(		elem,
			value
	)		((elem)->version != (value))

device source non-matching version comparator for AST_VECTOR_REMOVE_CMP_UNORDERED()

Parameters

elem	Element to compare against
value	Value to compare with the vector element.

Returns

0 if element does not match.

Non-zero if element matches.

Definition at line 567 of file extension_state.c.

EXTENSION_STATE_BUCKETS

#define EXTENSION_STATE_BUCKETS   563

Number of buckets for extension states.

Definition at line 125 of file extension_state.c.

HINTDEVICE_DATA_LENGTH

#define HINTDEVICE_DATA_LENGTH   16

Definition at line 82 of file extension_state.c.

Function Documentation

action_extensionstatelist()

static int action_extensionstatelist ( struct mansession *  s, const struct message *  m  )

static

Definition at line 1183 of file extension_state.c.

{
    const char *action_id = astman_get_header(m, "ActionID");
 
    if (!ao2_container_count(extension_states)) {
        astman_send_error(s, m, "No dialplan hints are available");
        return 0;
    }
 
    astman_send_listack(s, m, "Extension Statuses will follow", "start");
 
    ao2_lock(extension_states);
    if (ao2_container_count(extension_states)) {
        struct ao2_iterator it_states;
        struct extension_state *state;
        int count = 0;
 
        it_states = ao2_iterator_init(extension_states, 0);
        for (; (state = ao2_iterator_next(&it_states)); ao2_ref(state, -1)) {
            if (state->extension[0] == '_') {
                continue;
            }
 
            ++count;
 
            astman_append(s, "Event: ExtensionStatus\r\n");
            if (!ast_strlen_zero(action_id)) {
                astman_append(s, "ActionID: %s\r\n", action_id);
            }
            ao2_lock(state);
            astman_append(s,
               "Exten: %s\r\n"
               "Context: %s\r\n"
               "Hint: %s\r\n"
               "Status: %d\r\n"
               "StatusText: %s\r\n\r\n",
               state->dialplan_extension,
               state->dialplan_context,
               state->hint_extension ? ast_get_extension_app(state->hint_extension) : "None",
               state->device_snapshot->state,
               ast_extension_state2str(state->device_snapshot->state));
            ao2_unlock(state);
        }
        ao2_iterator_destroy(&it_states);
        astman_send_list_complete_start(s, m, "ExtensionStateListComplete", count);
        astman_send_list_complete_end(s);
    } else {
        astman_send_error(s, m, "No dialplan hints are available");
    }
 
    ao2_unlock(extension_states);
 
    return 0;
}

References ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_extension_state2str(), ast_get_extension_app(), ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), astman_send_list_complete_end(), astman_send_list_complete_start(), astman_send_listack(), and extension_states.

Referenced by ast_extension_state_init().

ast_devstate_to_extenstate()

enum ast_extension_states ast_devstate_to_extenstate

(

enum ast_device_state

devstate

)

Map devstate to an extension state.

Parameters

[in]

devstate

device state

Returns

the extension state mapping.

Definition at line 1135 of file extension_state.c.

{
    switch (devstate) {
    case AST_DEVICE_ONHOLD:
        return AST_EXTENSION_ONHOLD;
    case AST_DEVICE_BUSY:
        return AST_EXTENSION_BUSY;
    case AST_DEVICE_UNKNOWN:
        return AST_EXTENSION_NOT_INUSE;
    case AST_DEVICE_UNAVAILABLE:
    case AST_DEVICE_INVALID:
        return AST_EXTENSION_UNAVAILABLE;
    case AST_DEVICE_RINGINUSE:
        return (AST_EXTENSION_INUSE | AST_EXTENSION_RINGING);
    case AST_DEVICE_RINGING:
        return AST_EXTENSION_RINGING;
    case AST_DEVICE_INUSE:
        return AST_EXTENSION_INUSE;
    case AST_DEVICE_NOT_INUSE:
        return AST_EXTENSION_NOT_INUSE;
    case AST_DEVICE_TOTAL: /* not a device state, included for completeness */
        break;
    }
 
    return AST_EXTENSION_NOT_INUSE;
}

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_TOTAL, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_EXTENSION_BUSY, AST_EXTENSION_INUSE, AST_EXTENSION_NOT_INUSE, AST_EXTENSION_ONHOLD, AST_EXTENSION_RINGING, and AST_EXTENSION_UNAVAILABLE.

Referenced by AST_TEST_DEFINE(), extension_state_device_snapshot_refresh(), extension_state_device_state_cb(), and extension_state_update_sources().

ast_extension_state2str()

const char * ast_extension_state2str

(

int

extension_state

)

Return string representation of the state of an extension.

Parameters

extension_state

is the numerical state delivered by ast_extension_state

Returns

the state of an extension as string

Definition at line 1162 of file extension_state.c.

{
    int i;
 
    for (i = 0; (i < ARRAY_LEN(extension_state_mappings)); i++) {
        if (extension_state_mappings[i].extension_state == extension_state)
            return extension_state_mappings[i].text;
    }
    return "Unknown";
}

References ARRAY_LEN, extension_state_mappings, and cfextension_states::text.

Referenced by action_extensionstate(), action_extensionstatelist(), AST_TEST_DEFINE(), exten_state_publisher_state_cb(), handle_show_hint(), handle_show_hints(), manager_state_cb(), and to_ami().

ast_extension_state_get_device_causing_channel()

struct ast_channel * ast_extension_state_get_device_causing_channel	(	const char *	device,
		enum ast_device_state	device_state
	)

Get the channel that is causing the device to be in the given state, if any.

Since

23.5.0

22.11.0

20.21.0

Parameters

device	The device itself
device_state	The state of the device

Returns

The channel that is causing the device to be in the given state

Return values

NULL	if there is no channel causing the device to be in the given state

Definition at line 1069 of file extension_state.c.

{
    enum ast_channel_state search_state = 0; /* prevent false uninit warning */
    char match[AST_CHANNEL_NAME];
    struct ast_channel_iterator *chan_iter;
    struct ast_channel *chan, *channel = NULL;
    struct timeval chantime = {0, }; /* prevent false uninit warning */
 
    switch (device_state) {
    case AST_DEVICE_RINGING:
    case AST_DEVICE_RINGINUSE:
        /* find ringing channel */
        search_state = AST_STATE_RINGING;
        break;
    case AST_DEVICE_BUSY:
        /* find busy channel */
        search_state = AST_STATE_BUSY;
        break;
    case AST_DEVICE_ONHOLD:
    case AST_DEVICE_INUSE:
        /* find up channel */
        search_state = AST_STATE_UP;
        break;
    case AST_DEVICE_UNKNOWN:
    case AST_DEVICE_NOT_INUSE:
    case AST_DEVICE_INVALID:
    case AST_DEVICE_UNAVAILABLE:
    case AST_DEVICE_TOTAL /* not a state */:
        /* no channels are of interest */
        return NULL;
    }
 
    /* iterate over all channels of the device */
    snprintf(match, sizeof(match), "%s-", device);
    chan_iter = ast_channel_iterator_by_name_new(match, strlen(match));
    for (; (chan = ast_channel_iterator_next(chan_iter)); ast_channel_unref(chan)) {
        ast_channel_lock(chan);
        /* this channel's state doesn't match */
        if (search_state != ast_channel_state(chan)) {
            ast_channel_unlock(chan);
            continue;
        }
        /* any non-ringing channel will fit */
        if (search_state != AST_STATE_RINGING) {
            ast_channel_unlock(chan);
            channel = chan;
            break;
        }
        /* but we need the oldest ringing channel of the device to match with undirected pickup */
        if (!channel) {
            chantime = ast_channel_creationtime(chan);
            ast_channel_ref(chan); /* must ref it! */
            channel = chan;
        } else if (ast_tvcmp(ast_channel_creationtime(chan), chantime) < 0) {
            chantime = ast_channel_creationtime(chan);
            ast_channel_unref(channel);
            ast_channel_ref(chan); /* must ref it! */
            channel = chan;
        }
        ast_channel_unlock(chan);
    }
    ast_channel_iterator_destroy(chan_iter);
 
    return channel;
}

References ast_channel_creationtime(), ast_channel_iterator_by_name_new(), ast_channel_iterator_destroy(), ast_channel_iterator_next(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_ref, ast_channel_unlock, ast_channel_unref, AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, AST_DEVICE_TOTAL, AST_DEVICE_UNAVAILABLE, AST_DEVICE_UNKNOWN, AST_STATE_BUSY, AST_STATE_RINGING, AST_STATE_UP, ast_tvcmp(), match(), and NULL.

Referenced by extension_state_legacy_add_device_state_info().

ast_extension_state_get_latest_device_snapshot()

struct ast_extension_state_device_snapshot * ast_extension_state_get_latest_device_snapshot	(	struct ast_channel *	chan,
		const char *	exten,
		const char *	context
	)

Get the latest device state message for an extension.

Since

23.5.0

22.11.0

20.21.0

Parameters

chan	The optional channel to get the underlying hint from, if it needs to be created
exten	The extension to get the device state message for
context	The context of the extension

Returns

The latest device snapshot for the extension

Return values

NULL	if the extension does not have a configured hint

Definition at line 1406 of file extension_state.c.

{
    struct extension_state *state;
    struct ast_extension_state_device_snapshot *device_snapshot;
 
    state = extension_state_get(chan, context, exten);
    if (!state) {
        return NULL;
    }
 
    ao2_lock(state);
    extension_state_device_snapshot_refresh(state);
    device_snapshot = ao2_bump(state->device_snapshot);
    ao2_unlock(state);
    ao2_ref(state, -1);
 
    return device_snapshot;
}

References ao2_bump, ao2_lock, ao2_ref, ao2_unlock, extension_state_device_snapshot_refresh(), extension_state_get(), and NULL.

Referenced by ast_extension_state(), and ast_extension_state_extended().

ast_extension_state_get_latest_presence_snapshot()

struct ast_extension_state_presence_snapshot * ast_extension_state_get_latest_presence_snapshot	(	struct ast_channel *	chan,
		const char *	exten,
		const char *	context
	)

Get the latest presence state message for an extension.

Since

23.5.0

22.11.0

20.21.0

Parameters

chan	The optional channel to get the underlying hint from, if it needs to be created
exten	The extension to get the presence state message for
context	The context of the extension

Returns

The latest presence snapshot for the extension

Return values

NULL	if the extension does not have a configured hint

Definition at line 1485 of file extension_state.c.

{
    struct extension_state *state;
    struct ast_extension_state_presence_snapshot *presence_snapshot;
 
    state = extension_state_get(chan, context, exten);
    if (!state) {
        return NULL;
    }
 
    ao2_lock(state);
    extension_state_presence_snapshot_refresh(state);
    presence_snapshot = ao2_bump(state->presence_snapshot);
    ao2_unlock(state);
    ao2_ref(state, -1);
 
    return presence_snapshot;
}

References ao2_bump, ao2_lock, ao2_ref, ao2_unlock, extension_state_get(), extension_state_presence_snapshot_refresh(), and NULL.

Referenced by ast_hint_presence_state().

ast_extension_state_init()

int ast_extension_state_init

(

void

)

Provided by extension_state.c

Definition at line 1714 of file extension_state.c.

{
    if (STASIS_MESSAGE_TYPE_INIT(ast_extension_state_update_message_type) != 0) {
        return -1;
    }
 
    if (STASIS_MESSAGE_TYPE_INIT(ast_extension_state_remove_message_type) != 0) {
        return -1;
    }
 
    /* Initialize extension state subsystem */
    extension_states = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        extension_state_sort_fn, extension_state_cmp_fn);
    if (!extension_states) {
        ast_log(LOG_ERROR, "Failed to allocate new states container\n");
        return -1;
    }
 
    extension_state_topic_all = stasis_topic_create("extension_state:all");
    if (!extension_state_topic_all) {
        ast_log(LOG_ERROR, "Failed to create extension state topic\n");
        return -1;
    }
 
    presence_state_sub = stasis_subscribe(ast_presence_state_topic_all(), extension_state_presence_state_cb, NULL);
    if (!presence_state_sub) {
        ast_log(LOG_ERROR, "Failed to create subscription to receive presence state updates\n");
        return -1;
    }
    stasis_subscription_accept_message_type(presence_state_sub, ast_presence_state_message_type());
    stasis_subscription_set_filter(presence_state_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    ast_cli_register_multiple(extension_state_cli, ARRAY_LEN(extension_state_cli));
    ast_manager_register_xml_core("ExtensionStateList", EVENT_FLAG_CALL | EVENT_FLAG_REPORTING, action_extensionstatelist);
    ast_register_cleanup(extension_state_cleanup);
 
    return 0;
}

References action_extensionstatelist(), AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_rbtree, ARRAY_LEN, ast_cli_register_multiple, ast_extension_state_remove_message_type(), ast_extension_state_update_message_type(), ast_log, ast_manager_register_xml_core, ast_presence_state_message_type(), ast_presence_state_topic_all(), ast_register_cleanup(), EVENT_FLAG_CALL, EVENT_FLAG_REPORTING, extension_state_cleanup(), extension_state_cli, extension_state_presence_state_cb(), extension_state_topic_all, extension_states, LOG_ERROR, NULL, presence_state_sub, STASIS_MESSAGE_TYPE_INIT, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), and stasis_topic_create().

Referenced by asterisk_daemon().

ast_extension_state_topic()

struct stasis_topic * ast_extension_state_topic	(	const char *	exten,
		const char *	context
	)

Get the Stasis topic to receive extension state messages for a specific extension.

Since

23.5.0

22.11.0

20.21.0

Parameters

exten	The extension to receive extension state messages for
context	The context of the extension

Returns

The topic for extension state messages

Return values

NULL	if it has not been allocated

Definition at line 1298 of file extension_state.c.

{
    struct extension_state *state;
    struct stasis_topic *topic;
 
    state = extension_state_get(NULL, context, exten);
    if (!state) {
        return NULL;
    }
 
    ao2_lock(state);
    topic = ao2_bump(state->extension_state_topic);
    ao2_unlock(state);
    ao2_ref(state, -1);
 
    return topic;
}

References ao2_bump, ao2_lock, ao2_ref, ao2_unlock, extension_state_get(), and NULL.

Referenced by extension_state_legacy_add_destroy().

ast_extension_state_topic_all()

struct stasis_topic * ast_extension_state_topic_all

(

void

)

Get the Stasis topic to receive all extension state messages.

Since

23.5.0

22.11.0

20.21.0

Returns

The topic for extension state messages

Return values

NULL	if it has not been allocated

Definition at line 1293 of file extension_state.c.

{
    return extension_state_topic_all;
}

References extension_state_topic_all.

Referenced by extension_state_legacy_add_destroy().

AST_THREADSTORAGE_CUSTOM_SCOPE()

AST_THREADSTORAGE_CUSTOM_SCOPE	(	hintdevice_data	,
		NULL	,
		ast_free_ptr	,
		static
	)

complete_core_show_hint()

static char * complete_core_show_hint ( const char *  line, const char *  word, int  pos, int  state  )

static

Definition at line 1578 of file extension_state.c.

{
    struct extension_state *extstate;
    char *ret = NULL;
    int which = 0;
    int wordlen;
    struct ao2_iterator i;
 
    if (pos != 3)
        return NULL;
 
    wordlen = strlen(word);
 
    /* walk through all hints */
    i = ao2_iterator_init(extension_states, 0);
    for (; (extstate = ao2_iterator_next(&i)); ao2_ref(extstate, -1)) {
        ao2_lock(extstate);
        if (!strncasecmp(word, extstate->dialplan_extension, wordlen) && ++which > state) {
            ret = ast_strdup(extstate->dialplan_extension);
            ao2_unlock(extstate);
            ao2_ref(extstate, -1);
            break;
        }
        ao2_unlock(extstate);
    }
    ao2_iterator_destroy(&i);
 
    return ret;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_strdup, extension_state::dialplan_extension, extension_states, and NULL.

Referenced by handle_show_hint().

extension_state_alloc()

static struct extension_state * extension_state_alloc ( struct ast_exten *  exten, struct ast_context *  context  )

static

Definition at line 924 of file extension_state.c.

{
    char extension[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
    struct extension_state *state;
    char *extension_state_topic_name;
 
    snprintf(extension, sizeof(extension), "%s@%s", ast_get_extension_name(exten), ast_get_context_name(context));
 
    /*
     * Each individual extension state has its own lock to ensure that when updating it
     * we do not cause problems for either the existing topic ingesting updates
     * or any access to the extension state cached message.
     */
    state = ao2_alloc(sizeof(*state) + strlen(extension) + 1, extension_state_destroy);
    if (!state) {
        return NULL;
    }
 
    ast_copy_string(state->dialplan_context, ast_get_context_name(context), sizeof(state->dialplan_context));
    ast_copy_string(state->dialplan_extension, ast_get_extension_name(exten), sizeof(state->dialplan_extension));
    strcpy(state->extension, extension); /* Safe */
    AST_VECTOR_INIT(&state->device_state_sources, 0);
 
    /* These are the default if no sources are present */
    state->device_snapshot = extension_state_device_snapshot_create(AST_EXTENSION_UNAVAILABLE,
        &state->device_state_sources, NULL);
    state->presence_snapshot = extension_state_presence_snapshot_create(AST_PRESENCE_NOT_SET, NULL, NULL);
    if (!state->device_snapshot || !state->presence_snapshot) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    /*
     * We don't actually access the contents of exten past guarantee of it being valid so we can safely
     * store a pointer to just do pointer comparison.
     */
    state->hint_extension = exten;
 
    /* Pattern match extensions don't have sources or a topic, so return early */
    if (extension[0] == '_') {
        return state;
    }
 
    /* We most likely have at least one device state source */
    if (AST_VECTOR_INIT(&state->device_state_sources, 1)) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    if (ast_asprintf(&extension_state_topic_name, "extension_state:extension/%s", extension) < 0) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    state->extension_state_topic = stasis_topic_create(extension_state_topic_name);
    ast_free(extension_state_topic_name);
    if (!state->extension_state_topic) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    state->extension_state_forwarder = stasis_forward_all(state->extension_state_topic, extension_state_topic_all);
    if (!state->extension_state_forwarder) {
        ao2_ref(state, -1);
        return NULL;
    }
 
    return state;
}

References ao2_alloc, ao2_ref, ast_asprintf, ast_copy_string(), AST_EXTENSION_UNAVAILABLE, ast_free, ast_get_context_name(), ast_get_extension_name(), AST_MAX_CONTEXT, AST_MAX_EXTENSION, AST_PRESENCE_NOT_SET, AST_VECTOR_INIT, extension_state_destroy(), extension_state_device_snapshot_create(), extension_state_presence_snapshot_create(), extension_state_topic_all, NULL, stasis_forward_all(), and stasis_topic_create().

Referenced by pbx_extension_state_hint_set().

extension_state_cleanup()

static void extension_state_cleanup ( void  )

static

Definition at line 1701 of file extension_state.c.

{
    ast_cli_unregister_multiple(extension_state_cli, ARRAY_LEN(extension_state_cli));
    ast_manager_unregister("ExtensionStateList");
    if (extension_states) {
        ao2_callback(extension_states, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK, extension_state_cleanup_individual, NULL);
        ao2_ref(extension_states, -1);
    }
    presence_state_sub = stasis_unsubscribe_and_join(presence_state_sub);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_extension_state_update_message_type);
    STASIS_MESSAGE_TYPE_CLEANUP(ast_extension_state_remove_message_type);
}

References ao2_callback, ao2_ref, ARRAY_LEN, ast_cli_unregister_multiple(), ast_extension_state_remove_message_type(), ast_extension_state_update_message_type(), ast_manager_unregister(), extension_state_cleanup_individual(), extension_state_cli, extension_states, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, presence_state_sub, STASIS_MESSAGE_TYPE_CLEANUP, and stasis_unsubscribe_and_join().

Referenced by ast_extension_state_init().

extension_state_cleanup_individual()

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

static

Definition at line 1688 of file extension_state.c.

{
    struct extension_state *state = obj;
 
    extension_state_shutdown(state);
 
    return CMP_MATCH;
}

References CMP_MATCH, and extension_state_shutdown().

Referenced by extension_state_cleanup().

extension_state_destroy()

static void extension_state_destroy ( void *  obj )

static

Definition at line 726 of file extension_state.c.

{
    struct extension_state *state = obj;
 
    ao2_cleanup(state->device_snapshot);
    ao2_cleanup(state->presence_snapshot);
    ao2_cleanup(state->extension_state_topic);
 
    ast_free(state->presence_sources_string);
}

References ao2_cleanup, and ast_free.

Referenced by extension_state_alloc().

extension_state_device_snapshot_create()

static struct ast_extension_state_device_snapshot * extension_state_device_snapshot_create ( enum ast_extension_states  device_state, struct device_state_sources_vector *  device_state_sources, struct ast_extension_state_device_state_info *  causing_device  )

static

Definition at line 290 of file extension_state.c.

{
    struct ast_extension_state_device_snapshot *device_snapshot;
    int i;
 
    device_snapshot = ao2_alloc_options(sizeof(*device_snapshot),
        extension_state_device_snapshot_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!device_snapshot) {
        return NULL;
    }
 
    device_snapshot->state = device_state;
    device_snapshot->causing_device = ao2_bump(causing_device);
    if (AST_VECTOR_INIT(&device_snapshot->additional_devices, AST_VECTOR_SIZE(device_state_sources))) {
        ao2_ref(device_snapshot, -1);
        return NULL;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(device_state_sources); i++) {
        struct extension_state_device_source *source = AST_VECTOR_GET(device_state_sources, i);
 
        if (causing_device && source->info == causing_device) {
            continue;
        }
 
        AST_VECTOR_APPEND(&device_snapshot->additional_devices, ao2_bump(source->info));
    }
 
    return device_snapshot;
}

References ast_extension_state_device_snapshot::additional_devices, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_ref, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_INIT, AST_VECTOR_SIZE, ast_extension_state_device_snapshot::causing_device, extension_state_device_snapshot_destroy(), extension_state_device_source::info, NULL, and ast_extension_state_device_snapshot::state.

Referenced by extension_state_alloc(), extension_state_device_snapshot_refresh(), extension_state_device_state_cb(), and extension_state_update_sources().

extension_state_device_snapshot_destroy()

static void extension_state_device_snapshot_destroy ( void *  obj )

static

Definition at line 269 of file extension_state.c.

{
    struct ast_extension_state_device_snapshot *device_snapshot = obj;
 
    ao2_cleanup(device_snapshot->causing_device);
    AST_VECTOR_CALLBACK_VOID(&device_snapshot->additional_devices, ao2_cleanup);
    AST_VECTOR_FREE(&device_snapshot->additional_devices);
}

References ast_extension_state_device_snapshot::additional_devices, ao2_cleanup, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, and ast_extension_state_device_snapshot::causing_device.

Referenced by extension_state_device_snapshot_create().

extension_state_device_snapshot_refresh()

static void extension_state_device_snapshot_refresh ( struct extension_state *  state )

static

Definition at line 1328 of file extension_state.c.

{
    struct ast_devstate_aggregate agg;
    enum ast_extension_states new_device_state;
    int i;
    int invalid = 0;
 
    /* If no cached device state is invalid then there is nothing to refresh */
    for (i = 0; i < AST_VECTOR_SIZE(&state->device_state_sources); i++) {
        struct extension_state_device_source *source = AST_VECTOR_GET(&state->device_state_sources, i);
 
        if (source->info->state == AST_DEVICE_INVALID) {
            invalid = 1;
            break;
        }
    }
    if (!invalid) {
        return;
    }
 
    ast_devstate_aggregate_init(&agg);
 
    for (i = 0; i < AST_VECTOR_SIZE(&state->device_state_sources); i++) {
        struct extension_state_device_source *source = AST_VECTOR_GET(&state->device_state_sources, i);
 
        /*
         * An invalid state may be because the device state provider was not available when the
         * state was last queried, such as when the hint was created before the provider was
         * loaded. Since a caller is explicitly requesting the state we make another attempt to
         * retrieve it and if it has changed update it and notify any subscribers.
         */
        if (source->info->state == AST_DEVICE_INVALID) {
            enum ast_device_state device_state = ast_device_state(source->info->device);
 
            if (device_state != source->info->state) {
                struct ast_extension_state_device_state_info *info;
 
                info = extension_state_device_state_info_alloc(source->info->device, device_state);
                if (info) {
                    ao2_replace(source->info, info);
                    ao2_ref(info, -1);
                }
            }
        }
 
        ast_devstate_aggregate_add(&agg, source->info->state);
    }
 
    new_device_state = ast_devstate_to_extenstate(ast_devstate_aggregate_result(&agg));
    if (new_device_state != state->device_snapshot->state) {
        struct ast_extension_state_device_snapshot *device_snapshot;
        struct ast_extension_state_update_message *update_message;
 
        device_snapshot = extension_state_device_snapshot_create(new_device_state, &state->device_state_sources, NULL);
        if (!device_snapshot) {
            return;
        }
 
        update_message = extension_state_update_message_create(state->dialplan_context, state->dialplan_extension,
            state->device_snapshot, device_snapshot, state->presence_snapshot, state->presence_snapshot);
 
        /* Even if we can't publish an update message we still ensure the local cached snapshot is up to date */
        ao2_replace(state->device_snapshot, device_snapshot);
        ao2_ref(device_snapshot, -1);
 
        if (update_message) {
            struct stasis_message *message = stasis_message_create(ast_extension_state_update_message_type(), update_message);
 
            if (message) {
                stasis_publish(state->extension_state_topic, message);
                ao2_ref(message, -1);
            }
 
            ao2_ref(update_message, -1);
        }
    }
}

References ao2_ref, ao2_replace, AST_DEVICE_INVALID, ast_devstate_aggregate_add(), ast_devstate_aggregate_init(), ast_devstate_aggregate_result(), ast_devstate_to_extenstate(), ast_extension_state_update_message_type(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_extension_state_device_state_info::device, extension_state_device_snapshot_create(), extension_state_device_state_info_alloc(), extension_state_update_message_create(), extension_state_device_source::info, NULL, stasis_message_create(), stasis_publish(), and ast_extension_state_device_state_info::state.

Referenced by ast_extension_state_get_latest_device_snapshot(), handle_show_hint(), and handle_show_hints().

extension_state_device_source_alloc()

static struct extension_state_device_source * extension_state_device_source_alloc ( struct extension_state *  state, const char *  device  )

static

Definition at line 452 of file extension_state.c.

{
    struct extension_state_device_source *source;
    struct stasis_topic *topic;
 
    /*
     * Ensure that we have a direct device state topic for the device, note this is returned without a reference but
     * is guaranteed to exist regardless.
     */
    topic = ast_device_state_topic(device);
    if (!topic) {
        return NULL;
    }
 
    /*
     * The device state source is only used within the extension state and is never
     * passed around so the overhead of an ao2 object with reference counting is unnecessary.
     */
    source = ast_calloc(1, sizeof(*source));
    if (!source) {
        return NULL;
    }
 
    source->info = extension_state_device_state_info_alloc(device, ast_device_state(device));
    if (!source->info) {
        extension_state_device_source_destroy(source);
        return NULL;
    }
 
    /*
     * We do a synchronous subscription to the device state topic, as our callback is extremely
     * short lived and the added overhead of queueing to a taskprocessor for another thread to handle
     * it is just not worth it.
     */
    source->device_state_subscription = stasis_subscribe_synchronous(topic, extension_state_device_state_cb, state);
    if (!source->device_state_subscription) {
        extension_state_device_source_destroy(source);
        return NULL;
    }
 
    stasis_subscription_accept_message_type(source->device_state_subscription, ast_device_state_message_type());
    stasis_subscription_set_filter(source->device_state_subscription, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    return source;
}

References ast_calloc, ast_device_state_message_type(), ast_device_state_topic(), extension_state_device_source::device_state_subscription, extension_state_device_source_destroy(), extension_state_device_state_cb(), extension_state_device_state_info_alloc(), extension_state_device_source::info, NULL, stasis_subscribe_synchronous, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, and stasis_subscription_set_filter().

Referenced by extension_state_update_sources().

extension_state_device_source_destroy()

static void extension_state_device_source_destroy ( struct extension_state_device_source *  source )

static

Definition at line 225 of file extension_state.c.

{
    if (source->device_state_subscription) {
        stasis_unsubscribe(source->device_state_subscription);
    }
    ao2_cleanup(source->info);
    ast_free(source);
}

References ao2_cleanup, ast_free, extension_state_device_source::device_state_subscription, extension_state_device_source::info, and stasis_unsubscribe().

Referenced by extension_state_device_source_alloc(), extension_state_shutdown(), and extension_state_update_sources().

extension_state_device_state_cb()

static void extension_state_device_state_cb ( void *  userdata, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 334 of file extension_state.c.

{
    struct extension_state *state = userdata;
    struct ast_device_state_message *device_state;
    struct ast_devstate_aggregate agg;
    struct ast_extension_state_device_state_info *extension_device_state_info;
    int i;
    unsigned int updated = 0;
    enum ast_extension_states new_device_state;
 
    if (stasis_message_type(msg) != ast_device_state_message_type()) {
        return;
    }
 
    device_state = stasis_message_data(msg);
 
    /* We only care about the aggregate state */
    if (device_state->eid) {
        return;
    }
 
    ast_devstate_aggregate_init(&agg);
 
    /*
     * Alrighty, the reason that we store an extension_device_state_info is to reduce the memory allocation that
     * has to occur every time we get a device state update and have to construct a new message. If the extension
     * state contains only a single device source we have to do this anyway, but if there's multiple then if we
     * didn't store the result we'd be creating new ones every message to put in the additional_devices vector.
     */
    extension_device_state_info = extension_state_device_state_info_alloc(device_state->device, device_state->state);
    if (!extension_device_state_info) {
        return;
    }
 
    ao2_lock(state);
 
    for (i = 0; i < AST_VECTOR_SIZE(&state->device_state_sources); i++) {
        struct extension_state_device_source *source = AST_VECTOR_GET(&state->device_state_sources, i);
 
        if (!strcmp(source->info->device, device_state->device)) {
            ao2_replace(source->info, extension_device_state_info);
            updated = 1;
        }
 
        ast_devstate_aggregate_add(&agg, source->info->state);
    }
 
    /* We don't really care about the device state info contents now, so we can drop the reference */
    ao2_ref(extension_device_state_info, -1);
 
    /*
     * It's possible for a device state update to come in for a device which is no longer feeding this
     * extension state if it has been updated, so only actually care about the new device state if a
     * source has actually been updated.
     */
    if (!updated) {
        ao2_unlock(state);
        return;
    }
 
    /*
     * We actually update things and raise a message if the state is different, or if the state is ringing
     * as that can actually just be an update that someone else is ringing the same extension.
     */
    new_device_state = ast_devstate_to_extenstate(ast_devstate_aggregate_result(&agg));
    if ((state->device_snapshot->state != new_device_state) || (new_device_state & AST_EXTENSION_RINGING)) {
        struct ast_extension_state_device_snapshot *device_snapshot;
        struct ast_extension_state_update_message *update_message;
        struct stasis_message *message;
 
        /* Now above you probably noticed I dropped the reference for extension_device_state_info but now I'm
         * passing it in here. Don't panic - a reference exists on the device state source still and since we
         * have the state locked it can't go away.
         */
        device_snapshot = extension_state_device_snapshot_create(new_device_state, &state->device_state_sources,
            extension_device_state_info);
        if (!device_snapshot) {
            ao2_unlock(state);
            return;
        }
 
        update_message = extension_state_update_message_create(state->dialplan_context, state->dialplan_extension,
            state->device_snapshot, device_snapshot, state->presence_snapshot, state->presence_snapshot);
 
        /* Even if we can't publish an update message we still ensure the local cached snapshot is up to date */
        ao2_replace(state->device_snapshot, device_snapshot);
        ao2_ref(device_snapshot, -1);
 
        if (!update_message) {
            ao2_unlock(state);
            return;
        }
 
        /* Inform any subscribers of the change to the device snapshot */
        message = stasis_message_create(ast_extension_state_update_message_type(), update_message);
        if (message) {
            stasis_publish(state->extension_state_topic, message);
            ao2_ref(message, -1);
        }
 
        ao2_ref(update_message, -1);
    }
 
    ao2_unlock(state);
}

References ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_device_state_message_type(), ast_devstate_aggregate_add(), ast_devstate_aggregate_init(), ast_devstate_aggregate_result(), ast_devstate_to_extenstate(), AST_EXTENSION_RINGING, ast_extension_state_update_message_type(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_device_state_message::device, ast_extension_state_device_state_info::device, ast_device_state_message::eid, extension_state_device_snapshot_create(), extension_state_device_state_info_alloc(), extension_state_update_message_create(), extension_state_device_source::info, stasis_message_create(), stasis_message_data(), stasis_publish(), ast_device_state_message::state, and ast_extension_state_device_state_info::state.

Referenced by extension_state_device_source_alloc().

extension_state_device_state_info_alloc()

static struct ast_extension_state_device_state_info * extension_state_device_state_info_alloc ( const char *  device, enum ast_device_state  state  )

static

Definition at line 244 of file extension_state.c.

{
    struct ast_extension_state_device_state_info *info;
 
    info = ao2_alloc_options(sizeof(*info) + strlen(device) + 1, NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!info) {
        return NULL;
    }
 
    info->state = state;
    strcpy(info->device, device); /* Safe */
 
    return info;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_extension_state_device_state_info::device, NULL, and ast_extension_state_device_state_info::state.

Referenced by extension_state_device_snapshot_refresh(), extension_state_device_source_alloc(), and extension_state_device_state_cb().

extension_state_get()

static struct extension_state * extension_state_get ( struct ast_channel *  chan, const char *  context, const char *  extension  )

static

Definition at line 1006 of file extension_state.c.

{
    struct extension_state *state;
    struct ast_exten *hint_exten;
    struct pbx_find_info q = { .stacklen = 0 };
    char location[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
 
    /* We optimistically search for the extension state using the provided context and extension */
    snprintf(location, sizeof(location), "%s@%s", extension, context);
    state = ao2_find(extension_states, location, OBJ_SEARCH_KEY);
    if (state) {
        return state;
    }
 
    /*
     * Pattern match extensions do exist within extension state for the purposes of listing them out,
     * but they can't resolve down to anything else
     */
    if (extension[0] == '_') {
        return NULL;
    }
 
    ast_wrlock_contexts();
 
    /*
     * We can't use the provided context and extension as-is because an include
     * could have resulted in the context being different than what was provided.
     * To handle this we query the dialplan to find where the hint actually is.
     * We also need to do this to determine if this is a pattern match or an explicit
     * extension.
     */
    hint_exten = pbx_find_extension(chan, NULL, &q, context, extension,
        PRIORITY_HINT, NULL, "", E_MATCH);
    if (!hint_exten) {
        /*
         * The extension must ALWAYS exist in the dialplan in some capacity. It is
         * either in the dialplan as an explicit extension or a pattern match.
         */
        ast_unlock_contexts();
        return NULL;
    }
 
    if (ast_get_extension_name(hint_exten)[0] == '_') {
        /*
         * If this resolved down to a pattern match that means this is the first request
         * for this explicit extension so we need to add it to the dialplan which will create
         * an extension state for it. It's possible for us to conflict with another thread but
         * in that case the ast_add_extension call will fail and be a no-op and we will return
         * the extension state the other thread created.
         */
        ast_add_extension(q.foundcontext, 0, extension, PRIORITY_HINT, ast_get_extension_label(hint_exten),
            ast_get_extension_matchcid(hint_exten) ? ast_get_extension_cidmatch(hint_exten) : NULL,
            ast_get_extension_app(hint_exten), ast_strdup(ast_get_extension_app_data(hint_exten)), ast_free_ptr,
            ast_get_extension_registrar(hint_exten));
    }
 
    /* The extension state should already exist at this point */
    snprintf(location, sizeof(location), "%s@%s", extension, q.foundcontext);
    ast_unlock_contexts();
 
    return ao2_find(extension_states, location, OBJ_SEARCH_KEY);
}

References ao2_find, ast_add_extension(), ast_free_ptr(), ast_get_extension_app(), ast_get_extension_app_data(), ast_get_extension_cidmatch(), ast_get_extension_label(), ast_get_extension_matchcid(), ast_get_extension_name(), ast_get_extension_registrar(), AST_MAX_CONTEXT, AST_MAX_EXTENSION, ast_strdup, ast_unlock_contexts(), ast_wrlock_contexts(), E_MATCH, extension_states, pbx_find_info::foundcontext, NULL, OBJ_SEARCH_KEY, pbx_find_extension(), PRIORITY_HINT, and pbx_find_info::stacklen.

Referenced by ast_extension_state_get_latest_device_snapshot(), ast_extension_state_get_latest_presence_snapshot(), and ast_extension_state_topic().

extension_state_presence_snapshot_create()

static struct ast_extension_state_presence_snapshot * extension_state_presence_snapshot_create ( enum ast_presence_state  presence_state, const char *  presence_subtype, const char *  presence_message  )

static

Definition at line 527 of file extension_state.c.

{
    struct ast_extension_state_presence_snapshot *presence_snapshot;
 
    presence_snapshot = ao2_alloc_options(sizeof(*presence_snapshot), extension_state_presence_snapshot_destroy,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!presence_snapshot) {
        return NULL;
    }
 
    /* To ensure that we don't give a partial snapshot we fail creation if any allocation fails */
    presence_snapshot->presence_state = presence_state;
    if (presence_subtype) {
        presence_snapshot->presence_subtype = ast_strdup(presence_subtype);
        if (!presence_snapshot->presence_subtype) {
            ao2_ref(presence_snapshot, -1);
            return NULL;
        }
    }
    if (presence_message) {
        presence_snapshot->presence_message = ast_strdup(presence_message);
        if (!presence_snapshot->presence_message) {
            ao2_ref(presence_snapshot, -1);
            return NULL;
        }
    }
 
    return presence_snapshot;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_strdup, extension_state_presence_snapshot_destroy(), NULL, ast_extension_state_presence_snapshot::presence_message, ast_extension_state_presence_snapshot::presence_state, and ast_extension_state_presence_snapshot::presence_subtype.

Referenced by extension_state_alloc(), extension_state_presence_snapshot_refresh(), extension_state_presence_state_cb(), and extension_state_update_sources().

extension_state_presence_snapshot_destroy()

static void extension_state_presence_snapshot_destroy ( void *  obj )

static

Definition at line 507 of file extension_state.c.

{
    struct ast_extension_state_presence_snapshot *presence_snapshot = obj;
 
    ast_free(presence_snapshot->presence_subtype);
    ast_free(presence_snapshot->presence_message);
}

References ast_free, ast_extension_state_presence_snapshot::presence_message, and ast_extension_state_presence_snapshot::presence_subtype.

Referenced by extension_state_presence_snapshot_create().

extension_state_presence_snapshot_refresh()

static void extension_state_presence_snapshot_refresh ( struct extension_state *  state )

static

Definition at line 1438 of file extension_state.c.

{
    enum ast_presence_state presence_state_new;
    char *presence_subtype;
    char *presence_message;
 
    /*
     * If the cached presence state is invalid it may be because the presence state provider
     * was unable to be reached when it was last queried, or because the resulting update was
     * ignored. Since a caller is explicitly requesting the presence state we make another
     * attempt to retrieve it and if it has changed update it and notify any subscribers.
     */
    if (state->presence_snapshot->presence_state != AST_PRESENCE_INVALID || !state->presence_sources_string) {
        return;
    }
 
    presence_state_new = ast_presence_state(state->presence_sources_string, &presence_subtype, &presence_message);
    if (presence_state_new != AST_PRESENCE_INVALID) {
        struct ast_extension_state_presence_snapshot *new_presence_snapshot;
 
        new_presence_snapshot = extension_state_presence_snapshot_create(presence_state_new, presence_subtype,
            presence_message);
        if (new_presence_snapshot) {
            struct ast_extension_state_update_message *update_message;
 
            update_message = extension_state_update_message_create(state->dialplan_context, state->dialplan_extension,
                state->device_snapshot, state->device_snapshot, state->presence_snapshot, new_presence_snapshot);
            ao2_replace(state->presence_snapshot, new_presence_snapshot);
            ao2_ref(new_presence_snapshot, -1);
 
            if (update_message) {
                struct stasis_message *message = stasis_message_create(ast_extension_state_update_message_type(), update_message);
 
                if (message) {
                    stasis_publish(state->extension_state_topic, message);
                    ao2_ref(message, -1);
                }
 
                ao2_ref(update_message, -1);
            }
        }
    }
 
    ast_free(presence_subtype);
    ast_free(presence_message);
}

References ao2_ref, ao2_replace, ast_extension_state_update_message_type(), ast_free, AST_PRESENCE_INVALID, extension_state_presence_snapshot_create(), extension_state_update_message_create(), ast_extension_state_update_message::new_presence_snapshot, ast_extension_state_presence_snapshot::presence_message, ast_extension_state_presence_snapshot::presence_subtype, stasis_message_create(), and stasis_publish().

Referenced by ast_extension_state_get_latest_presence_snapshot(), handle_show_hint(), and handle_show_hints().

extension_state_presence_state_cb()

static void extension_state_presence_state_cb ( void *  unused, struct stasis_subscription *  sub, struct stasis_message *  msg  )

static

Definition at line 821 of file extension_state.c.

{
    struct ast_presence_state_message *presence_state;
    struct ao2_iterator iter;
    struct extension_state *state;
 
    if (stasis_message_type(msg) != ast_presence_state_message_type()) {
        return;
    }
 
    presence_state = stasis_message_data(msg);
 
    ao2_lock(extension_states);
    iter = ao2_iterator_init(extension_states, 0);
    for (; (state = ao2_iterator_next(&iter)); ao2_ref(state, -1)) {
        enum ast_presence_state presence_state_new;
        char *presence_subtype, *presence_message;
        struct ast_extension_state_presence_snapshot *presence_snapshot;
        struct ast_extension_state_update_message *update_message;
 
        ao2_lock(state);
 
        /*
         * We determine if this update is relevant to this extension state by seeing if the presence sources string
         * even remotely contains the provider for this update. Worst case it's a substring and the calculated presence
         * state is the same as before in which case we ignore it.
         */
        if (!state->presence_sources_string || !strcasestr(state->presence_sources_string, presence_state->provider)) {
            ao2_unlock(state);
            continue;
        }
 
        /*
         * Aggregation of presence state is done by requesting the current presence state with passing in a complete
         * list of providers. This means that a presence state change message is just a notification to us to go and
         * retrieve the new presence state. We don't just take it from the message itself. Since presence state is not
         * as common as device state this is not a problem despite being inefficient in comparison to the device state
         * implementation.
         */
        presence_state_new = ast_presence_state(state->presence_sources_string, &presence_subtype, &presence_message);
        if (presence_state_new == AST_PRESENCE_INVALID) {
            /* For the invalid case we just ignore this update */
            ao2_unlock(state);
            continue;
        }
 
        if ((state->presence_snapshot->presence_state == presence_state_new) &&
            ((!presence_subtype && !state->presence_snapshot->presence_subtype) ||
                (presence_subtype && state->presence_snapshot->presence_subtype &&
                    !strcmp(presence_subtype, state->presence_snapshot->presence_subtype))) &&
            ((!presence_message && !state->presence_snapshot->presence_message) ||
                (presence_message && state->presence_snapshot->presence_message &&
                    !strcmp(presence_message, state->presence_snapshot->presence_message)))) {
            /* No change in presence state, so ignore this update */
            ao2_unlock(state);
            ast_free(presence_subtype);
            ast_free(presence_message);
            continue;
        }
 
        presence_snapshot = extension_state_presence_snapshot_create(presence_state_new, presence_subtype, presence_message);
        if (!presence_snapshot) {
            ao2_unlock(state);
            ast_free(presence_subtype);
            ast_free(presence_message);
            continue;
        }
 
        update_message = extension_state_update_message_create(state->dialplan_context,
            state->dialplan_extension, state->device_snapshot, state->device_snapshot, state->presence_snapshot, presence_snapshot);
        ao2_replace(state->presence_snapshot, presence_snapshot);
        ao2_ref(presence_snapshot, -1);
        if (update_message) {
            struct stasis_message *message = stasis_message_create(ast_extension_state_update_message_type(), update_message);
 
            if (message) {
                stasis_publish(state->extension_state_topic, message);
                ao2_ref(message, -1);
            }
 
            ao2_ref(update_message, -1);
        }
 
        ao2_unlock(state);
 
        ast_free(presence_subtype);
        ast_free(presence_message);
    }
    ao2_iterator_destroy(&iter);
    ao2_unlock(extension_states);
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_extension_state_update_message_type(), ast_free, AST_PRESENCE_INVALID, ast_presence_state_message_type(), extension_state_presence_snapshot_create(), extension_state_update_message_create(), extension_states, stasis_message_create(), stasis_message_data(), stasis_publish(), and strcasestr().

Referenced by ast_extension_state_init().

extension_state_remove_message_create()

static struct stasis_message * extension_state_remove_message_create ( const char *  context, const char *  extension  )

static

Definition at line 750 of file extension_state.c.

{
    size_t context_len = strlen(context) + 1;
    size_t extension_len = strlen(extension) + 1;
    struct ast_extension_state_remove_message *remove_message;
    struct stasis_message *message;
 
    remove_message = ao2_alloc_options(sizeof(*remove_message) + context_len + extension_len, NULL,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!remove_message) {
        return NULL;
    }
 
    ast_copy_string(remove_message->extension, extension, extension_len); /* Safe */
    remove_message->context = remove_message->extension + extension_len;
    ast_copy_string(remove_message->context, context, context_len); /* Safe */
 
    message = stasis_message_create(ast_extension_state_remove_message_type(), remove_message);
    ao2_ref(remove_message, -1);
 
    return message;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_ref, ast_copy_string(), ast_extension_state_remove_message_type(), ast_extension_state_remove_message::context, ast_extension_state_remove_message::extension, NULL, and stasis_message_create().

Referenced by extension_state_shutdown().

extension_state_shutdown()

static void extension_state_shutdown ( struct extension_state *  state )

static

Definition at line 782 of file extension_state.c.

{
    struct stasis_message *remove_message;
 
    /*
     * Shutting down an extension state requires us to publish to its topic so all subscribers
     * know that it is going away. However, if the topic failed to be created then we have nothing
     * to publish to and can just return.
     */
    if (!state->extension_state_topic) {
        return;
    }
 
    /* Inform all subscribers that this extension state is being removed */
    remove_message = extension_state_remove_message_create(state->dialplan_context,
        state->dialplan_extension);
    if (remove_message) {
        stasis_publish(state->extension_state_topic, remove_message);
        ao2_ref(remove_message, -1);
    }
 
    AST_VECTOR_CALLBACK_VOID(&state->device_state_sources, extension_state_device_source_destroy);
    AST_VECTOR_FREE(&state->device_state_sources);
 
    stasis_forward_cancel(state->extension_state_forwarder);
}

References ao2_ref, AST_VECTOR_CALLBACK_VOID, AST_VECTOR_FREE, extension_state_device_source_destroy(), extension_state_remove_message_create(), stasis_forward_cancel(), and stasis_publish().

Referenced by extension_state_cleanup_individual(), and pbx_extension_state_hint_remove().

extension_state_update_message_create()

static struct ast_extension_state_update_message * extension_state_update_message_create ( const char *  context, const char *  extension, struct ast_extension_state_device_snapshot *  old_device_snapshot, struct ast_extension_state_device_snapshot *  new_device_snapshot, struct ast_extension_state_presence_snapshot *  old_presence_snapshot, struct ast_extension_state_presence_snapshot *  new_presence_snapshot  )

static

Definition at line 190 of file extension_state.c.

{
    size_t context_len = strlen(context) + 1;
    size_t extension_len = strlen(extension) + 1;
    struct ast_extension_state_update_message *update_message;
 
    update_message = ao2_alloc_options(sizeof(*update_message) + context_len + extension_len,
        extension_state_update_message_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!update_message) {
        return NULL;
    }
 
    ast_copy_string(update_message->extension, extension, extension_len); /* Safe */
    update_message->context = update_message->extension + extension_len;
    ast_copy_string(update_message->context, context, context_len); /* Safe */
 
    update_message->old_device_snapshot = ao2_bump(old_device_snapshot);
    update_message->new_device_snapshot = ao2_bump(new_device_snapshot);
    update_message->old_presence_snapshot = ao2_bump(old_presence_snapshot);
    update_message->new_presence_snapshot = ao2_bump(new_presence_snapshot);
 
    return update_message;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ast_copy_string(), ast_extension_state_update_message::context, ast_extension_state_update_message::extension, extension_state_update_message_destroy(), ast_extension_state_update_message::new_device_snapshot, ast_extension_state_update_message::new_presence_snapshot, NULL, ast_extension_state_update_message::old_device_snapshot, and ast_extension_state_update_message::old_presence_snapshot.

Referenced by extension_state_device_snapshot_refresh(), extension_state_device_state_cb(), extension_state_presence_snapshot_refresh(), extension_state_presence_state_cb(), and extension_state_update_sources().

extension_state_update_message_destroy()

static void extension_state_update_message_destroy ( void *  obj )

static

Definition at line 165 of file extension_state.c.

{
    struct ast_extension_state_update_message *update_message = obj;
 
    ao2_cleanup(update_message->old_device_snapshot);
    ao2_cleanup(update_message->new_device_snapshot);
    ao2_cleanup(update_message->old_presence_snapshot);
    ao2_cleanup(update_message->new_presence_snapshot);
}

References ao2_cleanup, ast_extension_state_update_message::new_device_snapshot, ast_extension_state_update_message::new_presence_snapshot, ast_extension_state_update_message::old_device_snapshot, and ast_extension_state_update_message::old_presence_snapshot.

Referenced by extension_state_update_message_create().

extension_state_update_sources()

static int extension_state_update_sources ( struct extension_state *  state, struct ast_exten *  exten  )

static

Definition at line 580 of file extension_state.c.

{
    struct ast_str *str = ast_str_thread_get(&hintdevice_data, HINTDEVICE_DATA_LENGTH);
    char *devices, *device, *presence_state_sources;
    struct ast_devstate_aggregate agg;
    enum ast_extension_states new_device_state;
    unsigned int version;
    struct ast_extension_state_device_snapshot *device_snapshot = NULL;
    struct ast_extension_state_presence_snapshot *presence_snapshot = NULL;
 
    ast_str_set(&str, 0, "%s", ast_get_extension_app(exten));
    devices = ast_str_buffer(str);
 
    ao2_lock(state);
 
    /*
     * The format of the app part of a hint is "[device[&device]],[presence[&presence]]" so
     * we can just find the first occurrence of ',' in order to get to the presence sources.
     */
    presence_state_sources = strchr(devices, ',');
    if (presence_state_sources) {
        *presence_state_sources++ = '\0';
    }
 
    ast_devstate_aggregate_init(&agg);
 
    version = ast_random();
 
    /* Devices are separated by '&' */
    while ((device = strsep(&devices, "&"))) {
        struct extension_state_device_source *source = NULL;
        int i;
 
        /* Skip any device names that are empty, as we can do nothing */
        if (ast_strlen_zero(device)) {
            continue;
        }
 
        for (i = 0; i < AST_VECTOR_SIZE(&state->device_state_sources); i++) {
            struct extension_state_device_source *existing_source = AST_VECTOR_GET(&state->device_state_sources, i);
 
            if (!strcmp(existing_source->info->device, device)) {
                source = existing_source;
                break;
            }
        }
        if (!source) {
            source = extension_state_device_source_alloc(state, device);
            if (!source) {
                ao2_unlock(state);
                return -1;
            }
            AST_VECTOR_APPEND(&state->device_state_sources, source);
        }
 
        ast_devstate_aggregate_add(&agg, source->info->state);
        source->version = version;
    }
 
    /* Do a pass and remove all old device sources */
    AST_VECTOR_REMOVE_ALL_CMP_UNORDERED(&state->device_state_sources, version,
        DEVICE_SOURCE_ELEM_VERSION_CMP, extension_state_device_source_destroy);
 
    /* If device state sources exist it is what produces the device state, otherwise we use the default */
    if (AST_VECTOR_SIZE(&state->device_state_sources)) {
        new_device_state = ast_devstate_to_extenstate(ast_devstate_aggregate_result(&agg));
    } else {
        new_device_state = AST_EXTENSION_UNAVAILABLE;
    }
 
    /* If the device state has changed, create a new snapshot */
    if (state->device_snapshot->state != new_device_state) {
        device_snapshot = extension_state_device_snapshot_create(new_device_state, &state->device_state_sources, NULL);
    }
    if (!device_snapshot) {
        /* If there's no new device snapshot we use the old one */
        device_snapshot = state->device_snapshot;
    }
 
    /* If the presence state has changed, create a new snapshot */
    if (strcmp(S_OR(state->presence_sources_string, ""), S_OR(presence_state_sources, ""))) {
        enum ast_presence_state presence_state = AST_PRESENCE_NOT_SET;
        char *presence_subtype = NULL, *presence_message = NULL;
 
        ast_free(state->presence_sources_string);
 
        if (!ast_strlen_zero(presence_state_sources)) {
            state->presence_sources_string = ast_strdup(presence_state_sources);
            /* Presence state is also separated by & but only the presence state API can handle it and aggregate */
            presence_state = ast_presence_state(presence_state_sources, &presence_subtype,
                &presence_message);
        } else {
            state->presence_sources_string = NULL;
        }
 
        presence_snapshot = extension_state_presence_snapshot_create(presence_state, presence_subtype, presence_message);
 
        ast_free(presence_subtype);
        ast_free(presence_message);
    }
    if (!presence_snapshot) {
        /* If there's no new presence snapshot we use the old one */
        presence_snapshot = state->presence_snapshot;
    }
 
    /* If any snapshots have changed create an update message containing them */
    if (state->device_snapshot != device_snapshot || state->presence_snapshot != presence_snapshot) {
        struct ast_extension_state_update_message *update_message;
 
        update_message = extension_state_update_message_create(state->dialplan_context, state->dialplan_extension, state->device_snapshot,
            device_snapshot, state->presence_snapshot, presence_snapshot);
        if (update_message) {
            struct stasis_message *message = stasis_message_create(ast_extension_state_update_message_type(), update_message);
 
            if (message) {
                stasis_publish(state->extension_state_topic, message);
                ao2_ref(message, -1);
            }
 
            ao2_ref(update_message, -1);
        }
 
        /* If applicable, update the snapshots on the state to their new version */
        if (state->device_snapshot != device_snapshot) {
            ao2_replace(state->device_snapshot, device_snapshot);
            ao2_ref(device_snapshot, -1);
        }
        if (state->presence_snapshot != presence_snapshot) {
            ao2_replace(state->presence_snapshot, presence_snapshot);
            ao2_ref(presence_snapshot, -1);
        }
    }
 
    ao2_unlock(state);
 
    return 0;
}

References ao2_lock, ao2_ref, ao2_replace, ao2_unlock, ast_devstate_aggregate_add(), ast_devstate_aggregate_init(), ast_devstate_aggregate_result(), ast_devstate_to_extenstate(), ast_extension_state_update_message_type(), AST_EXTENSION_UNAVAILABLE, ast_free, ast_get_extension_app(), AST_PRESENCE_NOT_SET, ast_random(), ast_str_buffer(), ast_str_set(), ast_str_thread_get(), ast_strdup, ast_strlen_zero(), AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_REMOVE_ALL_CMP_UNORDERED, AST_VECTOR_SIZE, ast_extension_state_device_state_info::device, DEVICE_SOURCE_ELEM_VERSION_CMP, extension_state_device_snapshot_create(), extension_state_device_source_alloc(), extension_state_device_source_destroy(), extension_state_presence_snapshot_create(), extension_state_update_message_create(), HINTDEVICE_DATA_LENGTH, extension_state_device_source::info, NULL, S_OR, stasis_message_create(), stasis_publish(), ast_extension_state_device_state_info::state, str, strsep(), version, and extension_state_device_source::version.

Referenced by pbx_extension_state_hint_set().

handle_show_hint()

static char * handle_show_hint ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1618 of file extension_state.c.

{
    struct extension_state *extstate;
    int num = 0, extenlen;
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show hint";
        e->usage =
            "Usage: core show hint <exten>\n"
            "       List registered hint.\n"
            "       Hint details are shown in five columns. In order from left to right, they are:\n"
            "       1. Hint extension URI.\n"
            "       2. List of mapped device or presence state identifiers.\n"
            "       3. Current extension state. The aggregate of mapped device states.\n"
            "       4. Current presence state for the mapped presence state provider.\n"
            "       5. Watchers - number of subscriptions and other entities watching this hint.\n";
        return NULL;
    case CLI_GENERATE:
        return complete_core_show_hint(a->line, a->word, a->pos, a->n);
    }
 
    if (a->argc < 4)
        return CLI_SHOWUSAGE;
 
    if (ao2_container_count(extension_states) == 0) {
        ast_cli(a->fd, "There are no registered dialplan hints\n");
        return CLI_SUCCESS;
    }
 
    extenlen = strlen(a->argv[3]);
    i = ao2_iterator_init(extension_states, 0);
    for (; (extstate = ao2_iterator_next(&i)); ao2_ref(extstate, -1)) {
        ao2_lock(extstate);
        if (!strncasecmp(extstate->extension, a->argv[3], extenlen)) {
            extension_state_device_snapshot_refresh(extstate);
            extension_state_presence_snapshot_refresh(extstate);
            ast_cli(a->fd, "%-30.30s: %-60.60s  State:%-15.15s Presence:%-15.15s Watchers %2zd\n",
                extstate->extension,
                extstate->hint_extension ? ast_get_extension_app(extstate->hint_extension) : "None",
                ast_extension_state2str(extstate->device_snapshot->state),
                ast_presence_state2str(extstate->presence_snapshot->presence_state),
                extstate->extension_state_topic ? stasis_topic_subscribers(extstate->extension_state_topic) : 0);
            num++;
        }
        ao2_unlock(extstate);
    }
    ao2_iterator_destroy(&i);
    if (!num)
        ast_cli(a->fd, "No hints matching extension %s\n", a->argv[3]);
    else
        ast_cli(a->fd, "%d hint%s matching extension %s\n", num, (num!=1 ? "s":""), a->argv[3]);
    return CLI_SUCCESS;
}

References a, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), ast_extension_state2str(), ast_get_extension_app(), ast_presence_state2str(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, complete_core_show_hint(), extension_state::device_snapshot, extension_state::extension, extension_state_device_snapshot_refresh(), extension_state_presence_snapshot_refresh(), extension_state::extension_state_topic, extension_states, extension_state::hint_extension, NULL, extension_state::presence_snapshot, ast_extension_state_presence_snapshot::presence_state, stasis_topic_subscribers(), ast_extension_state_device_snapshot::state, and ast_cli_entry::usage.

handle_show_hints()

static char * handle_show_hints ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 1515 of file extension_state.c.

{
    struct extension_state *state;
    int num = 0;
    struct ao2_iterator i;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "core show hints";
        e->usage =
            "Usage: core show hints\n"
            "       List registered hints.\n"
            "       Hint details are shown in five columns. In order from left to right, they are:\n"
            "       1. Hint extension URI.\n"
            "       2. List of mapped device or presence state identifiers.\n"
            "       3. Current extension state. The aggregate of mapped device states.\n"
            "       4. Current presence state for the mapped presence state provider.\n"
            "       5. Watchers - number of subscriptions and other entities watching this hint.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (ao2_container_count(extension_states) == 0) {
        ast_cli(a->fd, "There are no registered dialplan hints\n");
        return CLI_SUCCESS;
    }
    /* ... we have hints ... */
    ast_cli(a->fd, "\n    -= Registered Asterisk Dial Plan Hints =-\n");
 
    i = ao2_iterator_init(extension_states, 0);
    for (; (state = ao2_iterator_next(&i)); ao2_ref(state, -1)) {
        ao2_lock(state);
        extension_state_device_snapshot_refresh(state);
        extension_state_presence_snapshot_refresh(state);
        ast_cli(a->fd, "%-30.30s: %-60.60s  State:%-15.15s Presence:%-15.15s Watchers %2zd\n",
            state->extension,
            state->hint_extension ? ast_get_extension_app(state->hint_extension) : "None",
            ast_extension_state2str(state->device_snapshot->state),
            ast_presence_state2str(state->presence_snapshot->presence_state),
            state->extension_state_topic ? stasis_topic_subscribers(state->extension_state_topic) : 0);
        ao2_unlock(state);
 
        num++;
    }
    ao2_iterator_destroy(&i);
 
    ast_cli(a->fd, "----------------\n");
    ast_cli(a->fd, "- %d hints registered\n", num);
    return CLI_SUCCESS;
}

References a, ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli(), ast_extension_state2str(), ast_get_extension_app(), ast_presence_state2str(), CLI_GENERATE, CLI_INIT, CLI_SUCCESS, ast_cli_entry::command, extension_state_device_snapshot_refresh(), extension_state_presence_snapshot_refresh(), extension_states, NULL, stasis_topic_subscribers(), and ast_cli_entry::usage.

pbx_extension_state_hint_remove()

void pbx_extension_state_hint_remove	(	struct ast_exten *	exten,
		struct ast_context *	context
	)

Definition at line 1268 of file extension_state.c.

{
    char extension[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
    struct extension_state *state;
 
    snprintf(extension, sizeof(extension), "%s@%s", ast_get_extension_name(exten), ast_get_context_name(context));
 
    ao2_lock(extension_states);
 
    state = ao2_find(extension_states, extension, OBJ_SEARCH_KEY | OBJ_NOLOCK);
 
    /* If this is not the latest hint extension that configured this extension state it can't remove it */
    if (!state || state->hint_extension != exten) {
        ao2_unlock(extension_states);
        ao2_cleanup(state);
        return;
    }
 
    extension_state_shutdown(state);
    ao2_unlink_flags(extension_states, state, OBJ_NOLOCK);
    ao2_ref(state, -1);
 
    ao2_unlock(extension_states);
}

References ao2_cleanup, ao2_find, ao2_lock, ao2_ref, ao2_unlink_flags, ao2_unlock, ast_get_context_name(), ast_get_extension_name(), AST_MAX_CONTEXT, AST_MAX_EXTENSION, extension_state_shutdown(), extension_states, OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by ast_change_hint(), and ast_remove_hint().

pbx_extension_state_hint_set()

void pbx_extension_state_hint_set	(	struct ast_exten *	exten,
		struct ast_context *	context
	)

extension_state.c functions needed by pbx.c

Definition at line 1238 of file extension_state.c.

{
    char extension[AST_MAX_EXTENSION + AST_MAX_CONTEXT + 2];
    struct extension_state *state;
 
    snprintf(extension, sizeof(extension), "%s@%s", ast_get_extension_name(exten), ast_get_context_name(context));
 
    ao2_lock(extension_states);
 
    state = ao2_find(extension_states, extension, OBJ_SEARCH_KEY | OBJ_NOLOCK);
    if (!state) {
        state = extension_state_alloc(exten, context);
        if (!state) {
            ast_log(LOG_WARNING, "Could not create extension state for hint '%s', it will be unavailable\n",
                extension);
            ao2_unlock(extension_states);
            return;
        }
        ao2_link_flags(extension_states, state, OBJ_NOLOCK);
    }
 
    state->hint_extension = exten;
    if (extension[0] != '_') {
        extension_state_update_sources(state, exten);
    }
    ao2_ref(state, -1);
 
    ao2_unlock(extension_states);
}

References ao2_find, ao2_link_flags, ao2_lock, ao2_ref, ao2_unlock, ast_get_context_name(), ast_get_extension_name(), ast_log, AST_MAX_CONTEXT, AST_MAX_EXTENSION, extension_state_alloc(), extension_state_update_sources(), extension_states, LOG_WARNING, OBJ_NOLOCK, and OBJ_SEARCH_KEY.

Referenced by ast_add_hint(), ast_change_hint(), and context_promote().

STASIS_MESSAGE_TYPE_DEFN() [1/2]

STASIS_MESSAGE_TYPE_DEFN

(

ast_extension_state_remove_message_type

)

Stasis message type for extension state remove messages.

STASIS_MESSAGE_TYPE_DEFN() [2/2]

STASIS_MESSAGE_TYPE_DEFN

(

ast_extension_state_update_message_type

)

Sort function for extension states.

Compare function for extension states

Message type for extension state updates

Variable Documentation

extension_state_cli

struct ast_cli_entry extension_state_cli[]

static

Initial value:

= {
    { .handler =  handle_show_hints , .summary =  "Show dialplan hints" ,},
    { .handler =  handle_show_hint , .summary =  "Show dialplan hint" ,},
}

Definition at line 1674 of file extension_state.c.

                                                    {
    AST_CLI_DEFINE(handle_show_hints, "Show dialplan hints"),
    AST_CLI_DEFINE(handle_show_hint, "Show dialplan hint"),
};

Referenced by ast_extension_state_init(), and extension_state_cleanup().

extension_state_mappings

const struct cfextension_states extension_state_mappings[]

static

Referenced by ast_extension_state2str().

extension_state_topic_all

struct stasis_topic* extension_state_topic_all

static

Topic which receives all extension state updates.

Definition at line 146 of file extension_state.c.

Referenced by ast_extension_state_init(), ast_extension_state_topic_all(), and extension_state_alloc().

extension_states

struct ao2_container* extension_states

static

The global container of extension states.

Definition at line 143 of file extension_state.c.

Referenced by action_extensionstatelist(), ast_extension_state_init(), complete_core_show_hint(), extension_state_cleanup(), extension_state_get(), extension_state_presence_state_cb(), handle_show_hint(), handle_show_hints(), pbx_extension_state_hint_remove(), and pbx_extension_state_hint_set().

presence_state_sub

struct stasis_subscription* presence_state_sub

static

Single presence state subscription, for all extension states.

Definition at line 149 of file extension_state.c.

Referenced by ast_extension_state_init(), and extension_state_cleanup().