extension_state_legacy.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/lock.h"
#include "asterisk/vector.h"

Include dependency graph for extension_state_legacy.c:

Go to the source code of this file.

Data Structures
struct	extension_state_legacy_state_cb

Functions
int	ast_extension_state (struct ast_channel *c, const char *context, const char *exten)
	Uses hint and devicestate callback to get the state of an extension.
int	ast_extension_state_add (const char *context, const char *exten, ast_state_cb_type change_cb, void *data)
	Add watcher for extension states.
int	ast_extension_state_add_destroy (const char *context, const char *exten, ast_state_cb_type change_cb, ast_state_cb_destroy_type destroy_cb, void *data)
	Add watcher for extension states with destructor.
int	ast_extension_state_add_destroy_extended (const char *context, const char *exten, ast_state_cb_type change_cb, ast_state_cb_destroy_type destroy_cb, void *data)
	Add watcher for extended extension states with destructor.
int	ast_extension_state_add_extended (const char *context, const char *exten, ast_state_cb_type change_cb, void *data)
	Add watcher for extended extension states.
int	ast_extension_state_del (int id, ast_state_cb_type change_cb)
	Deletes a state change watcher by ID.
int	ast_extension_state_extended (struct ast_channel *c, const char *context, const char *exten, struct ao2_container **device_state_info)
	Uses hint and devicestate callback to get the extended state of an extension.
int	ast_extension_state_legacy_init (void)
int	ast_hint_presence_state (struct ast_channel *c, const char *context, const char *exten, char **subtype, char **message)
	Uses hint and presence state callback to get the presence state of an extension.
static void	device_state_info_destroy (void *obj)
static int	extension_state_legacy_add_destroy (const char *context, const char *exten, ast_state_cb_type change_cb, ast_state_cb_destroy_type destroy_cb, void *data, int extended)
static void	extension_state_legacy_cleanup (void)
static struct ao2_container *	extension_state_legacy_create_device_state_info (struct ast_extension_state_device_snapshot *device_snapshot)
static void	extension_state_legacy_remove_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	extension_state_legacy_state_cb_destroy (void *obj)
static void	extension_state_legacy_subscription_change_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)
static void	extension_state_legacy_update_cb (void *userdata, struct stasis_subscription *sub, struct stasis_message *msg)

Variables
struct {
size_t   current
struct extension_state_legacy_state_cb **   elems
size_t   max
}	extension_state_legacy_callbacks
	Legacy callbacks, the index of it in the vector is the id given to the API user for per-extension.
static ast_mutex_t	extension_state_legacy_callbacks_lock = AST_MUTEX_INIT_VALUE
	Lock to protect the callbacks vector.

Function Documentation

ast_extension_state()

int ast_extension_state	(	struct ast_channel *	c,
		const char *	context,
		const char *	exten
	)

Uses hint and devicestate callback to get the state of an extension.

Parameters

c	this is not important
context	which context to look in
exten	which extension to get state

Returns

extension state as defined in the ast_extension_states enum

Definition at line 55 of file extension_state_legacy.c.

{
    struct ast_extension_state_device_snapshot *device_snapshot;
    enum ast_extension_states device_state;
 
    device_snapshot = ast_extension_state_get_latest_device_snapshot(c, exten, context);
    if (!device_snapshot) {
        return -1;
    }
 
    device_state = device_snapshot->state;
    ao2_ref(device_snapshot, -1);
 
    return device_state;
}

References ao2_ref, ast_extension_state_get_latest_device_snapshot(), c, and ast_extension_state_device_snapshot::state.

Referenced by action_extensionstate(), extstate_read(), and get_queue_member_status().

ast_extension_state_add()

int ast_extension_state_add	(	const char *	context,
		const char *	exten,
		ast_state_cb_type	change_cb,
		void *	data
	)

Add watcher for extension states.

Parameters

context	which context to look in
exten	which extension to get state
change_cb	callback to call if state changed
data	to pass to callback

Note

If context and exten are NULL then the added watcher is global. The change_cb is called for every extension's state change.

The change_cb is called if the state of an extension is changed.

Return values

-1	on failure
0	Global watcher added successfully
ID	on success

Definition at line 375 of file extension_state_legacy.c.

{
    return extension_state_legacy_add_destroy(context, exten, change_cb, NULL, data, 0);
}

References extension_state_legacy_add_destroy(), and NULL.

Referenced by __init_manager(), create_queue_member(), and publisher_start().

