devicestate.c File Reference

Device state management. More...

#include "asterisk.h"
#include "asterisk/_private.h"
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/devicestate.h"
#include "asterisk/pbx.h"
#include "asterisk/app.h"
#include "asterisk/astobj2.h"
#include "asterisk/stasis.h"

Include dependency graph for devicestate.c:

Go to the source code of this file.

Data Structures
struct	chan2dev
	Mapping for channel states to device states. More...
struct	devstate_prov
	A device state provider (not a channel) More...
struct	devstate_provs
	A list of providers. More...
struct	state_change
struct	state_changes
	The state change queue. State changes are queued for processing by a separate thread. More...

Macros
#define	DEVSTATE_TOPIC_BUCKETS   57

Functions
static enum ast_device_state	_ast_device_state (const char *device, int check_cache)
	Check device state through channel specific function or generic function. More...
enum ast_device_state	ast_device_state (const char *device)
	Asks a channel for device state. More...
struct stasis_cache *	ast_device_state_cache (void)
	Backend cache for ast_device_state_topic_cached() More...
int	ast_device_state_clear_cache (const char *device)
	Clear the device from the stasis cache. More...
int	ast_device_state_engine_init (void)
	Initialize the device state engine in separate thread. More...
struct stasis_topic *	ast_device_state_topic (const char *device)
	Get the Stasis topic for device state messages for a specific device. More...
struct stasis_topic *	ast_device_state_topic_all (void)
	Get the Stasis topic for device state messages. More...
struct stasis_topic *	ast_device_state_topic_cached (void)
	Get the Stasis caching topic for device state messages. More...
const char *	ast_devstate2str (enum ast_device_state devstate)
	Find devicestate as text message for output. More...
void	ast_devstate_aggregate_add (struct ast_devstate_aggregate *agg, enum ast_device_state state)
	Add a device state to the aggregate device state. More...
void	ast_devstate_aggregate_init (struct ast_devstate_aggregate *agg)
	Initialize aggregate device state. More...
enum ast_device_state	ast_devstate_aggregate_result (struct ast_devstate_aggregate *agg)
	Get the aggregate device state result. More...
int	ast_devstate_changed (enum ast_device_state state, enum ast_devstate_cache cachable, const char *fmt,...)
	Tells Asterisk the State for Device is changed. More...
int	ast_devstate_changed_literal (enum ast_device_state state, enum ast_devstate_cache cachable, const char *device)
	Tells Asterisk the State for Device is changed. More...
int	ast_devstate_prov_add (const char *label, ast_devstate_prov_cb_type callback)
	Add device state provider. More...
int	ast_devstate_prov_del (const char *label)
	Remove device state provider. More...
const char *	ast_devstate_str (enum ast_device_state state)
	Convert device state to text string that is easier to parse. More...
enum ast_device_state	ast_devstate_val (const char *val)
	Convert device state from text to integer value. More...
enum ast_device_state	ast_parse_device_state (const char *device)
	Find out if device is active in a call or not. More...
int	ast_publish_device_state_full (const char *device, enum ast_device_state state, enum ast_devstate_cache cachable, struct ast_eid *eid)
	Publish a device state update with EID. More...
enum ast_device_state	ast_state_chan2dev (enum ast_channel_state chanstate)
	Convert channel state to devicestate. More...
static struct stasis_message *	device_state_aggregate_calc (struct stasis_cache_entry *entry, struct stasis_message *new_snapshot)
static void	device_state_aggregate_publish (struct stasis_topic *cache_topic, struct stasis_message *aggregate)
static struct ast_device_state_message *	device_state_alloc (const char *device, enum ast_device_state state, enum ast_devstate_cache cachable, const struct ast_eid *eid)
static void	device_state_engine_cleanup (void)
static const char *	device_state_get_id (struct stasis_message *message)
static enum ast_device_state	devstate_cached (const char *device)
static void	devstate_change_cb (void *data, struct stasis_subscription *sub, struct stasis_message *msg)
static void	devstate_cleanup (void)
int	devstate_init (void)
	Initialize the device state core. More...
static struct ast_manager_event_blob *	devstate_to_ami (struct stasis_message *msg)
static struct ast_event *	devstate_to_event (struct stasis_message *message)
	Convert a stasis_message to a ast_event. More...
static void *	do_devstate_changes (void *data)
	Go through the dev state change queue and update changes in the dev state thread. More...
static void	do_state_change (const char *device, enum ast_devstate_cache cachable)
static int	getproviderstate (const char *provider, const char *address)
	Get provider device state. More...
	STASIS_MESSAGE_TYPE_DEFN (ast_device_state_message_type,.to_ami=devstate_to_ami,.to_event=devstate_to_event,)

Variables
static const struct chan2dev	chan2dev []
static ast_cond_t	change_pending
	Flag for the queue. More...
static pthread_t	change_thread = AST_PTHREADT_NULL
	The device state change notification thread. More...
static struct stasis_cache *	device_state_cache
static struct stasis_topic *	device_state_topic_all
static struct stasis_caching_topic *	device_state_topic_cached
static struct stasis_topic_pool *	device_state_topic_pool
struct stasis_subscription *	devstate_message_sub
static struct devstate_provs	devstate_provs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static const char *const	devstatestring [][2]
	Device state strings for printing. More...
static volatile int	shuttingdown
static struct state_changes	state_changes = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

Detailed Description

Device state management.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Russell Bryant russe.nosp@m.ll@d.nosp@m.igium.nosp@m..com

• Extension and device states in Asterisk

Definition in file devicestate.c.

Macro Definition Documentation

DEVSTATE_TOPIC_BUCKETS

#define DEVSTATE_TOPIC_BUCKETS   57

Definition at line 158 of file devicestate.c.

Function Documentation

_ast_device_state()

static enum ast_device_state _ast_device_state ( const char *  device, int  check_cache  )

static

Check device state through channel specific function or generic function.

Channel driver that provides device state

Another provider of device state

Definition at line 328 of file devicestate.c.

