Sat Nov 1 06:28:20 2008

Asterisk developer's documentation

---

app_queue.c

Go to the documentation of this file.

/*
 * 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.
 */

/*! \file
 *
 * \brief True call queues with optional send URL on answer
 *
 * \author Mark Spencer <markster@digium.com>
 *
 * \arg Config in \ref Config_qu queues.conf
 *
 * \par Development notes
 * \note 2004-11-25: Persistent Dynamic Members added by:
 *             NetNation Communications (www.netnation.com)
 *             Kevin Lindsay <kevinl@netnation.com>
 *
 *             Each dynamic agent in each queue is now stored in the astdb.
 *             When asterisk is restarted, each agent will be automatically
 *             readded into their recorded queues. This feature can be
 *             configured with the 'persistent_members=<1|0>' setting in the
 *             '[general]' category in queues.conf. The default is on.
 *
 * \note 2004-06-04: Priorities in queues added by inAccess Networks (work funded by Hellas On Line (HOL) www.hol.gr).
 *
 * \note These features added by David C. Troy <dave@toad.net>:
 *    - Per-queue holdtime calculation
 *    - Estimated holdtime announcement
 *    - Position announcement
 *    - Abandoned/completed call counters
 *    - Failout timer passed as optional app parameter
 *    - Optional monitoring of calls, started when call is answered
 *
 * Patch Version 1.07 2003-12-24 01
 *
 * Added servicelevel statistic by Michiel Betel <michiel@betel.nl>
 * Added Priority jumping code for adding and removing queue members by Jonathan Stanton <asterisk@doilooklikeicare.com>
 *
 * Fixed to work with CVS as of 2004-02-25 and released as 1.07a
 * by Matthew Enger <m.enger@xi.com.au>
 *
 * \ingroup applications
 */

/*** MODULEINFO
        <depend>res_monitor</depend>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 152538 $")

#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <sys/signal.h>
#include <netinet/in.h>

#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/app.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/translate.h"
#include "asterisk/say.h"
#include "asterisk/features.h"
#include "asterisk/musiconhold.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/config.h"
#include "asterisk/monitor.h"
#include "asterisk/utils.h"
#include "asterisk/causes.h"
#include "asterisk/astdb.h"
#include "asterisk/devicestate.h"
#include "asterisk/stringfields.h"
#include "asterisk/astobj2.h"
#include "asterisk/global_datastores.h"

/* Please read before modifying this file.
 * There are three locks which are regularly used
 * throughout this file, the queue list lock, the lock
 * for each individual queue, and the interface list lock.
 * Please be extra careful to always lock in the following order
 * 1) queue list lock
 * 2) individual queue lock
 * 3) interface list lock
 * This order has sort of "evolved" over the lifetime of this
 * application, but it is now in place this way, so please adhere
 * to this order!
 */


enum {
   QUEUE_STRATEGY_RINGALL = 0,
   QUEUE_STRATEGY_ROUNDROBIN,
   QUEUE_STRATEGY_LEASTRECENT,
   QUEUE_STRATEGY_FEWESTCALLS,
   QUEUE_STRATEGY_RANDOM,
   QUEUE_STRATEGY_RRMEMORY
};

static struct strategy {
   int strategy;
   char *name;
} strategies[] = {
   { QUEUE_STRATEGY_RINGALL, "ringall" },
   { QUEUE_STRATEGY_ROUNDROBIN, "roundrobin" },
   { QUEUE_STRATEGY_LEASTRECENT, "leastrecent" },
   { QUEUE_STRATEGY_FEWESTCALLS, "fewestcalls" },
   { QUEUE_STRATEGY_RANDOM, "random" },
   { QUEUE_STRATEGY_RRMEMORY, "rrmemory" },
};

#define DEFAULT_RETRY      5
#define DEFAULT_TIMEOUT    15
#define RECHECK         1     /* Recheck every second to see we we're at the top yet */
#define MAX_PERIODIC_ANNOUNCEMENTS 10 /* The maximum periodic announcements we can have */