ast_extension_state_add_destroy()

int ast_extension_state_add_destroy	(	const char *	context,
		const char *	exten,
		ast_state_cb_type	change_cb,
		ast_state_cb_destroy_type	destroy_cb,
		void *	data
	)

Add watcher for extension states with destructor.

Since

1.8.9

10.1.0

Parameters

context	which context to look in
exten	which extension to get state
change_cb	callback to call if state changed
destroy_cb	callback to call when the watcher is destroyed.
data	to pass to callbacks

Note

If context and exten are NULL then the added watcher is global. The change_cb is called for every extension's state change.

The change_cb is called if the state of an extension is changed.

The destroy_cb is called when the watcher is deleted so the watcher can release any associated resources.

Return values

-1	on failure
0	Global watcher added successfully
ID	on success

Definition at line 369 of file extension_state_legacy.c.

{
    return extension_state_legacy_add_destroy(context, exten, change_cb, destroy_cb, data, 0);
}

References extension_state_legacy_add_destroy().

ast_extension_state_add_destroy_extended()

int ast_extension_state_add_destroy_extended	(	const char *	context,
		const char *	exten,
		ast_state_cb_type	change_cb,
		ast_state_cb_destroy_type	destroy_cb,
		void *	data
	)

Add watcher for extended extension states with destructor.

Since

11

Parameters

context	which context to look in
exten	which extension to get state
change_cb	callback to call if state changed
destroy_cb	callback to call when the watcher is destroyed.
data	to pass to callbacks

Note

If context and exten are NULL then the added watcher is global. The change_cb is called for every extension's state change.

The change_cb is called if the state of an extension is changed. The extended state is passed to the callback in the device_state_info member of ast_state_cb_info.

The destroy_cb is called when the watcher is deleted so the watcher can release any associated resources.

Return values

-1	on failure
0	Global watcher added successfully
ID	on success

Definition at line 381 of file extension_state_legacy.c.

{
    return extension_state_legacy_add_destroy(context, exten, change_cb, destroy_cb, data, 1);
}

References extension_state_legacy_add_destroy().

Referenced by subscription_established().

ast_extension_state_add_extended()

int ast_extension_state_add_extended	(	const char *	context,
		const char *	exten,
		ast_state_cb_type	change_cb,
		void *	data
	)

Add watcher for extended extension states.

Since

11

Parameters

context	which context to look in
exten	which extension to get state
change_cb	callback to call if state changed
data	to pass to callback

Note

If context and exten are NULL then the added watcher is global. The change_cb is called for every extension's state change.

The change_cb is called if the state of an extension is changed. The extended state is passed to the callback in the device_state_info member of ast_state_cb_info.

Return values

-1	on failure
0	Global watcher added successfully
ID	on success

Definition at line 387 of file extension_state_legacy.c.

{
    return extension_state_legacy_add_destroy(context, exten, change_cb, NULL, data, 1);
}

References extension_state_legacy_add_destroy(), and NULL.

ast_extension_state_del()

int ast_extension_state_del	(	int	id,
		ast_state_cb_type	change_cb
	)

Deletes a state change watcher by ID.

Parameters

id	of the state watcher to delete (0 for global watcher)
change_cb	callback to call if state changed (Used if id == 0 (global))

Return values

0	success
-1	failure

Definition at line 393 of file extension_state_legacy.c.

{
    struct extension_state_legacy_state_cb *cb;
 
    /* A negative id is considered invalid */
    if (id < 0) {
        return -1;
    }
 
    if (!id) {  /* id == 0 is a callback without extension */
        if (!change_cb) {
            return -1;
        }
 
        /*
         * Global callbacks all have the ID of 0 so we need to find the actual index
         * for them in the vector for removal based on callback.
         */
        ast_mutex_lock(&extension_state_legacy_callbacks_lock);
        for (id = 0; id < AST_VECTOR_SIZE(&extension_state_legacy_callbacks); id++) {
            cb = AST_VECTOR_GET(&extension_state_legacy_callbacks, id);
            if (cb && cb->change_cb == change_cb) {
                AST_VECTOR_REPLACE(&extension_state_legacy_callbacks, id, NULL);
                ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
                stasis_message_router_unsubscribe(cb->router);
                ao2_ref(cb, -1);
                return 0;
            }
        }
        ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
 
        return -1;
    }
 
    ast_mutex_lock(&extension_state_legacy_callbacks_lock);
    if (id <= AST_VECTOR_SIZE(&extension_state_legacy_callbacks)) {
        cb = AST_VECTOR_GET(&extension_state_legacy_callbacks, id - 1);
        if (cb) {
            AST_VECTOR_REPLACE(&extension_state_legacy_callbacks, id - 1, NULL);
            ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
            stasis_message_router_unsubscribe(cb->router);
            ao2_ref(cb, -1);
            return 0;
        }
    }
    ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
 
    return -1;
}