{
    char *number;
    const struct ast_channel_tech *chan_tech;
    enum ast_device_state res;
    /*! \brief Channel driver that provides device state */
    char *tech;
 
    /* If the last known state is cached, just return that */
    if (check_cache) {
        res = devstate_cached(device);
        if (res != AST_DEVICE_UNKNOWN) {
            return res;
        }
    }
 
    number = ast_strdupa(device);
    tech = strsep(&number, "/");
    if (!number) {
        /*! \brief Another provider of device state */
        char *provider;
 
        provider = strsep(&tech, ":");
        if (!tech) {
            return AST_DEVICE_INVALID;
        }
        /* We have a provider */
        number = tech;
 
        ast_debug(3, "Checking if I can find provider for \"%s\" - number: %s\n", provider, number);
        return getproviderstate(provider, number);
    }
 
    ast_debug(4, "No provider found, checking channel drivers for %s - %s\n", tech, number);
 
    chan_tech = ast_get_channel_tech(tech);
    if (!chan_tech) {
        return AST_DEVICE_INVALID;
    }
 
    /* Does the channel driver support device state notification? */
    if (!chan_tech->devicestate) {
        /* No, try the generic function */
        return ast_parse_device_state(device);
    }
 
    res = chan_tech->devicestate(number);
    if (res == AST_DEVICE_UNKNOWN) {
        res = ast_parse_device_state(device);
    }
 
    return res;
}

References ast_debug, AST_DEVICE_INVALID, AST_DEVICE_UNKNOWN, ast_get_channel_tech(), ast_parse_device_state(), ast_strdupa, ast_channel_tech::devicestate, devstate_cached(), getproviderstate(), provider, and strsep().

Referenced by ast_device_state(), and do_state_change().

ast_device_state()

enum ast_device_state ast_device_state

(

const char *

device

)

Asks a channel for device state.

Parameters

device

like a dial string

Asks a channel for device state, data is normally a number from a dial string used by the low level module Tries the channel device state callback if not supported search in the active channels list for the device.

Returns

an AST_DEVICE_??? state

Definition at line 382 of file devicestate.c.

{
    /* This function is called from elsewhere in the code to find out the
     * current state of a device.  Check the cache, first. */
 
    return _ast_device_state(device, 1);
}

References _ast_device_state().

ast_device_state_cache()

struct stasis_cache * ast_device_state_cache

(

void

)

Backend cache for ast_device_state_topic_cached()

Returns

Cache of ast_device_state_message.

Since

12

Definition at line 673 of file devicestate.c.

{
    return device_state_cache;
}

References device_state_cache.

Referenced by action_devicestatelist(), ast_device_state_clear_cache(), AST_TEST_DEFINE(), asterisk_publication_devicestate_refresh(), asterisk_start_devicestate_publishing(), cache_cleanup(), devstate_cached(), and xmpp_init_event_distribution().

ast_device_state_clear_cache()

int ast_device_state_clear_cache

(

const char *

device

)

Clear the device from the stasis cache.

Parameters

device

The device to clear

Return values

0	if successful
-1	nothing to clear

Since

12

Definition at line 688 of file devicestate.c.

{
    struct stasis_message *cached_msg;
    struct stasis_message *msg;
 
    cached_msg = stasis_cache_get_by_eid(ast_device_state_cache(),
        ast_device_state_message_type(), device, &ast_eid_default);
    if (!cached_msg) {
        /* nothing to clear */
        return -1;
    }
 
    msg = stasis_cache_clear_create(cached_msg);
    if (msg) {
        stasis_publish(ast_device_state_topic(device), msg);
    }
    ao2_cleanup(msg);
    ao2_cleanup(cached_msg);
    return 0;
}

References ao2_cleanup, ast_device_state_cache(), ast_device_state_message_type(), ast_device_state_topic(), ast_eid_default, stasis_cache_clear_create(), stasis_cache_get_by_eid(), and stasis_publish().

Referenced by stasis_app_device_state_delete().

ast_device_state_engine_init()

int ast_device_state_engine_init

(

void

)

Initialize the device state engine in separate thread.

Provided by devicestate.c

Definition at line 618 of file devicestate.c.

{
    ast_cond_init(&change_pending, NULL);
    if (ast_pthread_create_background(&change_thread, NULL, do_devstate_changes, NULL) < 0) {
        ast_log(LOG_ERROR, "Unable to start device state change thread.\n");
        return -1;
    }
    ast_register_cleanup(device_state_engine_cleanup);
 
    return 0;
}

References ast_cond_init, ast_log, ast_pthread_create_background, ast_register_cleanup(), change_pending, change_thread, device_state_engine_cleanup(), do_devstate_changes(), LOG_ERROR, and NULL.

Referenced by asterisk_daemon().

ast_device_state_topic()

struct stasis_topic * ast_device_state_topic

(

const char *

device

)

Get the Stasis topic for device state messages for a specific device.

Parameters

device

The device for which to get the topic

Returns

The topic structure for MWI messages for a given device

Return values

NULL	if it failed to be found or allocated

Since

12

Definition at line 683 of file devicestate.c.

{
    return stasis_topic_pool_get_topic(device_state_topic_pool, device);
}

References device_state_topic_pool, and stasis_topic_pool_get_topic().

Referenced by ast_device_state_clear_cache(), ast_publish_device_state_full(), cc_generic_agent_start_monitoring(), create_new_generic_list(), device_state_aggregate_publish(), remove_device_states_cb(), and subscribe_device_state().

ast_device_state_topic_all()

struct stasis_topic * ast_device_state_topic_all

(

void

)

Get the Stasis topic for device state messages.

Returns

The topic for device state messages

Return values

NULL	if it has not been allocated

Since

12

Definition at line 668 of file devicestate.c.

{
    return device_state_topic_all;
}

References device_state_topic_all.

Referenced by ast_publish_device_state_full(), AST_TEST_DEFINE(), asterisk_start_devicestate_publishing(), devstate_init(), load_module(), load_pbx(), publish_hint_change(), publish_hint_remove(), subscribe_device_state(), and xmpp_init_event_distribution().

ast_device_state_topic_cached()