#define  RES_OKAY 0     /* Action completed */
#define  RES_EXISTS  (-1)     /* Entry already exists */
#define  RES_OUTOFMEMORY   (-2)     /* Out of memory */
#define  RES_NOSUCHQUEUE   (-3)     /* No such queue */
#define RES_NOT_DYNAMIC (-4)     /* Member is not dynamic */

static char *app = "Queue";

static char *synopsis = "Queue a call for a call queue";

static char *descrip =
"  Queue(queuename[|options[|URL][|announceoverride][|timeout][|AGI]):\n"
"Queues an incoming call in a particular call queue as defined in queues.conf.\n"
"This application will return to the dialplan if the queue does not exist, or\n"
"any of the join options cause the caller to not enter the queue.\n"
"The option string may contain zero or more of the following characters:\n"
"      'd' -- data-quality (modem) call (minimum delay).\n"
"      'h' -- allow callee to hang up by hitting '*', or whatver disconnect sequence\n"
"             defined in the featuremap section in features.conf.\n"
"      'H' -- allow caller to hang up by hitting '*', or whatever disconnect sequence\n"
"             defined in the featuremap section in features.conf.\n"
"      'n' -- no retries on the timeout; will exit this application and \n"
"             go to the next step.\n"
"      'i' -- ignore call forward requests from queue members and do nothing\n"
"             when they are requested.\n"
"      'r' -- ring instead of playing MOH\n"
"      't' -- allow the called user transfer the calling user by pressing '#' or\n"
"             whatever blindxfer sequence defined in the featuremap section in\n"
"             features.conf\n"
"      'T' -- to allow the calling user to transfer the call by pressing '#' or\n"
"             whatever blindxfer sequence defined in the featuremap section in\n"
"             features.conf\n"
"      'w' -- allow the called user to write the conversation to disk via Monitor\n"
"             by pressing the automon sequence defined in the featuremap section in\n"
"             features.conf\n"
"      'W' -- allow the calling user to write the conversation to disk via Monitor\n"
"             by pressing the automon sequence defined in the featuremap section in\n"
"             features.conf\n"
"  In addition to transferring the call, a call may be parked and then picked\n"
"up by another user, by transferring to the parking lot extension. See features.conf.\n"
"  The optional URL will be sent to the called party if the channel supports\n"
"it.\n"
"  The optional AGI parameter will setup an AGI script to be executed on the \n"
"calling party's channel once they are connected to a queue member.\n"
"  The timeout will cause the queue to fail out after a specified number of\n"
"seconds, checked between each queues.conf 'timeout' and 'retry' cycle.\n"
"  This application sets the following channel variable upon completion:\n"
"      QUEUESTATUS    The status of the call as a text string, one of\n"
"             TIMEOUT | FULL | JOINEMPTY | LEAVEEMPTY | JOINUNAVAIL | LEAVEUNAVAIL\n";

static char *app_aqm = "AddQueueMember" ;
static char *app_aqm_synopsis = "Dynamically adds queue members" ;
static char *app_aqm_descrip =
"   AddQueueMember(queuename[|interface[|penalty[|options[|membername]]]]):\n"
"Dynamically adds interface to an existing queue.\n"
"If the interface is already in the queue and there exists an n+101 priority\n"
"then it will then jump to this priority.  Otherwise it will return an error\n"
"The option string may contain zero or more of the following characters:\n"
"       'j' -- jump to +101 priority when appropriate.\n"
"  This application sets the following channel variable upon completion:\n"
"     AQMSTATUS    The status of the attempt to add a queue member as a \n"
"                     text string, one of\n"
"           ADDED | MEMBERALREADY | NOSUCHQUEUE \n"
"Example: AddQueueMember(techsupport|SIP/3000)\n"
"";

static char *app_rqm = "RemoveQueueMember" ;
static char *app_rqm_synopsis = "Dynamically removes queue members" ;
static char *app_rqm_descrip =
"   RemoveQueueMember(queuename[|interface[|options]]):\n"
"Dynamically removes interface to an existing queue\n"
"If the interface is NOT in the queue and there exists an n+101 priority\n"
"then it will then jump to this priority.  Otherwise it will return an error\n"
"The option string may contain zero or more of the following characters:\n"
"       'j' -- jump to +101 priority when appropriate.\n"
"  This application sets the following channel variable upon completion:\n"
"     RQMSTATUS      The status of the attempt to remove a queue member as a\n"
"                     text string, one of\n"
"           REMOVED | NOTINQUEUE | NOSUCHQUEUE \n"
"Example: RemoveQueueMember(techsupport|SIP/3000)\n"
"";