References ao2_ref, ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, extension_state_legacy_state_cb::change_cb, extension_state_legacy_callbacks, extension_state_legacy_callbacks_lock, NULL, extension_state_legacy_state_cb::router, and stasis_message_router_unsubscribe().

Referenced by destroy_queue_member_cb(), subscription_shutdown(), and unload_module().

ast_extension_state_extended()

int ast_extension_state_extended	(	struct ast_channel *	c,
		const char *	context,
		const char *	exten,
		struct ao2_container **	device_state_info
	)

Uses hint and devicestate callback to get the extended state of an extension.

Since

11

Parameters

	c	this is not important
	context	which context to look in
	exten	which extension to get state
[out]	device_state_info	ptr to an ao2_container with extended state info, must be unref'd after use.

Returns

extension state as defined in the ast_extension_states enum

Definition at line 143 of file extension_state_legacy.c.

{
    struct ast_extension_state_device_snapshot *device_snapshot;
    enum ast_extension_states device_state;
 
    device_snapshot = ast_extension_state_get_latest_device_snapshot(c, exten, context);
    if (!device_snapshot) {
        return -1;
    }
 
    device_state = device_snapshot->state;
 
    /* The caller wants device state info, so allocate a container and populate it */
    if (device_state_info) {
        *device_state_info = extension_state_legacy_create_device_state_info(device_snapshot);
    }
 
    ao2_ref(device_snapshot, -1);
 
    return device_state;
}

References ao2_ref, ast_extension_state_get_latest_device_snapshot(), c, extension_state_legacy_create_device_state_info(), and ast_extension_state_device_snapshot::state.

Referenced by exten_state_data_alloc().

ast_extension_state_legacy_init()

int ast_extension_state_legacy_init

(

void

)

Provided by extension_state_legacy.c

Definition at line 470 of file extension_state_legacy.c.

{
    /* Since we're not pre-allocating for any callbacks this can't fail */
    AST_VECTOR_INIT(&extension_state_legacy_callbacks, 0);
    ast_register_cleanup(extension_state_legacy_cleanup);
 
    return 0;
}

References ast_register_cleanup(), AST_VECTOR_INIT, extension_state_legacy_callbacks, and extension_state_legacy_cleanup().

Referenced by asterisk_daemon().

ast_hint_presence_state()

int ast_hint_presence_state	(	struct ast_channel *	c,
		const char *	context,
		const char *	exten,
		char **	subtype,
		char **	message
	)

Uses hint and presence state callback to get the presence state of an extension.

Parameters

	c	this is not important
	context	which context to look in
	exten	which extension to get state
[out]	subtype	Further information regarding the presence returned
[out]	message	Custom message further describing current presence

Note

The subtype and message are dynamically allocated and must be freed by the caller of this function.

Returns

returns the presence state value.

Definition at line 71 of file extension_state_legacy.c.

{
    struct ast_extension_state_presence_snapshot *presence_snapshot;
    enum ast_presence_state presence_state;
 
    presence_snapshot = ast_extension_state_get_latest_presence_snapshot(c, exten, context);
    if (!presence_snapshot) {
        return -1;
    }
 
    presence_state = presence_snapshot->presence_state;
    if (presence_snapshot->presence_subtype) {
        *subtype = ast_strdup(presence_snapshot->presence_subtype);
    }
    if (presence_snapshot->presence_message) {
        *message = ast_strdup(presence_snapshot->presence_message);
    }
 
    ao2_ref(presence_snapshot, -1);
 
    return presence_state;
}

References ao2_ref, ast_extension_state_get_latest_presence_snapshot(), ast_strdup, c, ast_extension_state_presence_snapshot::presence_message, ast_extension_state_presence_snapshot::presence_state, and ast_extension_state_presence_snapshot::presence_subtype.

Referenced by exten_state_data_alloc().

device_state_info_destroy()

static void device_state_info_destroy ( void *  obj )

static

Definition at line 100 of file extension_state_legacy.c.