struct stasis_topic * ast_device_state_topic_cached

(

void

)

Get the Stasis caching topic for device state messages.

Returns

The caching topic for device state messages

Return values

NULL	if it has not been allocated

Since

12

Definition at line 678 of file devicestate.c.

{
    return stasis_caching_get_topic(device_state_topic_cached);
}

References device_state_topic_cached, and stasis_caching_get_topic().

Referenced by AST_TEST_DEFINE().

ast_devstate2str()

const char * ast_devstate2str

(

enum ast_device_state

devstate

)

Find devicestate as text message for output.

Convert device state to text string for output.

Definition at line 237 of file devicestate.c.

{
    return devstatestring[devstate][0];
}

References devstatestring.

Referenced by ast_sip_get_device_state(), AST_TEST_DEFINE(), ccss_notify_device_state_change(), device_state_cb(), do_state_change(), extension_state_cb(), page_exec(), parking_notify_metermaids(), and print_queue().

ast_devstate_aggregate_add()

void ast_devstate_aggregate_add	(	struct ast_devstate_aggregate *	agg,
		enum ast_device_state	state
	)

Add a device state to the aggregate device state.

Parameters

[in]	agg	the state object
[in]	state	the state to add

Since

1.6.1

Definition at line 636 of file devicestate.c.

{
    static enum ast_device_state state_order[] = {
        1, /* AST_DEVICE_UNKNOWN */
        3, /* AST_DEVICE_NOT_INUSE */
        6, /* AST_DEVICE_INUSE */
        7, /* AST_DEVICE_BUSY */
        0, /* AST_DEVICE_INVALID */
        2, /* AST_DEVICE_UNAVAILABLE */
        5, /* AST_DEVICE_RINGING */
        8, /* AST_DEVICE_RINGINUSE */
        4, /* AST_DEVICE_ONHOLD */
    };
 
    if (state == AST_DEVICE_RINGING) {
        agg->ringing = 1;
    } else if (state == AST_DEVICE_INUSE || state == AST_DEVICE_ONHOLD || state == AST_DEVICE_BUSY) {
        agg->inuse = 1;
    }
 
    if (agg->ringing && agg->inuse) {
        agg->state = AST_DEVICE_RINGINUSE;
    } else if (state_order[state] > state_order[agg->state]) {
        agg->state = state;
    }
}

References AST_DEVICE_BUSY, AST_DEVICE_INUSE, AST_DEVICE_ONHOLD, AST_DEVICE_RINGING, AST_DEVICE_RINGINUSE, ast_devstate_aggregate::inuse, ast_devstate_aggregate::ringing, ast_devstate_aggregate::state, and state.

Referenced by ast_extension_state3(), AST_TEST_DEFINE(), chan_pjsip_devicestate(), and device_state_aggregate_calc().

ast_devstate_aggregate_init()

void ast_devstate_aggregate_init

(

struct ast_devstate_aggregate *

agg

)

Initialize aggregate device state.

Parameters

[in]

agg

the state object

Since

1.6.1

Definition at line 630 of file devicestate.c.

{
    memset(agg, 0, sizeof(*agg));
    agg->state = AST_DEVICE_INVALID;
}

References AST_DEVICE_INVALID, and ast_devstate_aggregate::state.

Referenced by ast_extension_state3(), AST_TEST_DEFINE(), chan_pjsip_devicestate(), and device_state_aggregate_calc().

ast_devstate_aggregate_result()

enum ast_device_state ast_devstate_aggregate_result

(

struct ast_devstate_aggregate *

agg

)

Get the aggregate device state result.

Parameters

[in]

agg

the state object

Returns

the aggregate device state after adding some number of device states.

Since

1.6.1

Definition at line 663 of file devicestate.c.

{
    return agg->state;
}

References ast_devstate_aggregate::state.

Referenced by ast_extension_state3(), AST_TEST_DEFINE(), chan_pjsip_devicestate(), and device_state_aggregate_calc().

ast_devstate_changed()

int ast_devstate_changed	(	enum ast_device_state	state,
		enum ast_devstate_cache	cachable,
		const char *	fmt,
			...
	)

Tells Asterisk the State for Device is changed.

Parameters

state	the new state of the device
cachable	whether this device state is cachable
fmt	device name like a dial string with format parameters

The new state of the device will be sent off to any subscribers of device states. It will also be stored in the internal event cache.

Return values

0	on success
-1	on failure

Definition at line 510 of file devicestate.c.

{
    char buf[AST_MAX_EXTENSION];
    va_list ap;
 
    va_start(ap, fmt);
    vsnprintf(buf, sizeof(buf), fmt, ap);
    va_end(ap);
 
    return ast_devstate_changed_literal(state, cachable, buf);
}

References ast_devstate_changed_literal(), AST_MAX_EXTENSION, buf, and state_change::cachable.

Referenced by __expire_registry(), __iax2_poke_noanswer(), add_to_queue(), agent_devstate_changed(), ast_sip_persistent_endpoint_update_state(), calendar_devstate_change(), ccss_notify_device_state_change(), chan_pjsip_indicate(), conf_handle_first_join(), conf_run(), destroy_event(), device_state_cb(), devstate_write(), handle_cli_devstate_change(), init_queue(), join_queue(), leave_queue(), load_module(), member_add_to_queue(), member_remove_from_queue(), mwi_update_cb(), parking_notify_metermaids(), populate_cache(), reg_source_db(), register_verify(), remove_from_queue(), rt_handle_member_record(), set_queue_member_pause(), sla_change_trunk_state(), sla_handle_hold_event(), sla_station_exec(), socket_process_helper(), stasis_app_device_state_delete(), stasis_app_device_state_update(), transition_to_empty(), update_devstate(), update_registry(), and xmpp_pak_presence().

ast_devstate_changed_literal()

int ast_devstate_changed_literal	(	enum ast_device_state	state,
		enum ast_devstate_cache	cachable,
		const char *	device
	)

Tells Asterisk the State for Device is changed.

Parameters

state	the new state of the device
cachable	whether this device state is cachable
device	device name like a dial string with format parameters