static char *app_pqm = "PauseQueueMember" ;
static char *app_pqm_synopsis = "Pauses a queue member" ;
static char *app_pqm_descrip =
"   PauseQueueMember([queuename]|interface[|options]):\n"
"Pauses (blocks calls for) a queue member.\n"
"The given interface will be paused in the given queue.  This prevents\n"
"any calls from being sent from the queue to the interface until it is\n"
"unpaused with UnpauseQueueMember or the manager interface.  If no\n"
"queuename is given, the interface is paused in every queue it is a\n"
"member of.  If the interface is not in the named queue, or if no queue\n"
"is given and the interface is not in any queue, it will jump to\n"
"priority n+101, if it exists and the appropriate options are set.\n"
"The application will fail if the interface is not found and no extension\n"
"to jump to exists.\n"
"The option string may contain zero or more of the following characters:\n"
"       'j' -- jump to +101 priority when appropriate.\n"
"  This application sets the following channel variable upon completion:\n"
"     PQMSTATUS      The status of the attempt to pause a queue member as a\n"
"                     text string, one of\n"
"           PAUSED | NOTFOUND\n"
"Example: PauseQueueMember(|SIP/3000)\n";

static char *app_upqm = "UnpauseQueueMember" ;
static char *app_upqm_synopsis = "Unpauses a queue member" ;
static char *app_upqm_descrip =
"   UnpauseQueueMember([queuename]|interface[|options]):\n"
"Unpauses (resumes calls to) a queue member.\n"
"This is the counterpart to PauseQueueMember and operates exactly the\n"
"same way, except it unpauses instead of pausing the given interface.\n"
"The option string may contain zero or more of the following characters:\n"
"       'j' -- jump to +101 priority when appropriate.\n"
"  This application sets the following channel variable upon completion:\n"
"     UPQMSTATUS       The status of the attempt to unpause a queue \n"
"                      member as a text string, one of\n"
"            UNPAUSED | NOTFOUND\n"
"Example: UnpauseQueueMember(|SIP/3000)\n";

static char *app_ql = "QueueLog" ;
static char *app_ql_synopsis = "Writes to the queue_log" ;
static char *app_ql_descrip =
"   QueueLog(queuename|uniqueid|agent|event[|additionalinfo]):\n"
"Allows you to write your own events into the queue log\n"
"Example: QueueLog(101|${UNIQUEID}|${AGENT}|WENTONBREAK|600)\n";

/*! \brief Persistent Members astdb family */
static const char *pm_family = "Queue/PersistentMembers";
/* The maximum length of each persistent member queue database entry */
#define PM_MAX_LEN 8192

/*! \brief queues.conf [general] option */
static int queue_persistent_members = 0;

/*! \brief queues.conf per-queue weight option */
static int use_weight = 0;

/*! \brief queues.conf [general] option */
static int autofill_default = 0;

/*! \brief queues.conf [general] option */
static int montype_default = 0;

enum queue_result {
   QUEUE_UNKNOWN = 0,
   QUEUE_TIMEOUT = 1,
   QUEUE_JOINEMPTY = 2,
   QUEUE_LEAVEEMPTY = 3,
   QUEUE_JOINUNAVAIL = 4,
   QUEUE_LEAVEUNAVAIL = 5,
   QUEUE_FULL = 6,
};

const struct {
   enum queue_result id;
   char *text;
} queue_results[] = {
   { QUEUE_UNKNOWN, "UNKNOWN" },
   { QUEUE_TIMEOUT, "TIMEOUT" },
   { QUEUE_JOINEMPTY,"JOINEMPTY" },
   { QUEUE_LEAVEEMPTY, "LEAVEEMPTY" },
   { QUEUE_JOINUNAVAIL, "JOINUNAVAIL" },
   { QUEUE_LEAVEUNAVAIL, "LEAVEUNAVAIL" },
   { QUEUE_FULL, "FULL" },
};