{
    struct ast_device_state_info *info = obj;
 
    ao2_cleanup(info->causing_channel);
}

References ao2_cleanup.

Referenced by extension_state_legacy_create_device_state_info().

extension_state_legacy_add_destroy()

static int extension_state_legacy_add_destroy ( const char *  context, const char *  exten, ast_state_cb_type  change_cb, ast_state_cb_destroy_type  destroy_cb, void *  data, int  extended  )

static

Definition at line 271 of file extension_state_legacy.c.

{
    struct extension_state_legacy_state_cb *state_cb;
    int id;
 
    state_cb = ao2_alloc_options(sizeof(*state_cb), extension_state_legacy_state_cb_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!state_cb) {
        return -1;
    }
 
    state_cb->change_cb = change_cb;
    state_cb->destroy_cb = destroy_cb;
    state_cb->data = data;
    state_cb->extended = extended;
 
    ast_mutex_lock(&extension_state_legacy_callbacks_lock);
 
    /*
     * Callbacks for both per-extension and all are stored in a single vector which may have gaps in it.
     * When adding a new callback, we look for the first gap in the vector and insert the callback there.
     * If there are no gaps, we append it to the end of the vector.
     * For per-extension the ID of a callback is its index in the vector + 1, since 0 is reserved for "all" callbacks.
     */
    for (id = 0; id < AST_VECTOR_SIZE(&extension_state_legacy_callbacks); id++) {
        if (AST_VECTOR_GET(&extension_state_legacy_callbacks, id)) {
            continue;
        }
 
        state_cb->id = id + 1;
 
        /* This can't fail since the vector would have already resized */
        AST_VECTOR_REPLACE(&extension_state_legacy_callbacks, id, state_cb);
 
        break;
    }
 
    if (!state_cb->id) {
        /* The vector will resize when we append, which can fail, so handle it */
        if (AST_VECTOR_APPEND(&extension_state_legacy_callbacks, state_cb)) {
            ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
            ao2_ref(state_cb, -1);
            return -1;
        }
        state_cb->id = AST_VECTOR_SIZE(&extension_state_legacy_callbacks);
    }
 
    /* At this point it is guaranteed that the callback has been inserted so we can setup
     * the message router to accept messages from the appropriate topic and translate into
     * the legacy callback.
     */
    if (!context && !exten) {
        /*
         * The all topic will receive all extension state updates which can end up being quite
         * a lot, so we use a dedicated thread for each legacy callback to ensure that the
         * pool of stasis threads does not become overloaded.
         */
        state_cb->router = stasis_message_router_create(ast_extension_state_topic_all());
    } else {
        struct stasis_topic *topic = ast_extension_state_topic(exten, context);
 
        /*
         * Per-extension on the other hand will have comparatively few extension state updates
         * so we use the pool for it instead. Additionally the creation of the message router will
         * fail if topic is NULL, so we don't do an explicit check and just let it try.
         */
        state_cb->router = stasis_message_router_create_pool(topic);
        ao2_cleanup(topic);
    }
 
    /* If there is no message router allocated this callback is useless, so bail */
    if (!state_cb->router) {
        AST_VECTOR_REPLACE(&extension_state_legacy_callbacks, state_cb->id - 1, NULL);
        ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
        ao2_ref(state_cb, -1);
        return -1;
    }
 
    /*
     * Each of the message router callbacks translates the extension state messages into
     * the legacy callback format and then calls the legacy callback with the appropriate data.
     */
    stasis_message_router_add(state_cb->router, stasis_subscription_change_type(),
            extension_state_legacy_subscription_change_cb, ao2_bump(state_cb));
    stasis_message_router_add(state_cb->router, ast_extension_state_update_message_type(),
            extension_state_legacy_update_cb, state_cb);
    stasis_message_router_add(state_cb->router, ast_extension_state_remove_message_type(),
            extension_state_legacy_remove_cb, state_cb);
 
    ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
 
    /*
     * We don't hold a reference directly but the vector does and since we haven't given the ID back
     * there's no way for the caller to remove it, thus it has to be valid even now.
     */
    return (!context && !exten) ? 0 : state_cb->id;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_bump, ao2_cleanup, ao2_ref, ast_extension_state_remove_message_type(), ast_extension_state_topic(), ast_extension_state_topic_all(), ast_extension_state_update_message_type(), ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_APPEND, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, extension_state_legacy_state_cb::change_cb, extension_state_legacy_state_cb::data, extension_state_legacy_state_cb::destroy_cb, extension_state_legacy_state_cb::extended, extension_state_legacy_callbacks, extension_state_legacy_callbacks_lock, extension_state_legacy_remove_cb(), extension_state_legacy_state_cb_destroy(), extension_state_legacy_subscription_change_cb(), extension_state_legacy_update_cb(), id, extension_state_legacy_state_cb::id, NULL, extension_state_legacy_state_cb::router, stasis_message_router_add(), stasis_message_router_create, stasis_message_router_create_pool, and stasis_subscription_change_type().

Referenced by ast_extension_state_add(), ast_extension_state_add_destroy(), ast_extension_state_add_destroy_extended(), and ast_extension_state_add_extended().

extension_state_legacy_cleanup()

static void extension_state_legacy_cleanup ( void  )

static

Definition at line 450 of file extension_state_legacy.c.

{
    int i;
 
    ast_mutex_lock(&extension_state_legacy_callbacks_lock);
    for (i = 0; i < AST_VECTOR_SIZE(&extension_state_legacy_callbacks); i++) {
        struct extension_state_legacy_state_cb *cb = AST_VECTOR_GET(&extension_state_legacy_callbacks, i);
 
        if (!cb) {
            continue;
        }
 
        AST_VECTOR_REPLACE(&extension_state_legacy_callbacks, i, NULL);
        stasis_message_router_unsubscribe_and_join(cb->router);
        ao2_ref(cb, -1);
    }
    ast_mutex_unlock(&extension_state_legacy_callbacks_lock);
    AST_VECTOR_FREE(&extension_state_legacy_callbacks);
}

References ao2_ref, ast_mutex_lock, ast_mutex_unlock, AST_VECTOR_FREE, AST_VECTOR_GET, AST_VECTOR_REPLACE, AST_VECTOR_SIZE, extension_state_legacy_callbacks, extension_state_legacy_callbacks_lock, NULL, extension_state_legacy_state_cb::router, and stasis_message_router_unsubscribe_and_join().

Referenced by ast_extension_state_legacy_init().

extension_state_legacy_create_device_state_info()

static struct ao2_container * extension_state_legacy_create_device_state_info ( struct ast_extension_state_device_snapshot *  device_snapshot )

static

Definition at line 114 of file extension_state_legacy.c.

{
    struct ao2_container *device_state_info = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_NOLOCK, 0, NULL, NULL);
    int i;
 
    if (!device_state_info) {
        return NULL;
    }
 
    for (i = 0; i < AST_VECTOR_SIZE(&device_snapshot->additional_devices); i++) {
        struct ast_extension_state_device_state_info *source_info = AST_VECTOR_GET(&device_snapshot->additional_devices, i);
        struct ast_device_state_info *obj;
 
        obj = ao2_alloc_options(sizeof(*obj) + strlen(source_info->device) + 1, device_state_info_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
        if (!obj) {
            ao2_ref(device_state_info, -1);
            return NULL;
        }
 
        obj->device_state = source_info->state;
        strcpy(obj->device_name, source_info->device); /* Safe */
        obj->causing_channel = ast_extension_state_get_device_causing_channel(source_info->device, source_info->state);
        ao2_link(device_state_info, obj);
        ao2_ref(obj, -1);
    }
 
    return device_state_info;
}

References ast_extension_state_device_snapshot::additional_devices, AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_container_alloc_list, ao2_link, ao2_ref, ast_extension_state_get_device_causing_channel(), AST_VECTOR_GET, AST_VECTOR_SIZE, ast_device_state_info::causing_channel, ast_extension_state_device_state_info::device, ast_device_state_info::device_name, ast_device_state_info::device_state, device_state_info_destroy(), NULL, and ast_extension_state_device_state_info::state.

Referenced by ast_extension_state_extended(), and extension_state_legacy_update_cb().

extension_state_legacy_remove_cb()

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

static

Definition at line 246 of file extension_state_legacy.c.

{
    struct extension_state_legacy_state_cb *cb = userdata;
    struct ast_extension_state_remove_message *remove_message = stasis_message_data(msg);
    struct ast_state_cb_info info = {
        .reason = AST_HINT_UPDATE_DEVICE,
        .exten_state = AST_EXTENSION_REMOVED,
    };
 
    cb->change_cb(remove_message->context, remove_message->extension, &info, cb->data);
}

References AST_EXTENSION_REMOVED, AST_HINT_UPDATE_DEVICE, extension_state_legacy_state_cb::change_cb, ast_extension_state_remove_message::context, extension_state_legacy_state_cb::data, ast_extension_state_remove_message::extension, and stasis_message_data().

Referenced by extension_state_legacy_add_destroy().

extension_state_legacy_state_cb_destroy()

static void extension_state_legacy_state_cb_destroy ( void *  obj )

static

Definition at line 188 of file extension_state_legacy.c.

{
    struct extension_state_legacy_state_cb *cb = obj;
 
    if (cb->destroy_cb) {
        cb->destroy_cb(cb->id, cb->data);
    }
}

References extension_state_legacy_state_cb::data, extension_state_legacy_state_cb::destroy_cb, and extension_state_legacy_state_cb::id.

Referenced by extension_state_legacy_add_destroy().

extension_state_legacy_subscription_change_cb()

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

static

Definition at line 174 of file extension_state_legacy.c.

{
    if (stasis_subscription_final_message(sub, msg)) {
        ao2_cleanup(userdata);
    }
}

References ao2_cleanup, stasis_subscription_final_message(), and sub.

Referenced by extension_state_legacy_add_destroy().

extension_state_legacy_update_cb()

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

static

Definition at line 205 of file extension_state_legacy.c.

{
    struct extension_state_legacy_state_cb *cb = userdata;
    struct ast_extension_state_update_message *update_message = stasis_message_data(msg);
    struct ast_state_cb_info info = {
        .exten_state = update_message->new_device_snapshot->state,
        .presence_state = update_message->new_presence_snapshot->presence_state,
        .presence_subtype = S_OR(update_message->new_presence_snapshot->presence_subtype, ""),
        .presence_message = S_OR(update_message->new_presence_snapshot->presence_message, ""),
    };
 
    /* If the presence has changed, notify the callback */
    if (update_message->new_presence_snapshot != update_message->old_presence_snapshot) {
        info.reason = AST_HINT_UPDATE_PRESENCE;
        cb->change_cb(update_message->context, update_message->extension, &info, cb->data);
    }
 
    /* If the device state has changed, notify the callback */
    if (update_message->new_device_snapshot != update_message->old_device_snapshot) {
        info.reason = AST_HINT_UPDATE_DEVICE;
 
        /* If they want extended information we need to provide the channels */
        if (cb->extended) {
            info.device_state_info = extension_state_legacy_create_device_state_info(update_message->new_device_snapshot);
        }
 
        cb->change_cb(update_message->context, update_message->extension, &info, cb->data);
 
        ao2_cleanup(info.device_state_info);
    }
}

References ao2_cleanup, AST_HINT_UPDATE_DEVICE, AST_HINT_UPDATE_PRESENCE, extension_state_legacy_state_cb::change_cb, ast_extension_state_update_message::context, extension_state_legacy_state_cb::data, extension_state_legacy_state_cb::extended, ast_extension_state_update_message::extension, extension_state_legacy_create_device_state_info(), ast_extension_state_update_message::new_device_snapshot, ast_extension_state_update_message::new_presence_snapshot, ast_extension_state_update_message::old_device_snapshot, ast_extension_state_update_message::old_presence_snapshot, ast_extension_state_presence_snapshot::presence_message, ast_extension_state_presence_snapshot::presence_state, ast_extension_state_presence_snapshot::presence_subtype, S_OR, stasis_message_data(), and ast_extension_state_device_snapshot::state.

Referenced by extension_state_legacy_add_destroy().

Variable Documentation

current

size_t current

Definition at line 53 of file extension_state_legacy.c.

elems

struct extension_state_legacy_state_cb* * elems

Definition at line 53 of file extension_state_legacy.c.

[struct]

struct { ... } extension_state_legacy_callbacks

Legacy callbacks, the index of it in the vector is the id given to the API user for per-extension.

Referenced by ast_extension_state_del(), ast_extension_state_legacy_init(), extension_state_legacy_add_destroy(), and extension_state_legacy_cleanup().

extension_state_legacy_callbacks_lock

ast_mutex_t extension_state_legacy_callbacks_lock = AST_MUTEX_INIT_VALUE

static

Lock to protect the callbacks vector.

Definition at line 50 of file extension_state_legacy.c.

Referenced by ast_extension_state_del(), extension_state_legacy_add_destroy(), and extension_state_legacy_cleanup().

max

size_t max

Definition at line 53 of file extension_state_legacy.c.