The new state of the device will be sent off to any subscribers of device states. It will also be stored in the internal event cache.

Return values

0	on success
-1	on failure

Definition at line 471 of file devicestate.c.

{
    struct state_change *change;
 
    /*
     * If we know the state change (how nice of the caller of this function!)
     * then we can just generate a device state event.
     *
     * Otherwise, we do the following:
     *   - Queue an event up to another thread that the state has changed
     *   - In the processing thread, it calls the callback provided by the
     *     device state provider (which may or may not be a channel driver)
     *     to determine the state.
     *   - If the device state provider does not know the state, or this is
     *     for a channel and the channel driver does not implement a device
     *     state callback, then we will look through the channel list to
     *     see if we can determine a state based on active calls.
     *   - Once a state has been determined, a device state event is generated.
     */
 
    if (state != AST_DEVICE_UNKNOWN) {
        ast_publish_device_state(device, state, cachable);
    } else if (change_thread == AST_PTHREADT_NULL || !(change = ast_calloc(1, sizeof(*change) + strlen(device)))) {
        /* we could not allocate a change struct, or */
        /* there is no background thread, so process the change now */
        do_state_change(device, cachable);
    } else {
        /* queue the change */
        strcpy(change->device, device);
        change->cachable = cachable;
        AST_LIST_LOCK(&state_changes);
        AST_LIST_INSERT_TAIL(&state_changes, change, list);
        ast_cond_signal(&change_pending);
        AST_LIST_UNLOCK(&state_changes);
    }
 
    return 0;
}

References ast_calloc, ast_cond_signal, AST_DEVICE_UNKNOWN, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, AST_PTHREADT_NULL, ast_publish_device_state, state_change::cachable, change_pending, change_thread, state_change::device, do_state_change(), and state_change::list.

Referenced by ast_channel_destructor(), ast_devstate_changed(), ast_setstate(), AST_TEST_DEFINE(), chan_pjsip_indicate(), and dahdi_new().

ast_devstate_prov_add()

int ast_devstate_prov_add	(	const char *	label,
		ast_devstate_prov_cb_type	callback
	)

Add device state provider.

Parameters

label	to use in hint, like label:object
callback	Callback

Return values

0	success
-1	failure

Definition at line 391 of file devicestate.c.

{
    struct devstate_prov *devcb;
    struct devstate_prov *devprov;
 
    if (!callback || !(devprov = ast_calloc(1, sizeof(*devprov))))
        return -1;
 
    devprov->callback = callback;
    ast_copy_string(devprov->label, label, sizeof(devprov->label));
 
    AST_RWLIST_WRLOCK(&devstate_provs);
    AST_RWLIST_TRAVERSE(&devstate_provs, devcb, list) {
        if (!strcasecmp(devcb->label, label)) {
            ast_log(LOG_WARNING, "Device state provider '%s' already registered\n", label);
            ast_free(devprov);
            AST_RWLIST_UNLOCK(&devstate_provs);
            return -1;
        }
    }
    AST_RWLIST_INSERT_HEAD(&devstate_provs, devprov, list);
    AST_RWLIST_UNLOCK(&devstate_provs);
 
    return 0;
}

References ast_calloc, ast_copy_string(), ast_free, ast_log, AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, devstate_prov::callback, devstate_prov::label, and LOG_WARNING.

Referenced by AST_TEST_DEFINE(), load_module(), and load_parking_devstate().

ast_devstate_prov_del()

int ast_devstate_prov_del

(

const char *

label

)

Remove device state provider.

Parameters

label

to use in hint, like label:object

Return values

-1	on failure
0	on success

Definition at line 418 of file devicestate.c.

{
    struct devstate_prov *devcb;
    int res = -1;
 
    AST_RWLIST_WRLOCK(&devstate_provs);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&devstate_provs, devcb, list) {
        if (!strcasecmp(devcb->label, label)) {
            AST_RWLIST_REMOVE_CURRENT(list);
            ast_free(devcb);
            res = 0;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&devstate_provs);
 
    return res;
}

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, and devstate_prov::label.

Referenced by AST_TEST_DEFINE(), load_module(), unload_module(), and unload_parking_devstate().

ast_devstate_str()

const char * ast_devstate_str

(

enum ast_device_state

devstate

)

Convert device state to text string that is easier to parse.

Parameters

devstate

Current device state

Definition at line 255 of file devicestate.c.

{
    return devstatestring[state][1];
}

References devstatestring, and state.

Referenced by agent_handle_show_specific(), agent_show_requested(), AST_TEST_DEFINE(), asterisk_publisher_devstate_cb(), devstate_read(), devstate_to_ami(), stasis_app_device_state_to_json(), and xmpp_pubsub_devstate_cb().

ast_devstate_val()

enum ast_device_state ast_devstate_val

(

const char *

val

)

Convert device state from text to integer value.

Parameters

val	The text representing the device state. Valid values are anything that comes after AST_DEVICE_ in one of the defined values.

Returns

The AST_DEVICE_ integer value

Definition at line 260 of file devicestate.c.

{
    if (!strcasecmp(val, "NOT_INUSE"))
        return AST_DEVICE_NOT_INUSE;
    else if (!strcasecmp(val, "INUSE"))
        return AST_DEVICE_INUSE;
    else if (!strcasecmp(val, "BUSY"))
        return AST_DEVICE_BUSY;
    else if (!strcasecmp(val, "INVALID"))
        return AST_DEVICE_INVALID;
    else if (!strcasecmp(val, "UNAVAILABLE"))
        return AST_DEVICE_UNAVAILABLE;
    else if (!strcasecmp(val, "RINGING"))
        return AST_DEVICE_RINGING;
    else if (!strcasecmp(val, "RINGINUSE"))
        return AST_DEVICE_RINGINUSE;
    else if (!strcasecmp(val, "ONHOLD"))
        return AST_DEVICE_ONHOLD;
 
    return AST_DEVICE_UNKNOWN;
}

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_UNAVAILABLE, and AST_DEVICE_UNKNOWN.