/*! \brief We define a custom "local user" structure because we
   use it not only for keeping track of what is in use but
   also for keeping track of who we're dialing.

   There are two "links" defined in this structure, q_next and call_next.
   q_next links ALL defined callattempt structures into a linked list. call_next is
   a link which allows for a subset of the callattempts to be traversed. This subset
   is used in wait_for_answer so that irrelevant callattempts are not traversed. This
   also is helpful so that queue logs are always accurate in the case where a call to 
   a member times out, especially if using the ringall strategy. */

struct callattempt {
   struct callattempt *q_next;
   struct callattempt *call_next;
   struct ast_channel *chan;
   char interface[256];
   int stillgoing;
   int metric;
   int oldstatus;
   time_t lastcall;
   struct member *member;
};


struct queue_ent {
   struct call_queue *parent;          /*!< What queue is our parent */
   char moh[80];                       /*!< Name of musiconhold to be used */
   char announce[80];                  /*!< Announcement to play for member when call is answered */
   char context[AST_MAX_CONTEXT];      /*!< Context when user exits queue */
   char digits[AST_MAX_EXTENSION];     /*!< Digits entered while in queue */
   int valid_digits;        /*!< Digits entered correspond to valid extension. Exited */
   int pos;                            /*!< Where we are in the queue */
   int prio;                           /*!< Our priority */
   int last_pos_said;                  /*!< Last position we told the user */
   time_t last_periodic_announce_time; /*!< The last time we played a periodic announcement */
   int last_periodic_announce_sound;   /*!< The last periodic announcement we made */
   time_t last_pos;                    /*!< Last time we told the user their position */
   int opos;                           /*!< Where we started in the queue */
   int handled;                        /*!< Whether our call was handled */
   int pending;                        /*!< Non-zero if we are attempting to call a member */
   int max_penalty;                    /*!< Limit the members that can take this call to this penalty or lower */
   time_t start;                       /*!< When we started holding */
   time_t expire;                      /*!< When this entry should expire (time out of queue) */
   struct ast_channel *chan;           /*!< Our channel */
   struct queue_ent *next;             /*!< The next queue entry */
};

struct member {
   char interface[80];                 /*!< Technology/Location */
   char membername[80];                /*!< Member name to use in queue logs */
   int penalty;                        /*!< Are we a last resort? */
   int calls;                          /*!< Number of calls serviced by this member */
   int dynamic;                        /*!< Are we dynamically added? */
   int realtime;                       /*!< Is this member realtime? */
   int status;                         /*!< Status of queue member */
   int paused;                         /*!< Are we paused (not accepting calls)? */
   time_t lastcall;                    /*!< When last successful call was hungup */
   unsigned int dead:1;                /*!< Used to detect members deleted in realtime */
   unsigned int delme:1;               /*!< Flag to delete entry on reload */
};

struct member_interface {
   char interface[80];
   AST_LIST_ENTRY(member_interface) list;    /*!< Next call queue */
};

static AST_LIST_HEAD_STATIC(interfaces, member_interface);

/* values used in multi-bit flags in call_queue */
#define QUEUE_EMPTY_NORMAL 1
#define QUEUE_EMPTY_STRICT 2
#define ANNOUNCEHOLDTIME_ALWAYS 1
#define ANNOUNCEHOLDTIME_ONCE 2
#define QUEUE_EVENT_VARIABLES 3

