Sun Aug 6 15:10:11 2006

Asterisk developer's documentation

---

devicestate.c File Reference

Device state management. More...

#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "asterisk.h"
#include "asterisk/channel.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/linkedlists.h"
#include "asterisk/logger.h"
#include "asterisk/devicestate.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"

Include dependency graph for devicestate.c:

Go to the source code of this file.

Functions
static int	__ast_device_state_changed_literal (char *buf)
int	ast_device_state (const char *device)
	Asks a channel for device state.
int	ast_device_state_changed (const char *fmt,...)
int	ast_device_state_changed_literal (const char *dev)
	Tells Asterisk the State for Device is changed.
int	ast_device_state_engine_init (void)
int	ast_devstate_add (ast_devstate_cb_type callback, void *data)
	Registers a device state change callback.
void	ast_devstate_del (ast_devstate_cb_type callback, void *data)
static	AST_LIST_HEAD_STATIC (state_changes, state_change)
static	AST_LIST_HEAD_STATIC (devstate_cbs, devstate_cb)
int	ast_parse_device_state (const char *device)
	Search the Channels by Name.
const char *	devstate2str (int devstate)
	Convert device state to text string for output.
static void *	do_devstate_changes (void *data)
static void	do_state_change (const char *device)
Variables
static ast_cond_t	change_pending
static pthread_t	change_thread = AST_PTHREADT_NULL
static const char *	devstatestring []

---

Detailed Description

Device state management.

Definition in file devicestate.c.

---

Function Documentation

static int __ast_device_state_changed_literal (  char *  buf  )  [static]

Definition at line 197 of file devicestate.c. References ast_cond_signal(), AST_LIST_FIRST, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, AST_PTHREADT_NULL, calloc, change_pending, change_thread, do_state_change(), and list. Referenced by ast_device_state_changed(), and ast_device_state_changed_literal(). { char *device, *tmp; struct state_change *change = NULL; device = buf; tmp = strrchr(device, '-'); if (tmp) *tmp = '\0'; if (change_thread != AST_PTHREADT_NULL) change = calloc(1, sizeof(*change) + strlen(device)); if (!change) { /* we could not allocate a change struct, or */ /* there is no background thread, so process the change now */ do_state_change(device); } else { /* queue the change */ strcpy(change->device, device); AST_LIST_LOCK(&state_changes); AST_LIST_INSERT_TAIL(&state_changes, change, list); if (AST_LIST_FIRST(&state_changes) == change) /* the list was empty, signal the thread */ ast_cond_signal(&change_pending); AST_LIST_UNLOCK(&state_changes); } return 1; }

int ast_device_state (  const char *  device  )

Asks a channel for device state. Parameters: device  like a dialstring Asks a channel for device state, data is normaly a number from dialstring used by the low level module Trys the channel devicestate callback if not supported search in the active channels list for the device. Returns an AST_DEVICE_??? state -1 on failure Definition at line 104 of file devicestate.c. References AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, AST_DEVICE_UNKNOWN, ast_get_channel_tech(), ast_parse_device_state(), ast_strdupa, ast_channel_tech::devicestate, strsep(), and ast_channel::tech. Referenced by ast_extension_state2(), chanavail_exec(), create_queue_member(), do_state_change(), reload_queues(), and transmit_state_notify(). { char *buf; char *tech; char *number; const struct ast_channel_tech *chan_tech; int res = 0; buf = ast_strdupa(device); tech = strsep(&buf, "/"); number = buf; if (!number) return AST_DEVICE_INVALID; chan_tech = ast_get_channel_tech(tech); if (!chan_tech) return AST_DEVICE_INVALID; if (!chan_tech->devicestate) /* Does the channel driver support device state notification? */ return ast_parse_device_state(device); /* No, try the generic function */ else { res = chan_tech->devicestate(number); /* Ask the channel driver for device state */ if (res == AST_DEVICE_UNKNOWN) { res = ast_parse_device_state(device); /* at this point we know the device exists, but the channel driver could not give us a state; if there is no channel state available, it must be 'not in use' */ if (res == AST_DEVICE_UNKNOWN) res = AST_DEVICE_NOT_INUSE; return res; } else return res; } }

int ast_device_state_changed (  const char *  fmt,   ... )

Definition at line 235 of file devicestate.c. References __ast_device_state_changed_literal(), and AST_MAX_EXTENSION. Referenced by __login_exec(), action_agent_callback_login(), agent_hangup(), agent_logoff(), expire_register(), expire_registry(), handle_response_peerpoke(), iax2_poke_noanswer(), reg_source_db(), register_verify(), reload_agents(), sip_poke_noanswer(), socket_read(), and update_registry(). { char buf[AST_MAX_EXTENSION]; va_list ap; va_start(ap, fmt); vsnprintf(buf, sizeof(buf), fmt, ap); va_end(ap); return __ast_device_state_changed_literal(buf); }

int ast_device_state_changed_literal (  const char *  device  )

Tells Asterisk the State for Device is changed. Parameters: device  devicename like a dialstrin Asterisk polls the new extensionstates and calls the registered callbacks for the changed extensions Returns 0 on success, -1 on failure Definition at line 227 of file devicestate.c. References __ast_device_state_changed_literal(), and ast_strdupa. Referenced by ast_channel_free(), and ast_setstate(). { char *buf; buf = ast_strdupa(dev); return __ast_device_state_changed_literal(buf); }

int ast_device_state_engine_init (  void   )