Referenced by AST_TEST_DEFINE(), asterisk_publication_devicestate(), custom_devstate_callback(), devstate_write(), handle_cli_devstate_change(), initialize_cc_devstate_map_helper(), load_module(), populate_cache(), stasis_app_device_state_update(), stasis_device_state_cb(), and xmpp_pubsub_handle_event().

ast_parse_device_state()

enum ast_device_state ast_parse_device_state

(

const char *

device

)

Find out if device is active in a call or not.

Search the Channels by Name.

Note

find channels with the device's name in it This function is only used for channels that does not implement devicestate natively

Definition at line 287 of file devicestate.c.

{
    struct ast_channel *chan;
    char match[AST_CHANNEL_NAME];
    enum ast_device_state res;
 
    snprintf(match, sizeof(match), "%s-", device);
 
    if (!(chan = ast_channel_get_by_name_prefix(match, strlen(match)))) {
        return AST_DEVICE_UNKNOWN;
    }
 
    if (ast_channel_hold_state(chan) == AST_CONTROL_HOLD) {
        res = AST_DEVICE_ONHOLD;
    } else {
        res = ast_state_chan2dev(ast_channel_state(chan));
    }
    ast_channel_unref(chan);
 
    return res;
}

References ast_channel_get_by_name_prefix(), ast_channel_hold_state(), AST_CHANNEL_NAME, ast_channel_unref, AST_CONTROL_HOLD, AST_DEVICE_ONHOLD, AST_DEVICE_UNKNOWN, ast_state_chan2dev(), and match().

Referenced by _ast_device_state(), AST_TEST_DEFINE(), and chanavail_exec().

ast_publish_device_state_full()

int ast_publish_device_state_full	(	const char *	device,
		enum ast_device_state	state,
		enum ast_devstate_cache	cachable,
		struct ast_eid *	eid
	)

Publish a device state update with EID.

Parameters

[in]	device	The device name
[in]	state	The state of the device
[in]	cachable	Whether the device state can be cached
[in]	eid	The EID of the server that originally published the message

Return values

0	Success
-1	Failure

Since

12

Definition at line 709 of file devicestate.c.