struct call_queue {
   ast_mutex_t lock; 
   char name[80];                      /*!< Name */
   char moh[80];                       /*!< Music On Hold class to be used */
   char announce[80];                  /*!< Announcement to play when call is answered */
   char context[AST_MAX_CONTEXT];      /*!< Exit context */
   unsigned int monjoin:1;
   unsigned int dead:1;
   unsigned int joinempty:2;
   unsigned int eventwhencalled:2;
   unsigned int leavewhenempty:2;
   unsigned int ringinuse:1;
   unsigned int setinterfacevar:1;
   unsigned int reportholdtime:1;
   unsigned int wrapped:1;
   unsigned int timeoutrestart:1;
   unsigned int announceholdtime:2;
   int strategy:4;
   unsigned int maskmemberstatus:1;
   unsigned int realtime:1;
   unsigned int found:1;
   int announcefrequency;              /*!< How often to announce their position */
   int periodicannouncefrequency;      /*!< How often to play periodic announcement */
   int roundingseconds;                /*!< How many seconds do we round to? */
   int holdtime;                       /*!< Current avg holdtime, based on an exponential average */
   int callscompleted;                 /*!< Number of queue calls completed */
   int callsabandoned;                 /*!< Number of queue calls abandoned */
   int servicelevel;                   /*!< seconds setting for servicelevel*/
   int callscompletedinsl;             /*!< Number of calls answered with servicelevel*/
   char monfmt[8];                     /*!< Format to use when recording calls */
   int montype;                        /*!< Monitor type  Monitor vs. MixMonitor */
   char sound_next[80];                /*!< Sound file: "Your call is now first in line" (def. queue-youarenext) */
   char sound_thereare[80];            /*!< Sound file: "There are currently" (def. queue-thereare) */
   char sound_calls[80];               /*!< Sound file: "calls waiting to speak to a representative." (def. queue-callswaiting)*/
   char sound_holdtime[80];            /*!< Sound file: "The current estimated total holdtime is" (def. queue-holdtime) */
   char sound_minutes[80];             /*!< Sound file: "minutes." (def. queue-minutes) */
   char sound_lessthan[80];            /*!< Sound file: "less-than" (def. queue-lessthan) */
   char sound_seconds[80];             /*!< Sound file: "seconds." (def. queue-seconds) */
   char sound_thanks[80];              /*!< Sound file: "Thank you for your patience." (def. queue-thankyou) */
   char sound_reporthold[80];          /*!< Sound file: "Hold time" (def. queue-reporthold) */
   char sound_periodicannounce[MAX_PERIODIC_ANNOUNCEMENTS][80];/*!< Sound files: Custom announce, no default */

   int count;                          /*!< How many entries */
   int maxlen;                         /*!< Max number of entries */
   int wrapuptime;                     /*!< Wrapup Time */

   int retry;                          /*!< Retry calling everyone after this amount of time */
   int timeout;                        /*!< How long to wait for an answer */
   int weight;                         /*!< Respective weight */
   int autopause;                      /*!< Auto pause queue members if they fail to answer */

   /* Queue strategy things */
   int rrpos;                          /*!< Round Robin - position */
   int memberdelay;                    /*!< Seconds to delay connecting member to caller */
   int autofill;                       /*!< Ignore the head call status and ring an available agent */
   
   struct ao2_container *members;             /*!< Head of the list of members */
   /*! 
    * \brief Number of members _logged in_
    * \note There will be members in the members container that are not logged
    *       in, so this can not simply be replaced with ao2_container_count(). 
    */
   int membercount;
   struct queue_ent *head;             /*!< Head of the list of callers */
   AST_LIST_ENTRY(call_queue) list;    /*!< Next call queue */
};

static AST_LIST_HEAD_STATIC(queues, call_queue);

static int set_member_paused(const char *queuename, const char *interface, int paused);

static void queue_transfer_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan); 

static void rr_dep_warning(void)
{
   static unsigned int warned = 0;

   if (!warned) {
      ast_log(LOG_NOTICE, "The 'roundrobin' queue strategy is deprecated. Please use the 'rrmemory' strategy instead.\n");
      warned = 1;
   }
}

static void monjoin_dep_warning(void)
{
   static unsigned int warned = 0;
   if (!warned) {
      ast_log(LOG_NOTICE, "The 'monitor-join' queue option is deprecated. Please use monitor-type=mixmonitor instead.\n");
      warned = 1;
   }
}
/*! \brief sets the QUEUESTATUS channel variable */
static void set_queue_result(struct ast_channel *chan, enum queue_result res)
{
   int i;

   for (i = 0; i < sizeof(queue_results) / sizeof(queue_results[0]); i++) {
      if (queue_results[i].id == res) {
         pbx_builtin_setvar_helper(chan, "QUEUESTATUS", queue_results[i].text);
         return;
      }
   }
}