Definition at line 272 of file devicestate.c. References ast_cond_init(), ast_log(), ast_pthread_create, change_pending, change_thread, do_devstate_changes(), and LOG_ERROR. Referenced by main(). { ast_cond_init(&change_pending, NULL); if (ast_pthread_create(&change_thread, NULL, do_devstate_changes, NULL) < 0) { ast_log(LOG_ERROR, "Unable to start device state change thread.\n"); return -1; } return 0; }

int ast_devstate_add (  ast_devstate_cb_type  callback, void *  data )

Registers a device state change callback. Parameters: callback  Callback data  to pass to callback The callback is called if the state for extension is changed Return -1 on failure, ID on success Definition at line 141 of file devicestate.c. References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, calloc, and list. Referenced by load_module(). { struct devstate_cb *devcb; if (!callback) return -1; devcb = calloc(1, sizeof(*devcb)); if (!devcb) return -1; devcb->data = data; devcb->callback = callback; AST_LIST_LOCK(&devstate_cbs); AST_LIST_INSERT_HEAD(&devstate_cbs, devcb, list); AST_LIST_UNLOCK(&devstate_cbs); return 0; }

void ast_devstate_del (  ast_devstate_cb_type  callback, void *  data )

Definition at line 163 of file devicestate.c. References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, devstate_cb::callback, devstate_cb::data, free, and list. Referenced by unload_module(). { struct devstate_cb *devcb; AST_LIST_LOCK(&devstate_cbs); AST_LIST_TRAVERSE_SAFE_BEGIN(&devstate_cbs, devcb, list) { if ((devcb->callback == callback) && (devcb->data == data)) { AST_LIST_REMOVE_CURRENT(&devstate_cbs, list); free(devcb); break; } } AST_LIST_TRAVERSE_SAFE_END; AST_LIST_UNLOCK(&devstate_cbs); }

static AST_LIST_HEAD_STATIC (  state_changes  , state_change  )  [static]

static AST_LIST_HEAD_STATIC (  devstate_cbs  , devstate_cb  )  [static]

int ast_parse_device_state (  const char *  device  )

Search the Channels by Name. Parameters: device  like a dialstring Search the Device in active channels by compare the channelname against the devicename. Compared are only the first chars to the first '-' char. Returns an AST_DEVICE_UNKNOWN if no channel found or AST_DEVICE_INUSE if a channel is found Definition at line 80 of file devicestate.c. References ast_channel::_state, AST_CHANNEL_NAME, AST_DEVICE_INUSE, AST_DEVICE_RINGING, AST_DEVICE_UNKNOWN, ast_get_channel_by_name_prefix_locked(), ast_mutex_unlock(), AST_STATE_RINGING, ast_channel::lock, and match(). Referenced by ast_device_state(). { struct ast_channel *chan; char match[AST_CHANNEL_NAME]; int res; ast_copy_string(match, device, sizeof(match)-1); strcat(match, "-"); chan = ast_get_channel_by_name_prefix_locked(match, strlen(match)); if (!chan) return AST_DEVICE_UNKNOWN; if (chan->_state == AST_STATE_RINGING) res = AST_DEVICE_RINGING; else res = AST_DEVICE_INUSE; ast_mutex_unlock(&chan->lock); return res; }

const char* devstate2str (  int  devstate  )

Convert device state to text string for output. Parameters: devstate  Current device state Definition at line 74 of file devicestate.c. References devstatestring. Referenced by __queues_show(), changethread(), and do_state_change(). { return devstatestring[devstate]; }

static void* do_devstate_changes (  void *  data  )  [static]

Definition at line 247 of file devicestate.c. References ast_cond_wait(), AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, change_pending, do_state_change(), free, and list. Referenced by ast_device_state_engine_init(). { struct state_change *cur; AST_LIST_LOCK(&state_changes); for(;;) { /* the list lock will _always_ be held at this point in the loop */ cur = AST_LIST_REMOVE_HEAD(&state_changes, list); if (cur) { /* we got an entry, so unlock the list while we process it */ AST_LIST_UNLOCK(&state_changes); do_state_change(cur->device); free(cur); AST_LIST_LOCK(&state_changes); } else { /* there was no entry, so atomically unlock the list and wait for the condition to be signalled (returns with the lock held) */ ast_cond_wait(&change_pending, &state_changes.lock); } } return NULL; }

static void do_state_change (  const char *  device  )  [static]

Definition at line 180 of file devicestate.c. References ast_device_state(), ast_hint_state_changed(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), devstate_cb::callback, devstate_cb::data, devstate2str(), list, LOG_DEBUG, and option_debug. Referenced by __ast_device_state_changed_literal(), and do_devstate_changes(). { int state; struct devstate_cb *devcb; state = ast_device_state(device); if (option_debug > 2) ast_log(LOG_DEBUG, "Changing state for %s - state %d (%s)\n", device, state, devstate2str(state)); AST_LIST_LOCK(&devstate_cbs); AST_LIST_TRAVERSE(&devstate_cbs, devcb, list) devcb->callback(device, state, devcb->data); AST_LIST_UNLOCK(&devstate_cbs); ast_hint_state_changed(device); }

---

Variable Documentation

ast_cond_t change_pending [static]

Definition at line 71 of file devicestate.c. Referenced by __ast_device_state_changed_literal(), ast_device_state_engine_init(), and do_devstate_changes().

pthread_t change_thread = AST_PTHREADT_NULL [static]

Definition at line 70 of file devicestate.c. Referenced by __ast_device_state_changed_literal(), and ast_device_state_engine_init().

const char* devstatestring[] [static]

Definition at line 44 of file devicestate.c. Referenced by devstate2str().

---