{
    RAII_VAR(struct ast_device_state_message *, device_state, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
    struct stasis_topic *topic;
 
    ast_assert(!ast_strlen_zero(device));
 
    if (!ast_device_state_message_type()) {
        return -1;
    }
 
    device_state = device_state_alloc(device, state, cachable, eid);
    if (!device_state) {
        return -1;
    }
 
    message = stasis_message_create_full(ast_device_state_message_type(), device_state,
        eid);
    if (!message) {
        return -1;
    }
 
    /* When a device state is to be cached it is likely that something
     * external will either be monitoring it or will want to pull the
     * information from the cache, so we always publish to the device
     * specific topic. Cachable updates traditionally come from such things
     * as a SIP or PJSIP device.
     * When a device state is not to be cached we only publish to its
     * specific topic if something has already created the topic. Publishing
     * to its topic otherwise would create the topic, which may not be
     * necessary as it could be an ephemeral device. Uncachable updates
     * traditionally come from such things as Local channels.
     */
    if (cachable || stasis_topic_pool_topic_exists(device_state_topic_pool, device)) {
        topic = ast_device_state_topic(device);
    } else {
        topic = ast_device_state_topic_all();
    }
 
    if (!topic) {
        return -1;
    }
 
    stasis_publish(topic, message);
    return 0;
}

References ao2_cleanup, ast_assert, ast_device_state_message_type(), ast_device_state_topic(), ast_device_state_topic_all(), ast_strlen_zero(), device_state_alloc(), device_state_topic_pool, NULL, RAII_VAR, stasis_message_create_full(), stasis_publish(), and stasis_topic_pool_topic_exists().

Referenced by AST_TEST_DEFINE(), asterisk_publication_devicestate(), devstate_change_cb(), publish_device_state_to_stasis(), and xmpp_pubsub_handle_event().

ast_state_chan2dev()

enum ast_device_state ast_state_chan2dev

(

enum ast_channel_state

chanstate

)

Convert channel state to devicestate.

Parameters

chanstate

Current channel state

Since

1.6.1

Definition at line 242 of file devicestate.c.

{
    int i;
    chanstate &= 0xFFFF;
    for (i = 0; i < ARRAY_LEN(chan2dev); i++) {
        if (chan2dev[i].chan == chanstate) {
            return chan2dev[i].dev;
        }
    }
    return AST_DEVICE_UNKNOWN;
}

References ARRAY_LEN, AST_DEVICE_UNKNOWN, and chan2dev::dev.

Referenced by ast_parse_device_state(), AST_TEST_DEFINE(), and chan_pjsip_devicestate().

device_state_aggregate_calc()

static struct stasis_message * device_state_aggregate_calc ( struct stasis_cache_entry *  entry, struct stasis_message *  new_snapshot  )

static

Definition at line 816 of file devicestate.c.

{
    struct stasis_message *aggregate_snapshot;
    struct stasis_message *snapshot;
    struct ast_device_state_message *device_state;
    const char *device = NULL;
    struct ast_devstate_aggregate aggregate;
    int idx;
 
    if (!ast_device_state_message_type()) {
        return NULL;
    }
 
    /* Determine the new aggregate device state. */
    ast_devstate_aggregate_init(&aggregate);
    snapshot = stasis_cache_entry_get_local(entry);
    if (snapshot) {
        device_state = stasis_message_data(snapshot);
        device = device_state->device;
        ast_devstate_aggregate_add(&aggregate, device_state->state);
    }
    for (idx = 0; ; ++idx) {
        snapshot = stasis_cache_entry_get_remote(entry, idx);
        if (!snapshot) {
            break;
        }
 
        device_state = stasis_message_data(snapshot);
        device = device_state->device;
        ast_devstate_aggregate_add(&aggregate, device_state->state);
    }
 
    if (!device) {
        /* There are no device states cached.  Delete the aggregate. */
        return NULL;
    }
 
    snapshot = stasis_cache_entry_get_aggregate(entry);
    if (snapshot) {
        device_state = stasis_message_data(snapshot);
        if (device_state->state == ast_devstate_aggregate_result(&aggregate)) {
            /* Aggregate device state did not change. */
            return ao2_bump(snapshot);
        }
    }
 
    device_state = device_state_alloc(device, ast_devstate_aggregate_result(&aggregate),
        AST_DEVSTATE_CACHABLE, NULL);
    if (!device_state) {
        /* Bummer.  We have to keep the old aggregate snapshot. */
        return ao2_bump(snapshot);
    }
    aggregate_snapshot = stasis_message_create_full(ast_device_state_message_type(),
        device_state, NULL);
    ao2_cleanup(device_state);
    if (!aggregate_snapshot) {
        /* Bummer.  We have to keep the old aggregate snapshot. */
        return ao2_bump(snapshot);
    }
 
    return aggregate_snapshot;
}

References ao2_bump, ao2_cleanup, ast_device_state_message_type(), ast_devstate_aggregate_add(), ast_devstate_aggregate_init(), ast_devstate_aggregate_result(), AST_DEVSTATE_CACHABLE, ast_device_state_message::device, device_state_alloc(), NULL, stasis_cache_entry_get_aggregate(), stasis_cache_entry_get_local(), stasis_cache_entry_get_remote(), stasis_message_create_full(), stasis_message_data(), and ast_device_state_message::state.

Referenced by devstate_init().

device_state_aggregate_publish()

static void device_state_aggregate_publish ( struct stasis_topic *  cache_topic, struct stasis_message *  aggregate  )

static

Definition at line 785 of file devicestate.c.

{
    const char *device;
    struct stasis_topic *device_specific_topic;
 
    device = device_state_get_id(aggregate);
    if (!device) {
        return;
    }
    device_specific_topic = ast_device_state_topic(device);
    if (!device_specific_topic) {
        return;
    }
 
    stasis_publish(device_specific_topic, aggregate);
}

References ast_device_state_topic(), ast_device_state_message::device, device_state_get_id(), and stasis_publish().

Referenced by devstate_init().

device_state_alloc()

static struct ast_device_state_message * device_state_alloc ( const char *  device, enum ast_device_state  state, enum ast_devstate_cache  cachable, const struct ast_eid *  eid  )

static

Definition at line 547 of file devicestate.c.

{
    struct ast_device_state_message *new_device_state;
    char *pos;
    size_t stuff_len;
 
    ast_assert(!ast_strlen_zero(device));
 
    stuff_len = strlen(device) + 1;
    if (eid) {
        stuff_len += sizeof(*eid);
    }
    new_device_state = ao2_alloc_options(sizeof(*new_device_state) + stuff_len, NULL,
        AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!new_device_state) {
        return NULL;
    }
 
    if (eid) {
        /* non-aggregate device state. */
        new_device_state->stuff[0] = *eid;
        new_device_state->eid = &new_device_state->stuff[0];
        pos = (char *) &new_device_state->stuff[1];
    } else {
        pos = (char *) &new_device_state->stuff[0];
    }
 
    strcpy(pos, device);/* Safe */
    new_device_state->device = pos;
 
    new_device_state->state = state;
    new_device_state->cachable = cachable;
 
    return new_device_state;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ast_assert, ast_strlen_zero(), ast_device_state_message::cachable, ast_device_state_message::device, ast_device_state_message::eid, NULL, ast_device_state_message::state, state, and ast_device_state_message::stuff.

Referenced by ast_publish_device_state_full(), and device_state_aggregate_calc().

device_state_engine_cleanup()

static void device_state_engine_cleanup ( void  )

static

Definition at line 605 of file devicestate.c.

{
    shuttingdown = 1;
    AST_LIST_LOCK(&state_changes);
    ast_cond_signal(&change_pending);
    AST_LIST_UNLOCK(&state_changes);
 
    if (change_thread != AST_PTHREADT_NULL) {
        pthread_join(change_thread, NULL);
    }
}

References ast_cond_signal, AST_LIST_LOCK, AST_LIST_UNLOCK, AST_PTHREADT_NULL, change_pending, change_thread, NULL, and shuttingdown.

Referenced by ast_device_state_engine_init().

device_state_get_id()

static const char * device_state_get_id ( struct stasis_message *  message )

static

Definition at line 761 of file devicestate.c.

{
    struct ast_device_state_message *device_state;
 
    if (ast_device_state_message_type() != stasis_message_type(message)) {
        return NULL;
    }
 
    device_state = stasis_message_data(message);
    if (device_state->cachable == AST_DEVSTATE_NOT_CACHABLE) {
        return NULL;
    }
 
    return device_state->device;
}

References ast_device_state_message_type(), AST_DEVSTATE_NOT_CACHABLE, ast_device_state_message::cachable, ast_device_state_message::device, NULL, stasis_message_data(), and stasis_message_type().

Referenced by device_state_aggregate_publish(), and devstate_init().

devstate_cached()

static enum ast_device_state devstate_cached ( const char *  device )

static

Definition at line 309 of file devicestate.c.

{
    struct stasis_message *cached_msg;
    struct ast_device_state_message *device_state;
    enum ast_device_state state;
 
    cached_msg = stasis_cache_get_by_eid(ast_device_state_cache(),
        ast_device_state_message_type(), device, NULL);
    if (!cached_msg) {
        return AST_DEVICE_UNKNOWN;
    }
    device_state = stasis_message_data(cached_msg);
    state = device_state->state;
    ao2_cleanup(cached_msg);
 
    return state;
}

References ao2_cleanup, ast_device_state_cache(), ast_device_state_message_type(), AST_DEVICE_UNKNOWN, ast_device_state_message::device, NULL, stasis_cache_get_by_eid(), stasis_message_data(), ast_device_state_message::state, and state.

Referenced by _ast_device_state().

devstate_change_cb()

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

static

Definition at line 583 of file devicestate.c.

{
    struct ast_device_state_message *device_state;
 
    if (ast_device_state_message_type() != stasis_message_type(msg)) {
        return;
    }
 
    device_state = stasis_message_data(msg);
    if (device_state->cachable == AST_DEVSTATE_CACHABLE || !device_state->eid) {
        /* Ignore cacheable and aggregate messages. */
        return;
    }
 
    /*
     * Non-cacheable device state aggregates are just the
     * device state republished as the aggregate.
     */
    ast_publish_device_state_full(device_state->device, device_state->state,
        device_state->cachable, NULL);
}

References ast_device_state_message_type(), AST_DEVSTATE_CACHABLE, ast_publish_device_state_full(), ast_device_state_message::cachable, ast_device_state_message::device, ast_device_state_message::eid, NULL, stasis_message_data(), stasis_message_type(), and ast_device_state_message::state.

Referenced by devstate_init().

devstate_cleanup()

static void devstate_cleanup ( void  )

static

Definition at line 879 of file devicestate.c.

{
    devstate_message_sub = stasis_unsubscribe_and_join(devstate_message_sub);
    device_state_topic_cached = stasis_caching_unsubscribe_and_join(device_state_topic_cached);
 
    ao2_cleanup(device_state_cache);
    device_state_cache = NULL;
 
    ao2_cleanup(device_state_topic_pool);
    device_state_topic_pool = NULL;
 
    ao2_cleanup(device_state_topic_all);
    device_state_topic_all = NULL;
 
    STASIS_MESSAGE_TYPE_CLEANUP(ast_device_state_message_type);
}

References ao2_cleanup, ast_device_state_message_type(), device_state_cache, device_state_topic_all, device_state_topic_cached, device_state_topic_pool, devstate_message_sub, NULL, stasis_caching_unsubscribe_and_join(), STASIS_MESSAGE_TYPE_CLEANUP, and stasis_unsubscribe_and_join().

Referenced by devstate_init().

devstate_init()

int devstate_init

(

void

)

Initialize the device state core.

Return values

0	Success
-1	Failure

Since

12

Definition at line 896 of file devicestate.c.

{
    ast_register_cleanup(devstate_cleanup);
 
    if (STASIS_MESSAGE_TYPE_INIT(ast_device_state_message_type) != 0) {
        return -1;
    }
    device_state_topic_all = stasis_topic_create("devicestate:all");
    if (!device_state_topic_all) {
        return -1;
    }
    device_state_topic_pool = stasis_topic_pool_create(ast_device_state_topic_all());
    if (!device_state_topic_pool) {
        return -1;
    }
    device_state_cache = stasis_cache_create_full(device_state_get_id,
        device_state_aggregate_calc, device_state_aggregate_publish);
    if (!device_state_cache) {
        return -1;
    }
    device_state_topic_cached = stasis_caching_topic_create(ast_device_state_topic_all(),
        device_state_cache);
    if (!device_state_topic_cached) {
        return -1;
    }
    stasis_caching_accept_message_type(device_state_topic_cached, ast_device_state_message_type());
    stasis_caching_set_filter(device_state_topic_cached, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    devstate_message_sub = stasis_subscribe(ast_device_state_topic_all(),
        devstate_change_cb, NULL);
    if (!devstate_message_sub) {
        ast_log(LOG_ERROR, "Failed to create subscription creating uncached device state aggregate events.\n");
        return -1;
    }
    stasis_subscription_accept_message_type(devstate_message_sub, ast_device_state_message_type());
    stasis_subscription_set_filter(devstate_message_sub, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    return 0;
}

References ast_device_state_message_type(), ast_device_state_topic_all(), ast_log, ast_register_cleanup(), device_state_aggregate_calc(), device_state_aggregate_publish(), device_state_cache, device_state_get_id(), device_state_topic_all, device_state_topic_cached, device_state_topic_pool, devstate_change_cb(), devstate_cleanup(), devstate_message_sub, LOG_ERROR, NULL, stasis_cache_create_full(), stasis_caching_accept_message_type(), stasis_caching_set_filter(), stasis_caching_topic_create(), STASIS_MESSAGE_TYPE_INIT, stasis_subscribe, stasis_subscription_accept_message_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), stasis_topic_create(), and stasis_topic_pool_create().

Referenced by asterisk_daemon().

devstate_to_ami()

static struct ast_manager_event_blob * devstate_to_ami ( struct stasis_message *  msg )

static

Definition at line 936 of file devicestate.c.

{
    struct ast_device_state_message *dev_state;
 
    dev_state = stasis_message_data(msg);
 
    /* Ignore non-aggregate states */
    if (dev_state->eid) {
        return NULL;
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_CALL, "DeviceStateChange",
        "Device: %s\r\n"
        "State: %s\r\n",
        dev_state->device, ast_devstate_str(dev_state->state));
}

References ast_devstate_str(), ast_manager_event_blob_create(), ast_device_state_message::device, ast_device_state_message::eid, EVENT_FLAG_CALL, NULL, stasis_message_data(), and ast_device_state_message::state.

devstate_to_event()

static struct ast_event * devstate_to_event ( struct stasis_message *  msg )

static

Convert a stasis_message to a ast_event.

Definition at line 954 of file devicestate.c.

{
    struct ast_event *event;
    struct ast_device_state_message *device_state;
 
    if (!message) {
        return NULL;
    }
 
    device_state = stasis_message_data(message);
 
    if (device_state->eid) {
        event = ast_event_new(AST_EVENT_DEVICE_STATE_CHANGE,
                        AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, device_state->device,
                        AST_EVENT_IE_STATE, AST_EVENT_IE_PLTYPE_UINT, device_state->state,
                        AST_EVENT_IE_CACHABLE, AST_EVENT_IE_PLTYPE_UINT, device_state->cachable,
                        AST_EVENT_IE_EID, AST_EVENT_IE_PLTYPE_RAW, device_state->eid, sizeof(*device_state->eid),
                        AST_EVENT_IE_END);
    } else {
        event = ast_event_new(AST_EVENT_DEVICE_STATE,
                        AST_EVENT_IE_DEVICE, AST_EVENT_IE_PLTYPE_STR, device_state->device,
                        AST_EVENT_IE_STATE, AST_EVENT_IE_PLTYPE_UINT, device_state->state,
                        AST_EVENT_IE_CACHABLE, AST_EVENT_IE_PLTYPE_UINT, device_state->cachable,
                        AST_EVENT_IE_END);
    }
 
    return event;
}

References AST_EVENT_DEVICE_STATE, AST_EVENT_DEVICE_STATE_CHANGE, AST_EVENT_IE_CACHABLE, AST_EVENT_IE_DEVICE, AST_EVENT_IE_EID, AST_EVENT_IE_END, AST_EVENT_IE_PLTYPE_RAW, AST_EVENT_IE_PLTYPE_STR, AST_EVENT_IE_PLTYPE_UINT, AST_EVENT_IE_STATE, ast_event_new(), ast_device_state_message::cachable, ast_device_state_message::device, ast_device_state_message::eid, NULL, stasis_message_data(), and ast_device_state_message::state.

do_devstate_changes()

static void * do_devstate_changes ( void *  data )

static

Go through the dev state change queue and update changes in the dev state thread.

Definition at line 523 of file devicestate.c.

{
    struct state_change *next, *current;
 
    while (!shuttingdown) {
        /* This basically pops off any state change entries, resets the list back to NULL, unlocks, and processes each state change */
        AST_LIST_LOCK(&state_changes);
        if (AST_LIST_EMPTY(&state_changes))
            ast_cond_wait(&change_pending, &state_changes.lock);
        next = AST_LIST_FIRST(&state_changes);
        AST_LIST_HEAD_INIT_NOLOCK(&state_changes);
        AST_LIST_UNLOCK(&state_changes);
 
        /* Process each state change */
        while ((current = next)) {
            next = AST_LIST_NEXT(current, list);
            do_state_change(current->device, current->cachable);
            ast_free(current);
        }
    }
 
    return NULL;
}

References ast_cond_wait, ast_free, AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_HEAD_INIT_NOLOCK, AST_LIST_LOCK, AST_LIST_NEXT, AST_LIST_UNLOCK, change_pending, current, do_state_change(), state_change::list, state_changes::lock, state_change::next, NULL, and shuttingdown.

Referenced by ast_device_state_engine_init().

do_state_change()

static void do_state_change ( const char *  device, enum ast_devstate_cache  cachable  )

static

Called by the state change thread to find out what the state is, and then to queue up the state change event

Definition at line 460 of file devicestate.c.

{
    enum ast_device_state state;
 
    state = _ast_device_state(device, 0);
 
    ast_debug(3, "Changing state for %s - state %u (%s)\n", device, state, ast_devstate2str(state));
 
    ast_publish_device_state(device, state, cachable);
}

References _ast_device_state(), ast_debug, ast_devstate2str(), ast_publish_device_state, and state.

Referenced by ast_devstate_changed_literal(), and do_devstate_changes().

getproviderstate()

static int getproviderstate ( const char *  provider, const char *  address  )

static

Get provider device state.

Definition at line 439 of file devicestate.c.

{
    struct devstate_prov *devprov;
    int res = AST_DEVICE_INVALID;
 
    AST_RWLIST_RDLOCK(&devstate_provs);
    AST_RWLIST_TRAVERSE(&devstate_provs, devprov, list) {
        ast_debug(5, "Checking provider %s with %s\n", devprov->label, provider);
 
        if (!strcasecmp(devprov->label, provider)) {
            res = devprov->callback(address);
            break;
        }
    }
    AST_RWLIST_UNLOCK(&devstate_provs);
 
    return res;
}

References ast_debug, AST_DEVICE_INVALID, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, devstate_prov::callback, devstate_prov::label, and provider.

Referenced by _ast_device_state().

STASIS_MESSAGE_TYPE_DEFN()

STASIS_MESSAGE_TYPE_DEFN	(	ast_device_state_message_type	,
		.	to_ami = devstate_to_ami,
		.	to_event = devstate_to_event
	)

Variable Documentation

chan2dev

const struct chan2dev chan2dev[]

static

change_pending

ast_cond_t change_pending

static

Flag for the queue.

Definition at line 214 of file devicestate.c.

Referenced by ast_device_state_engine_init(), ast_devstate_changed_literal(), device_state_engine_cleanup(), and do_devstate_changes().

change_thread

pthread_t change_thread = AST_PTHREADT_NULL

static

The device state change notification thread.

Definition at line 211 of file devicestate.c.

Referenced by ast_device_state_engine_init(), ast_devstate_changed_literal(), and device_state_engine_cleanup().

device_state_cache

struct stasis_cache* device_state_cache

static

Definition at line 220 of file devicestate.c.

Referenced by ast_device_state_cache(), devstate_cleanup(), and devstate_init().

device_state_topic_all

struct stasis_topic* device_state_topic_all

static

Definition at line 219 of file devicestate.c.

Referenced by ast_device_state_topic_all(), devstate_cleanup(), and devstate_init().

device_state_topic_cached

struct stasis_caching_topic* device_state_topic_cached

static

Definition at line 221 of file devicestate.c.

Referenced by ast_device_state_topic_cached(), devstate_cleanup(), and devstate_init().

device_state_topic_pool

struct stasis_topic_pool* device_state_topic_pool

static

Definition at line 222 of file devicestate.c.

Referenced by ast_device_state_topic(), ast_publish_device_state_full(), devstate_cleanup(), and devstate_init().

devstate_message_sub

struct stasis_subscription* devstate_message_sub

Definition at line 217 of file devicestate.c.

Referenced by devstate_cleanup(), and devstate_init().

devstate_provs

struct devstate_provs devstate_provs = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

static

devstatestring

const char* const devstatestring[][2]

static

Device state strings for printing.

Definition at line 161 of file devicestate.c.

Referenced by ast_devstate2str(), and ast_devstate_str().

shuttingdown

volatile int shuttingdown

static

Definition at line 215 of file devicestate.c.

Referenced by device_state_engine_cleanup(), and do_devstate_changes().

state_changes

struct state_changes state_changes = { .first = NULL, .last = NULL, .lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} } , }

static