static char *int2strat(int strategy)
{
   int x;

   for (x = 0; x < sizeof(strategies) / sizeof(strategies[0]); x++) {
      if (strategy == strategies[x].strategy)
         return strategies[x].name;
   }

   return "<unknown>";
}

static int strat2int(const char *strategy)
{
   int x;

   for (x = 0; x < sizeof(strategies) / sizeof(strategies[0]); x++) {
      if (!strcasecmp(strategy, strategies[x].name))
         return strategies[x].strategy;
   }

   return -1;
}

/*! \brief Insert the 'new' entry after the 'prev' entry of queue 'q' */
static inline void insert_entry(struct call_queue *q, struct queue_ent *prev, struct queue_ent *new, int *pos)
{
   struct queue_ent *cur;

   if (!q || !new)
      return;
   if (prev) {
      cur = prev->next;
      prev->next = new;
   } else {
      cur = q->head;
      q->head = new;
   }
   new->next = cur;
   new->parent = q;
   new->pos = ++(*pos);
   new->opos = *pos;
}

enum queue_member_status {
   QUEUE_NO_MEMBERS,
   QUEUE_NO_REACHABLE_MEMBERS,
   QUEUE_NORMAL
};

/*! \brief Check if members are available
 *
 * This function checks to see if members are available to be called. If any member
 * is available, the function immediately returns QUEUE_NORMAL. If no members are available,
 * the appropriate reason why is returned
 */
static enum queue_member_status get_member_status(struct call_queue *q, int max_penalty)
{
   struct member *member;
   struct ao2_iterator mem_iter;
   enum queue_member_status result = QUEUE_NO_MEMBERS;

   ast_mutex_lock(&q->lock);
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((member = ao2_iterator_next(&mem_iter))) {
      if (max_penalty && (member->penalty > max_penalty)) {
         ao2_ref(member, -1);
         continue;
      }

      if (member->paused) {
         ao2_ref(member, -1);
         continue;
      }

      switch (member->status) {
      case AST_DEVICE_INVALID:
         /* nothing to do */
         ao2_ref(member, -1);
         break;
      case AST_DEVICE_UNAVAILABLE:
         result = QUEUE_NO_REACHABLE_MEMBERS;
         ao2_ref(member, -1);
         break;
      default:
         ast_mutex_unlock(&q->lock);
         ao2_ref(member, -1);
         return QUEUE_NORMAL;
      }
   }

   ast_mutex_unlock(&q->lock);
   return result;
}

struct statechange {
   AST_LIST_ENTRY(statechange) entry;
   int state;
   char dev[0];
};

static int update_status(const char *interface, const int status)
{
   struct member *cur;
   struct ao2_iterator mem_iter;
   struct call_queue *q;

   AST_LIST_LOCK(&queues);
   AST_LIST_TRAVERSE(&queues, q, list) {
      ast_mutex_lock(&q->lock);
      mem_iter = ao2_iterator_init(q->members, 0);
      while ((cur = ao2_iterator_next(&mem_iter))) {
         char *tmp_interface;
         char *slash_pos;
         tmp_interface = ast_strdupa(cur->interface);
         if ((slash_pos = strchr(tmp_interface, '/')))
            if ((slash_pos = strchr(slash_pos + 1, '/')))
               *slash_pos = '\0';

         if (strcasecmp(interface, tmp_interface)) {
            ao2_ref(cur, -1);
            continue;
         }

         if (cur->status != status) {
            cur->status = status;
            if (q->maskmemberstatus) {
               ao2_ref(cur, -1);
               continue;
            }

            manager_event(EVENT_FLAG_AGENT, "QueueMemberStatus",
               "Queue: %s\r\n"
               "Location: %s\r\n"
               "MemberName: %s\r\n"
               "Membership: %s\r\n"
               "Penalty: %d\r\n"
               "CallsTaken: %d\r\n"
               "LastCall: %d\r\n"
               "Status: %d\r\n"
               "Paused: %d\r\n",
               q->name, cur->interface, cur->membername, cur->dynamic ? "dynamic" : cur->realtime ? "realtime" : "static",
               cur->penalty, cur->calls, (int)cur->lastcall, cur->status, cur->paused);
         }
         ao2_ref(cur, -1);
      }
      ast_mutex_unlock(&q->lock);
   }
   AST_LIST_UNLOCK(&queues);

   return 0;
}

