Skip to content
Snippets Groups Projects
devicestate.c 10.2 KiB
Newer Older
  • Learn to ignore specific revisions
  •  * Asterisk -- An open source telephony toolkit.
    
     * Copyright (C) 1999 - 2006, Digium, Inc.
    
     *
     * Mark Spencer <markster@digium.com>
     *
     * See http://www.asterisk.org for more information about
     * the Asterisk project. Please do not directly contact
     * any of the maintainers of this project for assistance;
     * the project provides a web site, mailing lists and IRC
     * channels for your use.
    
     *
     * This program is free software, distributed under the terms of
    
     * the GNU General Public License Version 2. See the LICENSE file
     * at the top of the source tree.
     */
    
    
     * \brief Device state management
    
     *
     * \author Mark Spencer <markster@digium.com> 
    
    #include "asterisk.h"
    
    ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
    
    
    #include <sys/types.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    
    Kevin P. Fleming's avatar
    Kevin P. Fleming committed
    #include <stdio.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"
    
    Olle Johansson's avatar
    Olle Johansson committed
    #include "asterisk/app.h"
    
    #include "asterisk/options.h"
    
    
    /*! \brief Device state strings for printing */
    
    static const char *devstatestring[] = {
    
    	/* 0 AST_DEVICE_UNKNOWN */	"Unknown",	/*!< Valid, but unknown state */
    	/* 1 AST_DEVICE_NOT_INUSE */	"Not in use",	/*!< Not used */
    	/* 2 AST_DEVICE IN USE */	"In use",	/*!< In use */
    	/* 3 AST_DEVICE_BUSY */		"Busy",		/*!< Busy */
    	/* 4 AST_DEVICE_INVALID */	"Invalid",	/*!< Invalid - not known to Asterisk */
    	/* 5 AST_DEVICE_UNAVAILABLE */	"Unavailable",	/*!< Unavailable (not registred) */
    
    	/* 6 AST_DEVICE_RINGING */	"Ringing",	/*!< Ring, ring, ring */
    	/* 7 AST_DEVICE_RINGINUSE */	"Ring+Inuse",	/*!< Ring and in use */
    
    	/* 8 AST_DEVICE_ONHOLD */	"On Hold"	/*!< On Hold */
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief  A device state provider (not a channel) */
    struct devstate_prov {
    	char label[40];
    	ast_devstate_prov_cb_type callback;
    	AST_LIST_ENTRY(devstate_prov) list;
    };
    
    /*! \brief A list of providers */
    static AST_LIST_HEAD_STATIC(devstate_provs, devstate_prov);
    
    
    /*! \brief  A device state watcher (callback) */
    
    struct devstate_cb {
    	void *data;
    	ast_devstate_cb_type callback;
    	AST_LIST_ENTRY(devstate_cb) list;
    };
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief A device state watcher list */
    
    static AST_LIST_HEAD_STATIC(devstate_cbs, devstate_cb);
    
    struct state_change {
    	AST_LIST_ENTRY(state_change) list;
    	char device[1];
    };
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief The state change queue. State changes are queued
    	for processing by a separate thread */
    
    static AST_LIST_HEAD_STATIC(state_changes, state_change);
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief The device state change notification thread */
    
    static pthread_t change_thread = AST_PTHREADT_NULL;
    
    Olle Johansson's avatar
    Olle Johansson committed
    
    /*! \brief Flag for the queue */
    
    Olle Johansson's avatar
    Olle Johansson committed
    /* Forward declarations */
    static int getproviderstate(const char *provider, const char *address);
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Find devicestate as text message for output */
    
    const char *devstate2str(int devstate) 
    {
    	return devstatestring[devstate];
    }
    
    
    /*! \brief Find out if device is active in a call or not 
    
    Olle Johansson's avatar
    Olle Johansson committed
    	\note find channels with the device's name in it
    	This function is only used for channels that does not implement 
    	devicestate natively
    
    int ast_parse_device_state(const char *device)
    {
    	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_channel_unlock(chan);
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Check device state through channel specific function or generic function */
    
    int ast_device_state(const char *device)
    {
    	char *buf;
    	char *number;
    	const struct ast_channel_tech *chan_tech;
    	int res = 0;
    
    Olle Johansson's avatar
    Olle Johansson committed
    	/*! \brief Channel driver that provides device state */
    	char *tech;
    	/*! \brief Another provider of device state */
    	char *provider = NULL;
    
    	
    	buf = ast_strdupa(device);
    	tech = strsep(&buf, "/");
    	number = buf;
    
    Olle Johansson's avatar
    Olle Johansson committed
    	if (!number) {
    		provider = strsep(&tech, ":");
    		if (!provider)
    			return AST_DEVICE_INVALID;
    		/* We have a provider */
    		number = tech;
    		tech = NULL;
    	}
    
    	if (provider)  {
    		if(option_debug > 2)
    			ast_log(LOG_DEBUG, "Checking if I can find provider for \"%s\" - number: %s\n", provider, number);
    		return getproviderstate(provider, number);
    	}
    	if (option_debug > 3)
    		ast_log(LOG_DEBUG, "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;
    
    
    	if (!chan_tech->devicestate) 	/* Does the channel driver support device state notification? */
    		return ast_parse_device_state(device);	/* No, try the generic function */
    
    		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
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Add device state provider */
    int ast_devstate_prov_add(const char *label, ast_devstate_prov_cb_type callback)
    {
    	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_LIST_LOCK(&devstate_provs);
    	AST_LIST_INSERT_HEAD(&devstate_provs, devprov, list);
    	AST_LIST_UNLOCK(&devstate_provs);
    
    	return 0;
    }
    
    /*! \brief Remove device state provider */
    void ast_devstate_prov_del(const char *label)
    {
    	struct devstate_prov *devcb;
    
    	AST_LIST_LOCK(&devstate_provs);
    	AST_LIST_TRAVERSE_SAFE_BEGIN(&devstate_provs, devcb, list) {
    		if (!strcasecmp(devcb->label, label)) {
    			AST_LIST_REMOVE_CURRENT(&devstate_provs, list);
    			free(devcb);
    			break;
    		}
    	}
    	AST_LIST_TRAVERSE_SAFE_END;
    	AST_LIST_UNLOCK(&devstate_provs);
    }
    
    /*! \brief Get provider device state */
    static int getproviderstate(const char *provider, const char *address)
    {
    	struct devstate_prov *devprov;
    	int res = AST_DEVICE_INVALID;
    
    
    	AST_LIST_LOCK(&devstate_provs);
    	AST_LIST_TRAVERSE_SAFE_BEGIN(&devstate_provs, devprov, list) {
    		if(option_debug > 4)
    			ast_log(LOG_DEBUG, "Checking provider %s with %s\n", devprov->label, provider);
    
    		if (!strcasecmp(devprov->label, provider)) {
    			res = devprov->callback(address);
    			break;
    		}
    	}
    	AST_LIST_TRAVERSE_SAFE_END;
    	AST_LIST_UNLOCK(&devstate_provs);
    	return res;
    }
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Add device state watcher */
    
    int ast_devstate_add(ast_devstate_cb_type callback, void *data)
    {
    	struct devstate_cb *devcb;
    
    
    	if (!callback || !(devcb = ast_calloc(1, sizeof(*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;
    }
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Remove device state watcher */
    
    void ast_devstate_del(ast_devstate_cb_type callback, void *data)
    {
    	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);
    }
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Notify callback watchers of change, and notify PBX core for hint updates
    	Normally executed within a separate thread
    */
    
    static void do_state_change(const char *device)
    {
    	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);
    }
    
    
    static int __ast_device_state_changed_literal(char *buf)
    
    Olle Johansson's avatar
    Olle Johansson committed
    	if (option_debug > 2)
    		ast_log(LOG_DEBUG, "Notification of state change to be queued on device/channel %s\n", buf);
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    	
    
    
    	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);
    	} 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_LIST_UNLOCK(&state_changes);
    
    int ast_device_state_changed_literal(const char *dev)
    {
    	char *buf;
    	buf = ast_strdupa(dev);
    	return __ast_device_state_changed_literal(buf);
    }
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Accept change notification, add it to change queue */
    
    int ast_device_state_changed(const char *fmt, ...) 
    {
    	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);
    }
    
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Go through the dev state change queue and update changes in the dev state thread */
    
    static void *do_devstate_changes(void *data)
    
    {
    	struct state_change *cur;
    
    
    	AST_LIST_LOCK(&state_changes);
    
    		/* 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);
    
    Olle Johansson's avatar
    Olle Johansson committed
    /*! \brief Initialize the device state engine in separate thread */
    
    int ast_device_state_engine_init(void)
    {
    
    	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;
    }