/*! \brief set a member's status based on device state of that member's interface*/
static void *handle_statechange(struct statechange *sc)
{
   struct member_interface *curint;
   char *loc;
   char *technology;

   technology = ast_strdupa(sc->dev);
   loc = strchr(technology, '/');
   if (loc) {
      *loc++ = '\0';
   } else {
      return NULL;
   }

   AST_LIST_LOCK(&interfaces);
   AST_LIST_TRAVERSE(&interfaces, curint, list) {
      char *interface;
      char *slash_pos;
      interface = ast_strdupa(curint->interface);
      if ((slash_pos = strchr(interface, '/')))
         if ((slash_pos = strchr(slash_pos + 1, '/')))
            *slash_pos = '\0';

      if (!strcasecmp(interface, sc->dev))
         break;
   }
   AST_LIST_UNLOCK(&interfaces);

   if (!curint) {
      if (option_debug > 2)
         ast_log(LOG_DEBUG, "Device '%s/%s' changed to state '%d' (%s) but we don't care because they're not a member of any queue.\n", technology, loc, sc->state, devstate2str(sc->state));
      return NULL;
   }

   if (option_debug)
      ast_log(LOG_DEBUG, "Device '%s/%s' changed to state '%d' (%s)\n", technology, loc, sc->state, devstate2str(sc->state));

   update_status(sc->dev, sc->state);

   return NULL;
}

/*!
 * \brief Data used by the device state thread
 */
static struct {
   /*! Set to 1 to stop the thread */
   unsigned int stop:1;
   /*! The device state monitoring thread */
   pthread_t thread;
   /*! Lock for the state change queue */
   ast_mutex_t lock;
   /*! Condition for the state change queue */
   ast_cond_t cond;
   /*! Queue of state changes */
   AST_LIST_HEAD_NOLOCK(, statechange) state_change_q;
} device_state = {
   .thread = AST_PTHREADT_NULL,
};

/*! \brief Consumer of the statechange queue */
static void *device_state_thread(void *data)
{
   struct statechange *sc = NULL;

   while (!device_state.stop) {
      ast_mutex_lock(&device_state.lock);
      if (!(sc = AST_LIST_REMOVE_HEAD(&device_state.state_change_q, entry))) {
         ast_cond_wait(&device_state.cond, &device_state.lock);
         sc = AST_LIST_REMOVE_HEAD(&device_state.state_change_q, entry);
      }
      ast_mutex_unlock(&device_state.lock);

      /* Check to see if we were woken up to see the request to stop */
      if (device_state.stop)
         break;

      if (!sc)
         continue;

      handle_statechange(sc);

      free(sc);
      sc = NULL;
   }

   if (sc)
      free(sc);

   while ((sc = AST_LIST_REMOVE_HEAD(&device_state.state_change_q, entry)))
      free(sc);

   return NULL;
}
/*! \brief Producer of the statechange queue */
static int statechange_queue(const char *dev, int state, void *ign)
{
   struct statechange *sc;

   if (!(sc = ast_calloc(1, sizeof(*sc) + strlen(dev) + 1)))
      return 0;

   sc->state = state;
   strcpy(sc->dev, dev);

   ast_mutex_lock(&device_state.lock);
   AST_LIST_INSERT_TAIL(&device_state.state_change_q, sc, entry);
   ast_cond_signal(&device_state.cond);
   ast_mutex_unlock(&device_state.lock);

   return 0;
}
/*! \brief allocate space for new queue member and set fields based on parameters passed */
static struct member *create_queue_member(const char *interface, const char *membername, int penalty, int paused)
{
   struct member *cur;
   
   if ((cur = ao2_alloc(sizeof(*cur), NULL))) {
      cur->penalty = penalty;
      cur->paused = paused;
      ast_copy_string(cur->interface, interface, sizeof(cur->interface));
      if (!ast_strlen_zero(membername))
         ast_copy_string(cur->membername, membername, sizeof(cur->membername));
      else
         ast_copy_string(cur->membername, interface, sizeof(cur->membername));
      if (!strchr(cur->interface, '/'))
         ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
      cur->status = ast_device_state(interface);
   }

   return cur;
}

static struct call_queue *alloc_queue(const char *queuename)
{
   struct call_queue *q;

   if ((q = ast_calloc(1, sizeof(*q)))) {
      ast_mutex_init(&q->lock);
      ast_copy_string(q->name, queuename, sizeof(q->name));
   }
   return q;
}

static int compress_char(const char c)
{
   if (c < 32)
      return 0;
   else if (c > 96)
      return c - 64;
   else
      return c - 32;
}

static int member_hash_fn(const void *obj, const int flags)
{
   const struct member *mem = obj;
   const char *chname = strchr(mem->interface, '/');
   int ret = 0, i;
   if (!chname)
      chname = mem->interface;
   for (i = 0; i < 5 && chname[i]; i++)
      ret += compress_char(chname[i]) << (i * 6);
   return ret;
}

static int member_cmp_fn(void *obj1, void *obj2, int flags)
{
   struct member *mem1 = obj1, *mem2 = obj2;
   return strcmp(mem1->interface, mem2->interface) ? 0 : CMP_MATCH | CMP_STOP;
}

static void init_queue(struct call_queue *q)
{
   int i;

   q->dead = 0;
   q->retry = DEFAULT_RETRY;
   q->timeout = -1;
   q->maxlen = 0;
   q->announcefrequency = 0;
   q->announceholdtime = 0;
   q->roundingseconds = 0; /* Default - don't announce seconds */
   q->servicelevel = 0;
   q->ringinuse = 1;
   q->setinterfacevar = 0;
   q->autofill = autofill_default;
   q->montype = montype_default;
   q->moh[0] = '\0';
   q->announce[0] = '\0';
   q->context[0] = '\0';
   q->monfmt[0] = '\0';
   q->periodicannouncefrequency = 0;
   q->reportholdtime = 0;
   q->monjoin = 0;
   q->wrapuptime = 0;
   q->joinempty = 0;
   q->leavewhenempty = 0;
   q->memberdelay = 0;
   q->maskmemberstatus = 0;
   q->eventwhencalled = 0;
   q->weight = 0;
   q->timeoutrestart = 0;
   if (!q->members)
      q->members = ao2_container_alloc(37, member_hash_fn, member_cmp_fn);
   q->membercount = 0;
   q->found = 1;
   ast_copy_string(q->sound_next, "queue-youarenext", sizeof(q->sound_next));
   ast_copy_string(q->sound_thereare, "queue-thereare", sizeof(q->sound_thereare));
   ast_copy_string(q->sound_calls, "queue-callswaiting", sizeof(q->sound_calls));
   ast_copy_string(q->sound_holdtime, "queue-holdtime", sizeof(q->sound_holdtime));
   ast_copy_string(q->sound_minutes, "queue-minutes", sizeof(q->sound_minutes));
   ast_copy_string(q->sound_seconds, "queue-seconds", sizeof(q->sound_seconds));
   ast_copy_string(q->sound_thanks, "queue-thankyou", sizeof(q->sound_thanks));
   ast_copy_string(q->sound_lessthan, "queue-less-than", sizeof(q->sound_lessthan));
   ast_copy_string(q->sound_reporthold, "queue-reporthold", sizeof(q->sound_reporthold));
   ast_copy_string(q->sound_periodicannounce[0], "queue-periodic-announce", sizeof(q->sound_periodicannounce[0]));
   for (i = 1; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
      q->sound_periodicannounce[i][0]='\0';
   }
}

static void clear_queue(struct call_queue *q)
{
   q->holdtime = 0;
   q->callscompleted = 0;
   q->callsabandoned = 0;
   q->callscompletedinsl = 0;
   q->wrapuptime = 0;
}

static int add_to_interfaces(const char *