app_queue.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2018, 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>
 *
 * \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
 */
 
/*! \li \ref app_queues.c uses configuration file \ref queues.conf
 * \addtogroup configuration_file
 */
 
/*! \page queues.conf queues.conf
 * \verbinclude queues.conf.sample
 */
 
/*** MODULEINFO
   <use type="module">res_monitor</use>
   <support_level>core</support_level>
 ***/
 
#include "asterisk.h"
 
#include <sys/time.h>
#include <signal.h>
#include <netinet/in.h>
#include <ctype.h>
 
#include "asterisk/lock.h"
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.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/strings.h"
#include "asterisk/taskprocessor.h"
#include "asterisk/aoc.h"
#include "asterisk/callerid.h"
#include "asterisk/term.h"
#include "asterisk/dial.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/bridge_after.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/core_local.h"
#include "asterisk/mixmonitor.h"
#include "asterisk/bridge_basic.h"
#include "asterisk/max_forwards.h"
 
/*!
 * \par 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!
 */
 
/*** DOCUMENTATION
   <application name="Queue" language="en_US">
      <synopsis>
         Queue a call for a call queue.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="options">
            <optionlist>
               <option name="b" argsep="^">
                  <para>Before initiating an outgoing call, <literal>Gosub</literal> to the specified
                  location using the newly created channel.  The <literal>Gosub</literal> will be
                  executed for each destination channel.</para>
                  <argument name="context" required="false" />
                  <argument name="exten" required="false" />
                  <argument name="priority" required="true" hasparams="optional" argsep="^">
                     <argument name="arg1" multiple="true" required="true" />
                     <argument name="argN" />
                  </argument>
               </option>
               <option name="B" argsep="^">
                  <para>Before initiating the outgoing call(s), <literal>Gosub</literal> to the
                  specified location using the current channel.</para>
                  <argument name="context" required="false" />
                  <argument name="exten" required="false" />
                  <argument name="priority" required="true" hasparams="optional" argsep="^">
                     <argument name="arg1" multiple="true" required="true" />
                     <argument name="argN" />
                  </argument>
               </option>
               <option name="C">
                  <para>Mark all calls as "answered elsewhere" when cancelled.</para>
               </option>
               <option name="c">
                  <para>Continue in the dialplan if the callee hangs up.</para>
               </option>
               <option name="d">
                  <para>data-quality (modem) call (minimum delay).</para>
               </option>
               <option name="F" argsep="^">
                  <argument name="context" required="false" />
                  <argument name="exten" required="false" />
                  <argument name="priority" required="true" />
                  <para>When the caller hangs up, transfer the <emphasis>called member</emphasis>
                  to the specified destination and <emphasis>start</emphasis> execution at that location.</para>
                  <para>NOTE: Any channel variables you want the called channel to inherit from the caller channel must be
                  prefixed with one or two underbars ('_').</para>
               </option>
               <option name="F">
                  <para>When the caller hangs up, transfer the <emphasis>called member</emphasis> to the next priority of
                  the current extension and <emphasis>start</emphasis> execution at that location.</para>
                  <para>NOTE: Any channel variables you want the called channel to inherit from the caller channel must be
                  prefixed with one or two underbars ('_').</para>
                  <para>NOTE: Using this option from a Macro() or GoSub() might not make sense as there would be no return points.</para>
               </option>
               <option name="h">
                  <para>Allow <emphasis>callee</emphasis> to hang up by pressing <literal>*</literal>.</para>
               </option>
               <option name="H">
                  <para>Allow <emphasis>caller</emphasis> to hang up by pressing <literal>*</literal>.</para>
               </option>
               <option name="n">
                  <para>No retries on the timeout; will exit this application and
                  go to the next step.</para>
               </option>
               <option name="i">
                  <para>Ignore call forward requests from queue members and do nothing
                  when they are requested.</para>
               </option>
               <option name="I">
                  <para>Asterisk will ignore any connected line update requests or any redirecting party
                  update requests it may receive on this dial attempt.</para>
               </option>
               <option name="r">
                  <para>Ring instead of playing MOH. Periodic Announcements are still made, if applicable.</para>
               </option>
               <option name="R">
                  <para>Ring instead of playing MOH when a member channel is actually ringing.</para>
               </option>
               <option name="t">
                  <para>Allow the <emphasis>called</emphasis> user to transfer the calling user.</para>
               </option>
               <option name="T">
                  <para>Allow the <emphasis>calling</emphasis> user to transfer the call.</para>
               </option>
               <option name="w">
                  <para>Allow the <emphasis>called</emphasis> user to write the conversation to
                  disk via Monitor.</para>
               </option>
               <option name="W">
                  <para>Allow the <emphasis>calling</emphasis> user to write the conversation to
                  disk via Monitor.</para>
               </option>
               <option name="k">
                  <para>Allow the <emphasis>called</emphasis> party to enable parking of the call by sending
                  the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
               </option>
               <option name="K">
                  <para>Allow the <emphasis>calling</emphasis> party to enable parking of the call by sending
                  the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
               </option>
               <option name="x">
                  <para>Allow the <emphasis>called</emphasis> user to write the conversation
                  to disk via MixMonitor.</para>
               </option>
               <option name="X">
                  <para>Allow the <emphasis>calling</emphasis> user to write the conversation to
                  disk via MixMonitor.</para>
               </option>
            </optionlist>
         </parameter>
         <parameter name="URL">
            <para><replaceable>URL</replaceable> will be sent to the called party if the channel supports it.</para>
         </parameter>
         <parameter name="announceoverride" argsep="&amp;">
            <argument name="filename" required="true">
               <para>Announcement file(s) to play to agent before bridging call, overriding the announcement(s)
               configured in <filename>queues.conf</filename>, if any.</para>
            </argument>
            <argument name="filename2" multiple="true" />
         </parameter>
         <parameter name="timeout">
            <para>Will cause the queue to fail out after a specified number of
            seconds, checked between each <filename>queues.conf</filename> <replaceable>timeout</replaceable> and
            <replaceable>retry</replaceable> cycle.</para>
         </parameter>
         <parameter name="AGI">
            <para>Will setup an AGI script to be executed on the calling party's channel once they are
            connected to a queue member.</para>
         </parameter>
         <parameter name="macro">
            <para>Will run a macro on the called party's channel (the queue member) once the parties are connected.</para>
            <para>NOTE: Macros are deprecated, GoSub should be used instead.</para>
         </parameter>
         <parameter name="gosub">
            <para>Will run a gosub on the called party's channel (the queue member)
            once the parties are connected.  The subroutine execution starts in the
            named context at the s exten and priority 1.</para>
         </parameter>
         <parameter name="rule">
            <para>Will cause the queue's defaultrule to be overridden by the rule specified.</para>
         </parameter>
         <parameter name="position">
            <para>Attempt to enter the caller into the queue at the numerical position specified. <literal>1</literal>
            would attempt to enter the caller at the head of the queue, and <literal>3</literal> would attempt to place
            the caller third in the queue.</para>
         </parameter>
      </syntax>
      <description>
         <para>In addition to transferring the call, a call may be parked and then picked
         up by another user.</para>
         <para>This application will return to the dialplan if the queue does not exist, or
         any of the join options cause the caller to not enter the queue.</para>
         <para>This application does not automatically answer and should be preceeded
         by an application such as Answer(), Progress(), or Ringing().</para>
         <para>This application sets the following channel variables upon completion:</para>
         <variablelist>
            <variable name="QUEUESTATUS">
               <para>The status of the call as a text string.</para>
               <value name="TIMEOUT" />
               <value name="FULL" />
               <value name="JOINEMPTY" />
               <value name="LEAVEEMPTY" />
               <value name="JOINUNAVAIL" />
               <value name="LEAVEUNAVAIL" />
               <value name="CONTINUE" />
            </variable>
            <variable name="ABANDONED">
               <para>If the call was not answered by an agent this variable will be TRUE.</para>
               <value name="TRUE" />
            </variable>
         </variablelist>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="AddQueueMember" language="en_US">
      <synopsis>
         Dynamically adds queue members.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="interface" />
         <parameter name="penalty" />
         <parameter name="options" />
         <parameter name="membername" />
         <parameter name="stateinterface" />
         <parameter name="wrapuptime" />
      </syntax>
      <description>
         <para>Dynamically adds interface to an existing queue. If the interface is
         already in the queue it will return an error.</para>
         <para>This application sets the following channel variable upon completion:</para>
         <variablelist>
            <variable name="AQMSTATUS">
               <para>The status of the attempt to add a queue member as a text string.</para>
               <value name="ADDED" />
               <value name="MEMBERALREADY" />
               <value name="NOSUCHQUEUE" />
            </variable>
         </variablelist>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="RemoveQueueMember" language="en_US">
      <synopsis>
         Dynamically removes queue members.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="interface" />
      </syntax>
      <description>
         <para>If the interface is <emphasis>NOT</emphasis> in the queue it will return an error.</para>
         <para>This application sets the following channel variable upon completion:</para>
         <variablelist>
            <variable name="RQMSTATUS">
               <value name="REMOVED" />
               <value name="NOTINQUEUE" />
               <value name="NOSUCHQUEUE" />
               <value name="NOTDYNAMIC" />
            </variable>
         </variablelist>
         <para>Example: RemoveQueueMember(techsupport,SIP/3000)</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="PauseQueueMember" language="en_US">
      <synopsis>
         Pauses a queue member.
      </synopsis>
      <syntax>
         <parameter name="queuename" />
         <parameter name="interface" required="true" />
         <parameter name="options" />
         <parameter name="reason">
            <para>Is used to add extra information to the appropriate queue_log entries and manager events.</para>
         </parameter>
      </syntax>
      <description>
         <para>Pauses (blocks calls for) a queue member. The given interface will be paused in the given queue.
         This prevents any calls from being sent from the queue to the interface until it is
         unpaused with UnpauseQueueMember or the manager interface.  If no queuename is given,
         the interface is paused in every queue it is a member of. The application will fail if the
         interface is not found.</para>
         <para>This application sets the following channel variable upon completion:</para>
         <variablelist>
            <variable name="PQMSTATUS">
               <para>The status of the attempt to pause a queue member as a text string.</para>
               <value name="PAUSED" />
               <value name="NOTFOUND" />
            </variable>
         </variablelist>
         <para>Example: PauseQueueMember(,SIP/3000)</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="UnpauseQueueMember" language="en_US">
      <synopsis>
         Unpauses a queue member.
      </synopsis>
      <syntax>
         <parameter name="queuename" />
         <parameter name="interface" required="true" />
         <parameter name="options" />
         <parameter name="reason">
            <para>Is used to add extra information to the appropriate queue_log entries and manager events.</para>
         </parameter>
      </syntax>
      <description>
         <para>Unpauses (resumes calls to) a queue member. This is the counterpart to <literal>PauseQueueMember()</literal>
         and operates exactly the same way, except it unpauses instead of pausing the given interface.</para>
         <para>This application sets the following channel variable upon completion:</para>
         <variablelist>
            <variable name="UPQMSTATUS">
               <para>The status of the attempt to unpause a queue member as a text string.</para>
               <value name="UNPAUSED" />
               <value name="NOTFOUND" />
            </variable>
         </variablelist>
         <para>Example: UnpauseQueueMember(,SIP/3000)</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="QueueLog" language="en_US">
      <synopsis>
         Writes to the queue_log file.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="uniqueid" required="true" />
         <parameter name="agent" required="true" />
         <parameter name="event" required="true" />
         <parameter name="additionalinfo" />
      </syntax>
      <description>
         <para>Allows you to write your own events into the queue log.</para>
         <para>Example: QueueLog(101,${UNIQUEID},${AGENT},WENTONBREAK,600)</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </application>
   <application name="QueueUpdate" language="en_US">
      <synopsis>
         Writes to the queue_log file for OutBound calls and updates Realtime Data.
         Is used at h extension to be able to have all the parameters.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="uniqueid" required="true" />
         <parameter name="agent" required="true" />
         <parameter name="status" required="true" />
         <parameter name="talktime" required="true" />
         <parameter name="params" required="false" />
      </syntax>
      <description>
         <para>Allows you to write Outbound events into the queue log.</para>
         <para>Example: exten => h,1,QueueUpdate(${QUEUE}, ${UNIQUEID}, ${AGENT}, ${DIALSTATUS}, ${ANSWEREDTIME}, ${DIALEDTIME} | ${DIALEDNUMBER})</para>
      </description>
   </application>
   <function name="QUEUE_VARIABLES" language="en_US">
      <synopsis>
         Return Queue information in variables.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true">
            <enumlist>
               <enum name="QUEUEMAX">
                  <para>Maxmimum number of calls allowed.</para>
               </enum>
               <enum name="QUEUESTRATEGY">
                  <para>The strategy of the queue.</para>
               </enum>
               <enum name="QUEUECALLS">
                  <para>Number of calls currently in the queue.</para>
               </enum>
               <enum name="QUEUEHOLDTIME">
                  <para>Current average hold time.</para>
               </enum>
               <enum name="QUEUECOMPLETED">
                  <para>Number of completed calls for the queue.</para>
               </enum>
               <enum name="QUEUEABANDONED">
                  <para>Number of abandoned calls.</para>
               </enum>
               <enum name="QUEUESRVLEVEL">
                  <para>Queue service level.</para>
               </enum>
               <enum name="QUEUESRVLEVELPERF">
                  <para>Current service level performance.</para>
               </enum>
            </enumlist>
         </parameter>
      </syntax>
      <description>
         <para>Makes the following queue variables available.</para>
         <para>Returns <literal>0</literal> if queue is found and setqueuevar is defined, <literal>-1</literal> otherwise.</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_MEMBER" language="en_US">
      <synopsis>
         Provides a count of queue members based on the provided criteria, or updates a
         queue member's settings.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="false" />
         <parameter name="option" required="true">
            <enumlist>
               <enum name="logged">
                  <para>Returns the number of logged-in members for the specified queue.</para>
               </enum>
               <enum name="free">
                  <para>Returns the number of logged-in members for the specified queue that either can take calls or are currently wrapping up after a previous call.</para>
               </enum>
               <enum name="ready">
                  <para>Returns the number of logged-in members for the specified queue that are immediately available to answer a call.</para>
               </enum>
               <enum name="count">
                  <para>Returns the total number of members for the specified queue.</para>
               </enum>
               <enum name="penalty">
                  <para>Gets or sets queue member penalty.  If
                  <replaceable>queuename</replaceable> is not specified
                  when setting the penalty then the penalty is set in all queues
                  the interface is a member.</para>
               </enum>
               <enum name="paused">
                  <para>Gets or sets queue member paused status.  If
                  <replaceable>queuename</replaceable> is not specified
                  when setting the paused status then the paused status is set
                  in all queues the interface is a member.</para>
               </enum>
               <enum name="ringinuse">
                  <para>Gets or sets queue member ringinuse.  If
                  <replaceable>queuename</replaceable> is not specified
                  when setting ringinuse then ringinuse is set
                  in all queues the interface is a member.</para>
               </enum>
            </enumlist>
         </parameter>
         <parameter name="interface" required="false" />
      </syntax>
      <description>
         <para>Allows access to queue counts [R] and member information [R/W].</para>
         <para><replaceable>queuename</replaceable> is required for all read operations.</para>
         <para><replaceable>interface</replaceable> is required for all member operations.</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_MEMBER_COUNT" language="en_US">
      <synopsis>
         Count number of members answering a queue.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
      </syntax>
      <description>
         <para>Returns the number of members currently associated with the specified <replaceable>queuename</replaceable>.</para>
         <warning><para>This function has been deprecated in favor of the <literal>QUEUE_MEMBER()</literal> function</para></warning>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_EXISTS" language="en_US">
      <synopsis>
         Check if a named queue exists on this server
      </synopsis>
      <syntax>
         <parameter name="queuename" />
      </syntax>
      <description>
         <para>Returns 1 if the specified queue exists, 0 if it does not</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_GET_CHANNEL" language="en_US">
      <synopsis>
         Return caller at the specified position in a queue.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="position" />
      </syntax>
      <description>
         <para>Returns the caller channel at <replaceable>position</replaceable> in the specified <replaceable>queuename</replaceable>.</para>
         <para>If <replaceable>position</replaceable> is unspecified the first channel is returned.</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_WAITING_COUNT" language="en_US">
      <synopsis>
         Count number of calls currently waiting in a queue.
      </synopsis>
      <syntax>
         <parameter name="queuename" />
      </syntax>
      <description>
         <para>Returns the number of callers currently waiting in the specified <replaceable>queuename</replaceable>.</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_MEMBER_LIST" language="en_US">
      <synopsis>
         Returns a list of interfaces on a queue.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
      </syntax>
      <description>
         <para>Returns a comma-separated list of members associated with the specified <replaceable>queuename</replaceable>.</para>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <function name="QUEUE_MEMBER_PENALTY" language="en_US">
      <synopsis>
         Gets or sets queue members penalty.
      </synopsis>
      <syntax>
         <parameter name="queuename" required="true" />
         <parameter name="interface" required="true" />
      </syntax>
      <description>
         <para>Gets or sets queue members penalty.</para>
         <warning><para>This function has been deprecated in favor of the <literal>QUEUE_MEMBER()</literal> function</para></warning>
      </description>
      <see-also>
         <ref type="application">Queue</ref>
         <ref type="application">QueueLog</ref>
         <ref type="application">AddQueueMember</ref>
         <ref type="application">RemoveQueueMember</ref>
         <ref type="application">PauseQueueMember</ref>
         <ref type="application">UnpauseQueueMember</ref>
         <ref type="function">QUEUE_VARIABLES</ref>
         <ref type="function">QUEUE_MEMBER</ref>
         <ref type="function">QUEUE_MEMBER_COUNT</ref>
         <ref type="function">QUEUE_EXISTS</ref>
         <ref type="function">QUEUE_GET_CHANNEL</ref>
         <ref type="function">QUEUE_WAITING_COUNT</ref>
         <ref type="function">QUEUE_MEMBER_LIST</ref>
         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
      </see-also>
   </function>
   <manager name="QueueStatus" language="en_US">
      <synopsis>
         Show queue status.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue">
            <para>Limit the response to the status of the specified queue.</para>
         </parameter>
         <parameter name="Member">
            <para>Limit the response to the status of the specified member.</para>
         </parameter>
      </syntax>
      <description>
         <para>Check the status of one or more queues.</para>
      </description>
   </manager>
   <manager name="QueueSummary" language="en_US">
      <synopsis>
         Show queue summary.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue">
            <para>Queue for which the summary is requested.</para>
         </parameter>
      </syntax>
      <description>
         <para>Request the manager to send a QueueSummary event.</para>
      </description>
   </manager>
   <manager name="QueueAdd" language="en_US">
      <synopsis>
         Add interface to queue.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue" required="true">
            <para>Queue's name.</para>
         </parameter>
         <parameter name="Interface" required="true">
            <para>The name of the interface (tech/name) to add to the queue.</para>
         </parameter>
         <parameter name="Penalty">
            <para>A penalty (number) to apply to this member. Asterisk will distribute calls to members with higher penalties only after attempting to distribute calls to those with lower penalty.</para>
         </parameter>
         <parameter name="Paused">
            <para>To pause or not the member initially (true/false or 1/0).</para>
         </parameter>
         <parameter name="MemberName">
            <para>Text alias for the interface.</para>
         </parameter>
         <parameter name="StateInterface" />
      </syntax>
      <description>
      </description>
   </manager>
   <manager name="QueueRemove" language="en_US">
      <synopsis>
         Remove interface from queue.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue" required="true">
            <para>The name of the queue to take action on.</para>
         </parameter>
         <parameter name="Interface" required="true">
            <para>The interface (tech/name) to remove from queue.</para>
         </parameter>
      </syntax>
      <description>
      </description>
   </manager>
   <manager name="QueuePause" language="en_US">
      <synopsis>
         Makes a queue member temporarily unavailable.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Interface" required="true">
            <para>The name of the interface (tech/name) to pause or unpause.</para>
         </parameter>
         <parameter name="Paused" required="true">
            <para>Pause or unpause the interface. Set to 'true' to pause the member or 'false' to unpause.</para>
         </parameter>
         <parameter name="Queue">
            <para>The name of the queue in which to pause or unpause this member. If not specified, the member will be paused or unpaused in all the queues it is a member of.</para>
         </parameter>
         <parameter name="Reason">
            <para>Text description, returned in the event QueueMemberPaused.</para>
         </parameter>
      </syntax>
      <description>
         <para>Pause or unpause a member in a queue.</para>
      </description>
   </manager>
   <manager name="QueueLog" language="en_US">
      <synopsis>
         Adds custom entry in queue_log.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue" required="true" />
         <parameter name="Event" required="true" />
         <parameter name="Uniqueid" />
         <parameter name="Interface" />
         <parameter name="Message" />
      </syntax>
      <description>
      </description>
   </manager>
   <manager name="QueuePenalty" language="en_US">
      <synopsis>
         Set the penalty for a queue member.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Interface" required="true">
            <para>The interface (tech/name) of the member whose penalty to change.</para>
         </parameter>
         <parameter name="Penalty" required="true">
            <para>The new penalty (number) for the member. Must be nonnegative.</para>
         </parameter>
         <parameter name="Queue">
            <para>If specified, only set the penalty for the member of this queue. Otherwise, set the penalty for the member in all queues to which the member belongs.</para>
         </parameter>
      </syntax>
      <description>
         <para>Change the penalty of a queue member</para>
      </description>
   </manager>
   <manager name="QueueMemberRingInUse" language="en_US">
      <synopsis>
         Set the ringinuse value for a queue member.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Interface" required="true" />
         <parameter name="RingInUse" required="true" />
         <parameter name="Queue" />
      </syntax>
      <description>
      </description>
   </manager>
   <manager name="QueueRule" language="en_US">
      <synopsis>
         Queue Rules.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Rule">
            <para>The name of the rule in queuerules.conf whose contents to list.</para>
         </parameter>
      </syntax>
      <description>
         <para>List queue rules defined in queuerules.conf</para>
      </description>
   </manager>
   <manager name="QueueReload" language="en_US">
      <synopsis>
         Reload a queue, queues, or any sub-section of a queue or queues.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue">
            <para>The name of the queue to take action on. If no queue name is specified, then all queues are affected.</para>
         </parameter>
         <parameter name="Members">
            <para>Whether to reload the queue's members.</para>
            <enumlist>
               <enum name="yes" />
               <enum name="no" />
            </enumlist>
         </parameter>
         <parameter name="Rules">
            <para>Whether to reload queuerules.conf</para>
            <enumlist>
               <enum name="yes" />
               <enum name="no" />
            </enumlist>
         </parameter>
         <parameter name="Parameters">
            <para>Whether to reload the other queue options.</para>
            <enumlist>
               <enum name="yes" />
               <enum name="no" />
            </enumlist>
         </parameter>
      </syntax>
      <description>
      </description>
   </manager>
   <manager name="QueueReset" language="en_US">
      <synopsis>
         Reset queue statistics.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue">
            <para>The name of the queue on which to reset statistics.</para>
         </parameter>
      </syntax>
      <description>
         <para>Reset the statistics for a queue.</para>
      </description>
   </manager>
   <manager name="QueueChangePriorityCaller" language="en_US">
      <synopsis>
         Change priority of a caller on queue.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Queue" required="true">
            <para>The name of the queue to take action on.</para>
         </parameter>
         <parameter name="Caller" required="true">
            <para>The caller (channel) to change priority on queue.</para>
         </parameter>
 
         <parameter name="Priority" required="true">
            <para>Priority value for change for caller on queue.</para>
         </parameter>
      </syntax>
      <description>
      </description>
   </manager>
 
   <managerEvent language="en_US" name="QueueMemberStatus">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a Queue member's status has changed.</synopsis>
         <syntax>
            <parameter name="Queue">
               <para>The name of the queue.</para>
            </parameter>
            <parameter name="MemberName">
               <para>The name of the queue member.</para>
            </parameter>
            <parameter name="Interface">
               <para>The queue member's channel technology or location.</para>
            </parameter>
            <parameter name="StateInterface">
               <para>Channel technology or location from which to read device state changes.</para>
            </parameter>
            <parameter name="Membership">
               <enumlist>
                  <enum name="dynamic"/>
                  <enum name="realtime"/>
                  <enum name="static"/>
               </enumlist>
            </parameter>
            <parameter name="Penalty">
               <para>The penalty associated with the queue member.</para>
            </parameter>
            <parameter name="CallsTaken">
               <para>The number of calls this queue member has serviced.</para>
            </parameter>
            <parameter name="LastCall">
               <para>The time this member last took a call, expressed in seconds since 00:00, Jan 1, 1970 UTC.</para>
            </parameter>
            <parameter name="LastPause">
               <para>The time when started last paused the queue member.</para>
            </parameter>
            <parameter name="LoginTime">
               <para>The time this member logged in to the queue, expressed in seconds since 00:00, Jan 1, 1970 UTC.</para>
            </parameter>
            <parameter name="InCall">
               <para>Set to 1 if member is in call. Set to 0 after LastCall time is updated.</para>
               <enumlist>
                  <enum name="0"/>
                  <enum name="1"/>
               </enumlist>
            </parameter>
            <parameter name="Status">
               <para>The numeric device state status of the queue member.</para>
               <enumlist>
                  <enum name="0"><para>AST_DEVICE_UNKNOWN</para></enum>
                  <enum name="1"><para>AST_DEVICE_NOT_INUSE</para></enum>
                  <enum name="2"><para>AST_DEVICE_INUSE</para></enum>
                  <enum name="3"><para>AST_DEVICE_BUSY</para></enum>
                  <enum name="4"><para>AST_DEVICE_INVALID</para></enum>
                  <enum name="5"><para>AST_DEVICE_UNAVAILABLE</para></enum>
                  <enum name="6"><para>AST_DEVICE_RINGING</para></enum>
                  <enum name="7"><para>AST_DEVICE_RINGINUSE</para></enum>
                  <enum name="8"><para>AST_DEVICE_ONHOLD</para></enum>
               </enumlist>
            </parameter>
            <parameter name="Paused">
               <enumlist>
                  <enum name="0"/>
                  <enum name="1"/>
               </enumlist>
            </parameter>
            <parameter name="PausedReason">
               <para>If set when paused, the reason the queue member was paused.</para>
            </parameter>
            <parameter name="Ringinuse">
               <enumlist>
                  <enum name="0"/>
                  <enum name="1"/>
               </enumlist>
            </parameter>
            <parameter name="Wrapuptime">
               <para>The Wrapup Time of the queue member. If this value is set will override the wrapup time of queue.</para>
            </parameter>
         </syntax>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueMemberAdded">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a member is added to the queue.</synopsis>
         <syntax>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter)" />
         </syntax>
         <see-also>
            <ref type="managerEvent">QueueMemberRemoved</ref>
            <ref type="application">AddQueueMember</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueMemberRemoved">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a member is removed from the queue.</synopsis>
         <syntax>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter)" />
         </syntax>
         <see-also>
            <ref type="managerEvent">QueueMemberAdded</ref>
            <ref type="application">RemoveQueueMember</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueMemberPause">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a member is paused/unpaused in the queue.</synopsis>
         <syntax>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter)" />
         </syntax>
         <see-also>
            <ref type="application">PauseQueueMember</ref>
            <ref type="application">UnPauseQueueMember</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueMemberPenalty">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a member's penalty is changed.</synopsis>
         <syntax>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter)" />
         </syntax>
         <see-also>
            <ref type="function">QUEUE_MEMBER</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueMemberRinginuse">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a member's ringinuse setting is changed.</synopsis>
         <syntax>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter)" />
         </syntax>
         <see-also>
            <ref type="function">QUEUE_MEMBER</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueCallerJoin">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a caller joins a Queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <parameter name="Position">
               <para>This channel's current position in the queue.</para>
            </parameter>
            <parameter name="Count">
               <para>The total number of channels in the queue.</para>
            </parameter>
         </syntax>
         <see-also>
            <ref type="managerEvent">QueueCallerLeave</ref>
            <ref type="application">Queue</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueCallerLeave">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a caller leaves a Queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueCallerJoin']/managerEventInstance/syntax/parameter[@name='Count'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueCallerJoin']/managerEventInstance/syntax/parameter[@name='Position'])" />
         </syntax>
         <see-also>
            <ref type="managerEvent">QueueCallerJoin</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="QueueCallerAbandon">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a caller abandons the queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueCallerJoin']/managerEventInstance/syntax/parameter[@name='Position'])" />
            <parameter name="OriginalPosition">
               <para>The channel's original position in the queue.</para>
            </parameter>
            <parameter name="HoldTime">
               <para>The time the channel was in the queue, expressed in seconds since 00:00, Jan 1, 1970 UTC.</para>
            </parameter>
         </syntax>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="AgentCalled">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when an queue member is notified of a caller in the queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <channel_snapshot prefix="Dest"/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='MemberName'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Interface'])" />
         </syntax>
         <see-also>
            <ref type="managerEvent">AgentRingNoAnswer</ref>
            <ref type="managerEvent">AgentComplete</ref>
            <ref type="managerEvent">AgentConnect</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="AgentRingNoAnswer">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a queue member is notified of a caller in the queue and fails to answer.</synopsis>
         <syntax>
            <channel_snapshot/>
            <channel_snapshot prefix="Dest"/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='MemberName'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Interface'])" />
            <parameter name="RingTime">
               <para>The time the queue member was rung, expressed in seconds since 00:00, Jan 1, 1970 UTC.</para>
            </parameter>
         </syntax>
         <see-also>
            <ref type="managerEvent">AgentCalled</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="AgentComplete">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a queue member has finished servicing a caller in the queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <channel_snapshot prefix="Dest"/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='MemberName'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Interface'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueCallerAbandon']/managerEventInstance/syntax/parameter[@name='HoldTime'])" />
            <parameter name="TalkTime">
               <para>The time the queue member talked with the caller in the queue, expressed in seconds since 00:00, Jan 1, 1970 UTC.</para>
            </parameter>
            <parameter name="Reason">
               <enumlist>
                  <enum name="caller"/>
                  <enum name="agent"/>
                  <enum name="transfer"/>
               </enumlist>
            </parameter>
         </syntax>
         <see-also>
            <ref type="managerEvent">AgentCalled</ref>
            <ref type="managerEvent">AgentConnect</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="AgentDump">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a queue member hangs up on a caller in the queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <channel_snapshot prefix="Dest"/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='MemberName'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Interface'])" />
         </syntax>
         <see-also>
            <ref type="managerEvent">AgentCalled</ref>
            <ref type="managerEvent">AgentConnect</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
   <managerEvent language="en_US" name="AgentConnect">
      <managerEventInstance class="EVENT_FLAG_AGENT">
         <synopsis>Raised when a queue member answers and is bridged to a caller in the queue.</synopsis>
         <syntax>
            <channel_snapshot/>
            <channel_snapshot prefix="Dest"/>
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Queue'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='MemberName'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueMemberStatus']/managerEventInstance/syntax/parameter[@name='Interface'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='AgentRingNoAnswer']/managerEventInstance/syntax/parameter[@name='RingTime'])" />
            <xi:include xpointer="xpointer(/docs/managerEvent[@name='QueueCallerAbandon']/managerEventInstance/syntax/parameter[@name='HoldTime'])" />
         </syntax>
         <see-also>
            <ref type="managerEvent">AgentCalled</ref>
            <ref type="managerEvent">AgentComplete</ref>
            <ref type="managerEvent">AgentDump</ref>
         </see-also>
      </managerEventInstance>
   </managerEvent>
 ***/
 
enum {
   OPT_MARK_AS_ANSWERED =       (1 << 0),
   OPT_GO_ON =                  (1 << 1),
   OPT_DATA_QUALITY =           (1 << 2),
   OPT_CALLEE_GO_ON =           (1 << 3),
   OPT_CALLEE_HANGUP =          (1 << 4),
   OPT_CALLER_HANGUP =          (1 << 5),
   OPT_IGNORE_CALL_FW =         (1 << 6),
   OPT_IGNORE_CONNECTEDLINE =   (1 << 7),
   OPT_CALLEE_PARK =            (1 << 8),
   OPT_CALLER_PARK =            (1 << 9),
   OPT_NO_RETRY =               (1 << 10),
   OPT_RINGING =                (1 << 11),
   OPT_RING_WHEN_RINGING =      (1 << 12),
   OPT_CALLEE_TRANSFER =        (1 << 13),
   OPT_CALLER_TRANSFER =        (1 << 14),
   OPT_CALLEE_AUTOMIXMON =      (1 << 15),
   OPT_CALLER_AUTOMIXMON =      (1 << 16),
   OPT_CALLEE_AUTOMON =         (1 << 17),
   OPT_CALLER_AUTOMON =         (1 << 18),
   OPT_PREDIAL_CALLEE =         (1 << 19),
   OPT_PREDIAL_CALLER =         (1 << 20),
};
 
enum {
   OPT_ARG_CALLEE_GO_ON = 0,
   OPT_ARG_PREDIAL_CALLEE,
   OPT_ARG_PREDIAL_CALLER,
   /* note: this entry _MUST_ be the last one in the enum */
   OPT_ARG_ARRAY_SIZE
};
 
AST_APP_OPTIONS(queue_exec_options, BEGIN_OPTIONS
   AST_APP_OPTION_ARG('b', OPT_PREDIAL_CALLEE, OPT_ARG_PREDIAL_CALLEE),
   AST_APP_OPTION_ARG('B', OPT_PREDIAL_CALLER, OPT_ARG_PREDIAL_CALLER),
   AST_APP_OPTION('C', OPT_MARK_AS_ANSWERED),
   AST_APP_OPTION('c', OPT_GO_ON),
   AST_APP_OPTION('d', OPT_DATA_QUALITY),
   AST_APP_OPTION_ARG('F', OPT_CALLEE_GO_ON, OPT_ARG_CALLEE_GO_ON),
   AST_APP_OPTION('h', OPT_CALLEE_HANGUP),
   AST_APP_OPTION('H', OPT_CALLER_HANGUP),
   AST_APP_OPTION('i', OPT_IGNORE_CALL_FW),
   AST_APP_OPTION('I', OPT_IGNORE_CONNECTEDLINE),
   AST_APP_OPTION('k', OPT_CALLEE_PARK),
   AST_APP_OPTION('K', OPT_CALLER_PARK),
   AST_APP_OPTION('n', OPT_NO_RETRY),
   AST_APP_OPTION('r', OPT_RINGING),
   AST_APP_OPTION('R', OPT_RING_WHEN_RINGING),
   AST_APP_OPTION('t', OPT_CALLEE_TRANSFER),
   AST_APP_OPTION('T', OPT_CALLER_TRANSFER),
   AST_APP_OPTION('x', OPT_CALLEE_AUTOMIXMON),
   AST_APP_OPTION('X', OPT_CALLER_AUTOMIXMON),
   AST_APP_OPTION('w', OPT_CALLEE_AUTOMON),
   AST_APP_OPTION('W', OPT_CALLER_AUTOMON),
END_OPTIONS);
 
enum {
   QUEUE_STRATEGY_RINGALL = 0,
   QUEUE_STRATEGY_LEASTRECENT,
   QUEUE_STRATEGY_FEWESTCALLS,
   QUEUE_STRATEGY_RANDOM,
   QUEUE_STRATEGY_RRMEMORY,
   QUEUE_STRATEGY_LINEAR,
   QUEUE_STRATEGY_WRANDOM,
   QUEUE_STRATEGY_RRORDERED,
};
 
enum {
   QUEUE_AUTOPAUSE_OFF = 0,
   QUEUE_AUTOPAUSE_ON,
   QUEUE_AUTOPAUSE_ALL
};
 
enum queue_reload_mask {
   QUEUE_RELOAD_PARAMETERS = (1 << 0),
   QUEUE_RELOAD_MEMBER = (1 << 1),
   QUEUE_RELOAD_RULES = (1 << 2),
   QUEUE_RESET_STATS = (1 << 3),
};
 
static const struct strategy {
   int strategy;
   const char *name;
} strategies[] = {
   { QUEUE_STRATEGY_RINGALL, "ringall" },
   { QUEUE_STRATEGY_LEASTRECENT, "leastrecent" },
   { QUEUE_STRATEGY_FEWESTCALLS, "fewestcalls" },
   { QUEUE_STRATEGY_RANDOM, "random" },
   { QUEUE_STRATEGY_RRMEMORY, "rrmemory" },
   { QUEUE_STRATEGY_RRMEMORY, "roundrobin" },
   { QUEUE_STRATEGY_LINEAR, "linear" },
   { QUEUE_STRATEGY_WRANDOM, "wrandom"},
   { QUEUE_STRATEGY_RRORDERED, "rrordered"},
};
 
static const struct autopause {
   int autopause;
   const char *name;
} autopausesmodes [] = {
   { QUEUE_AUTOPAUSE_OFF,"no" },
   { QUEUE_AUTOPAUSE_ON, "yes" },
   { QUEUE_AUTOPAUSE_ALL,"all" },
};
 
#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 */
/*!
 * \brief The minimum number of seconds between position announcements.
 * \note The default value of 15 provides backwards compatibility.
 */
#define DEFAULT_MIN_ANNOUNCE_FREQUENCY 15
 
#define MAX_QUEUE_BUCKETS 53
 
#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 */
#define RES_NOT_CALLER  (-5)     /*!< Caller not found */
 
static char *app = "Queue";
 
static char *app_aqm = "AddQueueMember" ;
 
static char *app_rqm = "RemoveQueueMember" ;
 
static char *app_pqm = "PauseQueueMember" ;
 
static char *app_upqm = "UnpauseQueueMember" ;
 
static char *app_ql = "QueueLog" ;
 
static char *app_qupd = "QueueUpdate";
 
/*! \brief Persistent Members astdb family */
static const char * const pm_family = "Queue/PersistentMembers";
 
/*! \brief queues.conf [general] option */
static int queue_persistent_members;
 
/*! \brief Records that one or more queues use weight */
static int use_weight;
 
/*! \brief queues.conf [general] option */
static int autofill_default;
 
/*! \brief queues.conf [general] option */
static int montype_default;
 
/*! \brief queues.conf [general] option */
static int shared_lastcall;
 
/*! \brief queuerules.conf [general] option */
static int realtime_rules;
 
/*! \brief Subscription to device state change messages */
static struct stasis_subscription *device_state_sub;
 
/*! \brief queues.conf [general] option */
static int negative_penalty_invalid;
 
/*! \brief queues.conf [general] option */
static int log_membername_as_agent;
 
/*! \brief name of the ringinuse field in the realtime database */
static char *realtime_ringinuse_field;
 
enum queue_result {
   QUEUE_UNKNOWN = 0,
   QUEUE_TIMEOUT = 1,
   QUEUE_JOINEMPTY = 2,
   QUEUE_LEAVEEMPTY = 3,
   QUEUE_JOINUNAVAIL = 4,
   QUEUE_LEAVEUNAVAIL = 5,
   QUEUE_FULL = 6,
   QUEUE_CONTINUE = 7,
};
 
static 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" },
   { QUEUE_CONTINUE, "CONTINUE" },
};
 
enum queue_timeout_priority {
   TIMEOUT_PRIORITY_APP,
   TIMEOUT_PRIORITY_CONF,
};
 
/*! \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];       /*!< An Asterisk dial string (not a channel name) */
   int metric;
   struct member *member;
   /*! Saved connected party info from an AST_CONTROL_CONNECTED_LINE. */
   struct ast_party_connected_line connected;
   /*! TRUE if an AST_CONTROL_CONNECTED_LINE update was saved to the connected element. */
   unsigned int pending_connected_update:1;
   /*! TRUE if the connected line update is blocked. */
   unsigned int block_connected_update:1;
   /*! TRUE if caller id is not available for connected line */
   unsigned int dial_callerid_absent:1;
   /*! TRUE if the call is still active */
   unsigned int stillgoing:1;
   struct ast_aoc_decoded *aoc_s_rate_list;
   /*! Original channel name.  Must be freed.  Could be NULL if allocation failed. */
   char *orig_chan_name;
};
 
 
struct queue_ent {
   struct call_queue *parent;             /*!< What queue is our parent */
   char moh[MAX_MUSICCLASS];              /*!< Name of musiconhold to be used */
   char announce[PATH_MAX];               /*!< 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 */
   const char *predial_callee;            /*!< Gosub app arguments for outgoing calls.  NULL if not supplied. */
   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 */
   int ring_when_ringing;                 /*!< Should we only use ring indication when a channel is ringing? */
   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 */
   int min_penalty;                       /*!< Limit the members that can take this call to this penalty or higher */
   int raise_penalty;                     /*!< Float lower penalty members to a minimum penalty */
   int linpos;                            /*!< If using linear strategy, what position are we at? */
   int linwrapped;                        /*!< Is the linpos wrapped? */
   time_t start;                          /*!< When we started holding */
   time_t expire;                         /*!< When this entry should expire (time out of queue) */
   int cancel_answered_elsewhere;         /*!< Whether we should force the CAE flag on this call (C) option*/
   struct ast_channel *chan;              /*!< Our channel */
   AST_LIST_HEAD_NOLOCK(,penalty_rule) qe_rules; /*!< Local copy of the queue's penalty rules */
   struct penalty_rule *pr;               /*!< Pointer to the next penalty rule to implement */
   struct queue_ent *next;                /*!< The next queue entry */
};
 
struct member {
   char interface[AST_CHANNEL_NAME];    /*!< Technology/Location to dial to reach this member*/
   char state_exten[AST_MAX_EXTENSION]; /*!< Extension to get state from (if using hint) */
   char state_context[AST_MAX_CONTEXT]; /*!< Context to use when getting state (if using hint) */
   char state_interface[AST_CHANNEL_NAME]; /*!< Technology/Location from which to read devicestate changes */
   int state_id;                        /*!< Extension state callback id (if using hint) */
   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)? */
   char reason_paused[80];              /*!< Reason of paused if member is paused */
   int queuepos;                        /*!< In what order (pertains to certain strategies) should this member be called? */
   int callcompletedinsl;               /*!< Whether the current call was completed within service level */
   int wrapuptime;                      /*!< Wrapup Time */
   time_t starttime;                    /*!< The time at which the member answered the current caller. */
   time_t lastcall;                     /*!< When last successful call was hungup */
   time_t lastpause;                    /*!< When started the last pause */
   time_t logintime;                    /*!< The time when started the login */
   struct call_queue *lastqueue;        /*!< Last queue we received a call */
   unsigned int dead:1;                 /*!< Used to detect members deleted in realtime */
   unsigned int delme:1;                /*!< Flag to delete entry on reload */
   char rt_uniqueid[80];                /*!< Unique id of realtime member entry */
   unsigned int ringinuse:1;            /*!< Flag to ring queue members even if their status is 'inuse' */
};
 
enum empty_conditions {
   QUEUE_EMPTY_PENALTY = (1 << 0),
   QUEUE_EMPTY_PAUSED = (1 << 1),
   QUEUE_EMPTY_INUSE = (1 << 2),
   QUEUE_EMPTY_RINGING = (1 << 3),
   QUEUE_EMPTY_UNAVAILABLE = (1 << 4),
   QUEUE_EMPTY_INVALID = (1 << 5),
   QUEUE_EMPTY_UNKNOWN = (1 << 6),
   QUEUE_EMPTY_WRAPUP = (1 << 7),
};
 
enum member_properties {
   MEMBER_PENALTY = 0,
   MEMBER_RINGINUSE = 1,
};
 
/* values used in multi-bit flags in call_queue */
#define ANNOUNCEHOLDTIME_ALWAYS 1
#define ANNOUNCEHOLDTIME_ONCE 2
#define QUEUE_EVENT_VARIABLES 3
 
struct penalty_rule {
   int time;                           /*!< Number of seconds that need to pass before applying this rule */
   int max_value;                      /*!< The amount specified in the penalty rule for max penalty */
   int min_value;                      /*!< The amount specified in the penalty rule for min penalty */
   int raise_value;                      /*!< The amount specified in the penalty rule for min penalty */
   int max_relative;                   /*!< Is the max adjustment relative? 1 for relative, 0 for absolute */
   int min_relative;                   /*!< Is the min adjustment relative? 1 for relative, 0 for absolute */
   int raise_relative;                   /*!< Is the min adjustment relative? 1 for relative, 0 for absolute */
   AST_LIST_ENTRY(penalty_rule) list;  /*!< Next penalty_rule */
};
 
#define ANNOUNCEPOSITION_YES 1 /*!< We announce position */
#define ANNOUNCEPOSITION_NO 2 /*!< We don't announce position */
#define ANNOUNCEPOSITION_MORE_THAN 3 /*!< We say "Currently there are more than <limit>" */
#define ANNOUNCEPOSITION_LIMIT 4 /*!< We not announce position more than <limit> */
 
struct call_queue {
   AST_DECLARE_STRING_FIELDS(
      /*! Queue name */
      AST_STRING_FIELD(name);
      /*! Music on Hold class */
      AST_STRING_FIELD(moh);
      /*! Announcement to play when call is answered */
      AST_STRING_FIELD(announce);
      /*! Exit context */
      AST_STRING_FIELD(context);
      /*! Macro to run upon member connection */
      AST_STRING_FIELD(membermacro);
      /*! Gosub to run upon member connection */
      AST_STRING_FIELD(membergosub);
      /*! Default rule to use if none specified in call to Queue() */
      AST_STRING_FIELD(defaultrule);
      /*! Sound file: "Your call is now first in line" (def. queue-youarenext) */
      AST_STRING_FIELD(sound_next);
      /*! Sound file: "There are currently" (def. queue-thereare) */
      AST_STRING_FIELD(sound_thereare);
      /*! Sound file: "calls waiting to speak to a representative." (def. queue-callswaiting) */
      AST_STRING_FIELD(sound_calls);
      /*! Sound file: "Currently there are more than" (def. queue-quantity1) */
      AST_STRING_FIELD(queue_quantity1);
      /*! Sound file: "callers waiting to speak with a representative" (def. queue-quantity2) */
      AST_STRING_FIELD(queue_quantity2);
      /*! Sound file: "The current estimated total holdtime is" (def. queue-holdtime) */
      AST_STRING_FIELD(sound_holdtime);
      /*! Sound file: "minutes." (def. queue-minutes) */
      AST_STRING_FIELD(sound_minutes);
      /*! Sound file: "minute." (def. queue-minute) */
      AST_STRING_FIELD(sound_minute);
      /*! Sound file: "seconds." (def. queue-seconds) */
      AST_STRING_FIELD(sound_seconds);
      /*! Sound file: "Thank you for your patience." (def. queue-thankyou) */
      AST_STRING_FIELD(sound_thanks);
      /*! Sound file: Custom announce for caller, no default */
      AST_STRING_FIELD(sound_callerannounce);
      /*! Sound file: "Hold time" (def. queue-reporthold) */
      AST_STRING_FIELD(sound_reporthold);
   );
   /*! Sound files: Custom announce, no default */
   struct ast_str *sound_periodicannounce[MAX_PERIODIC_ANNOUNCEMENTS];
   unsigned int dead:1;
   unsigned int ringinuse:1;
   unsigned int announce_to_first_user:1; /*!< Whether or not we announce to the first user in a queue */
   unsigned int setinterfacevar:1;
   unsigned int setqueuevar:1;
   unsigned int setqueueentryvar:1;
   unsigned int reportholdtime:1;
   unsigned int wrapped:1;
   unsigned int timeoutrestart:1;
   unsigned int announceholdtime:2;
   unsigned int announceposition:3;
   unsigned int announceposition_only_up:1; /*!< Only announce position if it has improved */
   int strategy:4;
   unsigned int realtime:1;
   unsigned int found:1;
   unsigned int relativeperiodicannounce:1;
   unsigned int autopausebusy:1;
   unsigned int autopauseunavail:1;
   enum empty_conditions joinempty;
   enum empty_conditions leavewhenempty;
   int announcepositionlimit;          /*!< How many positions we announce? */
   int announcefrequency;              /*!< How often to announce their position */
   int minannouncefrequency;           /*!< The minimum number of seconds between position announcements (def. 15) */
   int periodicannouncefrequency;      /*!< How often to play periodic announcement */
   int numperiodicannounce;            /*!< The number of periodic announcements configured */
   int randomperiodicannounce;         /*!< Are periodic announcments randomly chosen */
   int roundingseconds;                /*!< How many seconds do we round to? */
   int holdtime;                       /*!< Current avg holdtime, based on an exponential average */
   int talktime;                       /*!< Current avg talktime, based on the same exponential average */
   int callscompleted;                 /*!< Number of queue calls completed */
   int callsabandoned;                 /*!< Number of queue calls abandoned */
   int callsabandonedinsl;             /*!< Number of queue calls abandoned in servicelevel */
   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 */
   int count;                          /*!< How many entries */
   int maxlen;                         /*!< Max number of entries */
   int wrapuptime;                     /*!< Wrapup Time */
   int penaltymemberslimit;            /*!< Disregard penalty when queue has fewer than this many members */
 
   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 */
   int autopausedelay;                 /*!< Delay auto pause for autopausedelay seconds since last call */
   int timeoutpriority;                /*!< Do we allow a fraction of the timeout to occur for a ring? */
 
   /* 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 */
   struct queue_ent *head;             /*!< Head of the list of callers */
   AST_LIST_ENTRY(call_queue) list;    /*!< Next call queue */
   AST_LIST_HEAD_NOLOCK(, penalty_rule) rules; /*!< The list of penalty rules to invoke */
};
 
struct rule_list {
   char name[80];
   AST_LIST_HEAD_NOLOCK(,penalty_rule) rules;
   AST_LIST_ENTRY(rule_list) list;
};
 
static AST_LIST_HEAD_STATIC(rule_lists, rule_list);
 
static struct ao2_container *queues;
 
static void update_realtime_members(struct call_queue *q);
static struct member *interface_exists(struct call_queue *q, const char *interface);
static int set_member_paused(const char *queuename, const char *interface, const char *reason, int paused);
static int update_queue(struct call_queue *q, struct member *member, int callcompletedinsl, time_t starttime);
 
static struct member *find_member_by_queuename_and_interface(const char *queuename, const char *interface);
/*! \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 < ARRAY_LEN(queue_results); i++) {
      if (queue_results[i].id == res) {
         pbx_builtin_setvar_helper(chan, "QUEUESTATUS", queue_results[i].text);
         return;
      }
   }
}
 
static const char *int2strat(int strategy)
{
   int x;
 
   for (x = 0; x < ARRAY_LEN(strategies); x++) {
      if (strategy == strategies[x].strategy) {
         return strategies[x].name;
      }
   }
 
   return "<unknown>";
}
 
static int strat2int(const char *strategy)
{
   int x;
 
   for (x = 0; x < ARRAY_LEN(strategies); x++) {
      if (!strcasecmp(strategy, strategies[x].name)) {
         return strategies[x].strategy;
      }
   }
 
   return -1;
}
 
static int autopause2int(const char *autopause)
{
   int x;
   /*This 'double check' that default value is OFF */
   if (ast_strlen_zero(autopause)) {
      return QUEUE_AUTOPAUSE_OFF;
   }
 
   /*This 'double check' is to ensure old values works */
   if(ast_true(autopause)) {
      return QUEUE_AUTOPAUSE_ON;
   }
 
   for (x = 0; x < ARRAY_LEN(autopausesmodes); x++) {
      if (!strcasecmp(autopause, autopausesmodes[x].name)) {
         return autopausesmodes[x].autopause;
      }
   }
 
   /*This 'double check' that default value is OFF */
   return QUEUE_AUTOPAUSE_OFF;
}
 
static int queue_hash_cb(const void *obj, const int flags)
{
   const struct call_queue *q = obj;
 
   return ast_str_case_hash(q->name);
}
 
static int queue_cmp_cb(void *obj, void *arg, int flags)
{
   struct call_queue *q = obj, *q2 = arg;
   return !strcasecmp(q->name, q2->name) ? CMP_MATCH | CMP_STOP : 0;
}
 
/*!
 * \brief Return wrapuptime
 *
 * This function checks if wrapuptime in member is set and return this value.
 * Otherwise return value the wrapuptime in the queue configuration
 * \return integer value
 */
static int get_wrapuptime(struct call_queue *q, struct member *member)
{
   if (member->wrapuptime) {
      return member->wrapuptime;
   }
   return q->wrapuptime;
}
 
/*! \internal
 * \brief ao2_callback, Decreases queuepos of all followers with a queuepos greater than arg.
 * \param obj the member being acted on
 * \param arg pointer to an integer containing the position value that was removed and requires reduction for anything above
 * \param flag unused
 */
static int queue_member_decrement_followers(void *obj, void *arg, int flag)
{
   struct member *mem = obj;
   int *decrement_followers_after = arg;
 
   if (mem->queuepos > *decrement_followers_after) {
      mem->queuepos--;
   }
 
   return 0;
}
 
/*! \internal
 * \brief ao2_callback, finds members in a queue marked for deletion and in a cascading fashion runs queue_member_decrement_followers
 *        on them. This callback should always be ran before performing mass unlinking of delmarked members from queues.
 * \param obj member being acted on
 * \param arg pointer to the queue members are being removed from
 * \param flag unused
 */
static int queue_delme_members_decrement_followers(void *obj, void *arg, int flag)
{
   struct member *mem = obj;
   struct call_queue *queue = arg;
   int rrpos = mem->queuepos;
 
   if (mem->delme) {
      ao2_callback(queue->members, OBJ_NODATA | OBJ_MULTIPLE, queue_member_decrement_followers, &rrpos);
   }
 
   return 0;
}
 
/*! \internal
 * \brief Use this to decrement followers during removal of a member
 * \param queue which queue the member is being removed from
 * \param mem which member is being removed from the queue
 */
static void queue_member_follower_removal(struct call_queue *queue, struct member *mem)
{
   int pos = mem->queuepos;
 
   /* If the position being removed is less than the current place in the queue, reduce the queue position by one so that we don't skip the member
    * who would have been next otherwise. */
   if (pos < queue->rrpos) {
      queue->rrpos--;
   }
 
   ao2_callback(queue->members, OBJ_NODATA | OBJ_MULTIPLE, queue_member_decrement_followers, &pos);
}
 
#define queue_ref(q)          ao2_bump(q)
#define queue_unref(q)           ({ ao2_cleanup(q); NULL; })
#define queue_t_ref(q, tag)         ao2_t_bump(q, tag)
#define queue_t_unref(q, tag)    ({ ao2_t_cleanup(q, tag); NULL; })
#define queues_t_link(c, q, tag) ao2_t_link(c, q, tag)
#define queues_t_unlink(c, q, tag)  ao2_t_unlink(c, q, tag)
 
/*! \brief Set variables of queue */
static void set_queue_variables(struct call_queue *q, struct ast_channel *chan)
{
   char interfacevar[256]="";
   float sl = 0;
 
   ao2_lock(q);
 
   if (q->setqueuevar) {
      sl = 0;
      if (q->callscompleted > 0) {
         sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
      }
 
      snprintf(interfacevar, sizeof(interfacevar),
         "QUEUENAME=%s,QUEUEMAX=%d,QUEUESTRATEGY=%s,QUEUECALLS=%d,QUEUEHOLDTIME=%d,QUEUETALKTIME=%d,QUEUECOMPLETED=%d,QUEUEABANDONED=%d,QUEUESRVLEVEL=%d,QUEUESRVLEVELPERF=%2.1f",
         q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted, q->callsabandoned,  q->servicelevel, sl);
 
      ao2_unlock(q);
 
      pbx_builtin_setvar_multiple(chan, interfacevar);
   } else {
      ao2_unlock(q);
   }
}
 
/*! \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;
 
   /* every queue_ent must have a reference to it's parent call_queue, this
    * reference does not go away until the end of the queue_ent's life, meaning
    * that even when the queue_ent leaves the call_queue this ref must remain. */
   queue_ref(q);
   new->parent = q;
   new->pos = ++(*pos);
   new->opos = *pos;
}
 
static struct ast_manager_event_blob *queue_channel_to_ami(const char *type, struct stasis_message *message)
{
   struct ast_channel_blob *obj = stasis_message_data(message);
   RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
   RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
   channel_string = ast_manager_build_channel_state_string(obj->snapshot);
   event_string = ast_manager_str_from_json_object(obj->blob, NULL);
   if (!channel_string || !event_string) {
      return NULL;
   }
 
   return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
      "%s"
      "%s",
      ast_str_buffer(channel_string),
      ast_str_buffer(event_string));
}
 
static struct ast_manager_event_blob *queue_caller_join_to_ami(struct stasis_message *message)
{
   return queue_channel_to_ami("QueueCallerJoin", message);
}
 
static struct ast_manager_event_blob *queue_caller_leave_to_ami(struct stasis_message *message)
{
   return queue_channel_to_ami("QueueCallerLeave", message);
}
 
static struct ast_manager_event_blob *queue_caller_abandon_to_ami(struct stasis_message *message)
{
   return queue_channel_to_ami("QueueCallerAbandon", message);
}
 
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_caller_join_type,
   .to_ami = queue_caller_join_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_caller_leave_type,
   .to_ami = queue_caller_leave_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_caller_abandon_type,
   .to_ami = queue_caller_abandon_to_ami,
   );
 
static struct ast_manager_event_blob *queue_member_to_ami(const char *type, struct stasis_message *message)
{
   struct ast_json_payload *payload = stasis_message_data(message);
   RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
   event_string = ast_manager_str_from_json_object(payload->json, NULL);
   if (!event_string) {
      return NULL;
   }
 
   return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
      "%s",
      ast_str_buffer(event_string));
}
 
static struct ast_manager_event_blob *queue_member_status_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberStatus", message);
}
 
static struct ast_manager_event_blob *queue_member_added_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberAdded", message);
}
 
static struct ast_manager_event_blob *queue_member_removed_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberRemoved", message);
}
 
static struct ast_manager_event_blob *queue_member_pause_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberPause", message);
}
 
static struct ast_manager_event_blob *queue_member_penalty_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberPenalty", message);
}
 
static struct ast_manager_event_blob *queue_member_ringinuse_to_ami(struct stasis_message *message)
{
   return queue_member_to_ami("QueueMemberRinginuse", message);
}
 
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_status_type,
   .to_ami = queue_member_status_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_added_type,
   .to_ami = queue_member_added_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_removed_type,
   .to_ami = queue_member_removed_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_pause_type,
   .to_ami = queue_member_pause_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_penalty_type,
   .to_ami = queue_member_penalty_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_member_ringinuse_type,
   .to_ami = queue_member_ringinuse_to_ami,
   );
 
static struct ast_manager_event_blob *queue_multi_channel_to_ami(const char *type, struct stasis_message *message)
{
   struct ast_multi_channel_blob *obj = stasis_message_data(message);
   struct ast_channel_snapshot *caller;
   struct ast_channel_snapshot *agent;
   RAII_VAR(struct ast_str *, caller_event_string, NULL, ast_free);
   RAII_VAR(struct ast_str *, agent_event_string, NULL, ast_free);
   RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
   caller = ast_multi_channel_blob_get_channel(obj, "caller");
   if (caller) {
      caller_event_string = ast_manager_build_channel_state_string(caller);
      if (!caller_event_string) {
         ast_log(LOG_NOTICE, "No caller event string, bailing\n");
         return NULL;
      }
   }
 
   agent = ast_multi_channel_blob_get_channel(obj, "agent");
   if (agent) {
      agent_event_string = ast_manager_build_channel_state_string_prefix(agent, "Dest");
      if (!agent_event_string) {
         ast_log(LOG_NOTICE, "No agent event string, bailing\n");
         return NULL;
      }
   }
 
   event_string = ast_manager_str_from_json_object(ast_multi_channel_blob_get_json(obj), NULL);
   if (!event_string) {
      return NULL;
   }
 
   return ast_manager_event_blob_create(EVENT_FLAG_AGENT, type,
      "%s"
      "%s"
      "%s",
      caller_event_string ? ast_str_buffer(caller_event_string) : "",
      agent_event_string ? ast_str_buffer(agent_event_string) : "",
      ast_str_buffer(event_string));
}
 
static struct ast_manager_event_blob *queue_agent_called_to_ami(struct stasis_message *message)
{
   return queue_multi_channel_to_ami("AgentCalled", message);
}
 
static struct ast_manager_event_blob *queue_agent_connect_to_ami(struct stasis_message *message)
{
   return queue_multi_channel_to_ami("AgentConnect", message);
}
 
static struct ast_manager_event_blob *queue_agent_complete_to_ami(struct stasis_message *message)
{
   return queue_multi_channel_to_ami("AgentComplete", message);
}
 
static struct ast_manager_event_blob *queue_agent_dump_to_ami(struct stasis_message *message)
{
   return queue_multi_channel_to_ami("AgentDump", message);
}
 
static struct ast_manager_event_blob *queue_agent_ringnoanswer_to_ami(struct stasis_message *message)
{
   return queue_multi_channel_to_ami("AgentRingNoAnswer", message);
}
 
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_agent_called_type,
   .to_ami = queue_agent_called_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_agent_connect_type,
   .to_ami = queue_agent_connect_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_agent_complete_type,
   .to_ami = queue_agent_complete_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_agent_dump_type,
   .to_ami = queue_agent_dump_to_ami,
   );
STASIS_MESSAGE_TYPE_DEFN_LOCAL(queue_agent_ringnoanswer_type,
   .to_ami = queue_agent_ringnoanswer_to_ami,
   );
 
static void queue_publish_multi_channel_snapshot_blob(struct stasis_topic *topic,
      struct ast_channel_snapshot *caller_snapshot,
      struct ast_channel_snapshot *agent_snapshot,
      struct stasis_message_type *type, struct ast_json *blob)
{
   RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
   if (!type) {
      return;
   }
 
   payload = ast_multi_channel_blob_create(blob);
   if (!payload) {
      return;
   }
 
   if (caller_snapshot) {
      ast_multi_channel_blob_add_channel(payload, "caller", caller_snapshot);
   } else {
      ast_debug(1, "Empty caller_snapshot; sending incomplete event\n");
   }
 
   if (agent_snapshot) {
      ast_multi_channel_blob_add_channel(payload, "agent", agent_snapshot);
   }
 
   msg = stasis_message_create(type, payload);
   if (!msg) {
      return;
   }
 
   stasis_publish(topic, msg);
}
 
static void queue_publish_multi_channel_blob(struct ast_channel *caller, struct ast_channel *agent,
      struct stasis_message_type *type, struct ast_json *blob)
{
   RAII_VAR(struct ast_channel_snapshot *, caller_snapshot, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, agent_snapshot, NULL, ao2_cleanup);
 
   ast_channel_lock(caller);
   caller_snapshot = ast_channel_snapshot_create(caller);
   ast_channel_unlock(caller);
   ast_channel_lock(agent);
   agent_snapshot = ast_channel_snapshot_create(agent);
   ast_channel_unlock(agent);
 
   if (!caller_snapshot || !agent_snapshot) {
      return;
   }
 
   queue_publish_multi_channel_snapshot_blob(ast_channel_topic(caller), caller_snapshot,
         agent_snapshot, type, blob);
}
 
/*!
 * \internal
 * \brief Publish the member blob.
 * \since 12.0.0
 *
 * \param type Stasis message type to publish.
 * \param blob The information being published.
 *
 * \note The json blob reference is passed to this function.
 */
static void queue_publish_member_blob(struct stasis_message_type *type, struct ast_json *blob)
{
   RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
   if (!blob || !type) {
      ast_json_unref(blob);
      return;
   }
 
   payload = ast_json_payload_create(blob);
   ast_json_unref(blob);
   if (!payload) {
      return;
   }
 
   msg = stasis_message_create(type, payload);
   if (!msg) {
      return;
   }
 
   stasis_publish(ast_manager_get_topic(), msg);
}
 
static struct ast_json *queue_member_blob_create(struct call_queue *q, struct member *mem)
{
   return ast_json_pack("{s: s, s: s, s: s, s: s, s: s, s: i, s: i, s: i, s: i, s: i, s: i, s: i, s: i, s: s, s: i, s: i}",
      "Queue", q->name,
      "MemberName", mem->membername,
      "Interface", mem->interface,
      "StateInterface", mem->state_interface,
      "Membership", (mem->dynamic ? "dynamic" : (mem->realtime ? "realtime" : "static")),
      "Penalty", mem->penalty,
      "CallsTaken", mem->calls,
      "LastCall", (int)mem->lastcall,
      "LastPause", (int)mem->lastpause,
      "LoginTime", (int)mem->logintime,
      "InCall", mem->starttime ? 1 : 0,
      "Status", mem->status,
      "Paused", mem->paused,
      "PausedReason", mem->reason_paused,
      "Ringinuse", mem->ringinuse,
      "Wrapuptime", mem->wrapuptime);
}
 
/*! \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 0. If no members are available,
 * then -1 is returned.
 */
static int get_member_status(struct call_queue *q, int max_penalty, int min_penalty, int raise_penalty, enum empty_conditions conditions, int devstate)
{
   struct member *member;
   struct ao2_iterator mem_iter;
 
   ao2_lock(q);
   mem_iter = ao2_iterator_init(q->members, 0);
   for (; (member = ao2_iterator_next(&mem_iter)); ao2_ref(member, -1)) {
      int penalty = member->penalty;
      if (raise_penalty != INT_MAX && penalty < raise_penalty) {
         ast_debug(4, "%s is having his penalty raised up from %d to %d\n", member->membername, penalty, raise_penalty);
         penalty = raise_penalty;
      }
      if ((max_penalty != INT_MAX && penalty > max_penalty) || (min_penalty != INT_MAX && penalty < min_penalty)) {
         if (conditions & QUEUE_EMPTY_PENALTY) {
            ast_debug(4, "%s is unavailable because his penalty is not between %d and %d\n", member->membername, min_penalty, max_penalty);
            continue;
         }
      }
 
      switch (devstate ? ast_device_state(member->state_interface) : member->status) {
      case AST_DEVICE_INVALID:
         if (conditions & QUEUE_EMPTY_INVALID) {
            ast_debug(4, "%s is unavailable because his device state is 'invalid'\n", member->membername);
            break;
         }
         goto default_case;
      case AST_DEVICE_UNAVAILABLE:
         if (conditions & QUEUE_EMPTY_UNAVAILABLE) {
            ast_debug(4, "%s is unavailable because his device state is 'unavailable'\n", member->membername);
            break;
         }
         goto default_case;
      case AST_DEVICE_INUSE:
         if (conditions & QUEUE_EMPTY_INUSE) {
            ast_debug(4, "%s is unavailable because his device state is 'inuse'\n", member->membername);
            break;
         }
         goto default_case;
      case AST_DEVICE_RINGING:
         if (conditions & QUEUE_EMPTY_RINGING) {
            ast_debug(4, "%s is unavailable because his device state is 'ringing'\n", member->membername);
            break;
         }
         goto default_case;
      case AST_DEVICE_UNKNOWN:
         if (conditions & QUEUE_EMPTY_UNKNOWN) {
            ast_debug(4, "%s is unavailable because his device state is 'unknown'\n", member->membername);
            break;
         }
         /* Fall-through */
      default:
      default_case:
         if (member->paused && (conditions & QUEUE_EMPTY_PAUSED)) {
            ast_debug(4, "%s is unavailable because he is paused'\n", member->membername);
            break;
         } else if ((conditions & QUEUE_EMPTY_WRAPUP)
            && member->lastcall
            && get_wrapuptime(q, member)
            && (time(NULL) - get_wrapuptime(q, member) < member->lastcall)) {
            ast_debug(4, "%s is unavailable because it has only been %d seconds since his last call (wrapup time is %d)\n",
               member->membername, (int) (time(NULL) - member->lastcall), get_wrapuptime(q, member));
            break;
         } else {
            ao2_ref(member, -1);
            ao2_iterator_destroy(&mem_iter);
            ao2_unlock(q);
            ast_debug(4, "%s is available.\n", member->membername);
            return 0;
         }
         break;
      }
   }
   ao2_iterator_destroy(&mem_iter);
   ao2_unlock(q);
 
   if (!devstate && (conditions & QUEUE_EMPTY_RINGING)) {
      /* member state still may be RINGING due to lag in event message - check again with device state */
      return get_member_status(q, max_penalty, min_penalty, raise_penalty, conditions, 1);
   }
   return -1;
}
 
/*
 * A "pool" of member objects that calls are currently pending on. If an
 * agent is a member of multiple queues it's possible for that agent to be
 * called by each of the queues at the same time. This happens because device
 * state is slow to notify the queue app of one of it's member's being rung.
 * This "pool" allows us to track which members are currently being rung while
 * we wait on the device state change.
 */
static struct ao2_container *pending_members;
#define MAX_CALL_ATTEMPT_BUCKETS 353
 
static int pending_members_hash(const void *obj, const int flags)
{
   const struct member *object;
   const char *key;
 
   switch (flags & OBJ_SEARCH_MASK) {
   case OBJ_SEARCH_KEY:
      key = obj;
      break;
   case OBJ_SEARCH_OBJECT:
      object = obj;
      key = object->interface;
      break;
   default:
      ast_assert(0);
      return 0;
   }
   return ast_str_case_hash(key);
}
 
static int pending_members_cmp(void *obj, void *arg, int flags)
{
   const struct member *object_left = obj;
   const struct member *object_right = arg;
   const char *right_key = arg;
   int cmp;
 
   switch (flags & OBJ_SEARCH_MASK) {
   case OBJ_SEARCH_OBJECT:
      right_key = object_right->interface;
      /* Fall through */
   case OBJ_SEARCH_KEY:
      cmp = strcasecmp(object_left->interface, right_key);
      break;
   case OBJ_SEARCH_PARTIAL_KEY:
      /* Not supported by container. */
      ast_assert(0);
      return 0;
   default:
      cmp = 0;
      break;
   }
   if (cmp) {
      return 0;
   }
   return CMP_MATCH;
}
 
static void pending_members_remove(struct member *mem)
{
   ast_debug(3, "Removed %s from pending_members\n", mem->membername);
   ao2_find(pending_members, mem, OBJ_POINTER | OBJ_NODATA | OBJ_UNLINK);
}
 
/*! \brief set a member's status based on device state of that member's state_interface.
 *
 * Lock interface list find sc, iterate through each queues queue_member list for member to
 * update state inside queues
*/
static void update_status(struct call_queue *q, struct member *m, const int status)
{
   if (m->status != status) {
      /* If this member has transitioned to being available then update their queue
       * information. If they are currently in a call then the leg to the agent will be
       * considered done and the call finished.
       */
      if (status == AST_DEVICE_NOT_INUSE) {
         update_queue(q, m, m->callcompletedinsl, m->starttime);
      }
 
      m->status = status;
 
      /* Remove the member from the pending members pool only when the status changes.
       * This is not done unconditionally because we can occasionally see multiple
       * device state notifications of not in use after a previous call has ended,
       * including after we have initiated a new call. This is more likely to
       * happen when there is latency in the connection to the member.
       */
      pending_members_remove(m);
 
      queue_publish_member_blob(queue_member_status_type(), queue_member_blob_create(q, m));
   }
}
 
/*!
 * \internal
 * \brief Determine if a queue member is available
 * \retval 1 if the member is available
 * \retval 0 if the member is not available
 */
static int is_member_available(struct call_queue *q, struct member *mem)
{
   int available = 0;
   int wrapuptime;
 
   switch (mem->status) {
      case AST_DEVICE_INVALID:
      case AST_DEVICE_UNAVAILABLE:
         break;
      case AST_DEVICE_INUSE:
      case AST_DEVICE_BUSY:
      case AST_DEVICE_RINGING:
      case AST_DEVICE_RINGINUSE:
      case AST_DEVICE_ONHOLD:
         if (!mem->ringinuse) {
            break;
         }
         /* else fall through */
      case AST_DEVICE_NOT_INUSE:
      case AST_DEVICE_UNKNOWN:
         if (!mem->paused) {
            available = 1;
         }
         break;
   }
 
   /* Let wrapuptimes override device state availability */
   wrapuptime = get_wrapuptime(q, mem);
   if (mem->lastcall && wrapuptime && (time(NULL) - wrapuptime < mem->lastcall)) {
      available = 0;
   }
   return available;
}
 
/*! \brief set a member's status based on device state of that member's interface*/
static void device_state_cb(void *unused, struct stasis_subscription *sub, struct stasis_message *msg)
{
   struct ao2_iterator miter, qiter;
   struct ast_device_state_message *dev_state;
   struct member *m;
   struct call_queue *q;
   char interface[80], *slash_pos;
   int found = 0;       /* Found this member in any queue */
   int found_member;    /* Found this member in this queue */
   int avail = 0;       /* Found an available member in this queue */
 
   if (ast_device_state_message_type() != stasis_message_type(msg)) {
      return;
   }
 
   dev_state = stasis_message_data(msg);
   if (dev_state->eid) {
      /* ignore non-aggregate states */
      return;
   }
 
   qiter = ao2_iterator_init(queues, 0);
   while ((q = ao2_t_iterator_next(&qiter, "Iterate over queues"))) {
      ao2_lock(q);
 
      avail = 0;
      found_member = 0;
      miter = ao2_iterator_init(q->members, 0);
      for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
         if (!found_member) {
            ast_copy_string(interface, m->state_interface, sizeof(interface));
 
            if ((slash_pos = strchr(interface, '/'))) {
               if (!strncasecmp(interface, "Local/", 6) && (slash_pos = strchr(slash_pos + 1, '/'))) {
                  *slash_pos = '\0';
               }
            }
 
            if (!strcasecmp(interface, dev_state->device)) {
               found_member = 1;
               update_status(q, m, dev_state->state);
            }
         }
 
         /* check every member until we find one NOT_INUSE */
         if (!avail) {
            avail = is_member_available(q, m);
         }
         if (avail && found_member) {
            /* early exit as we've found an available member and the member of interest */
            ao2_ref(m, -1);
            break;
         }
      }
 
      if (found_member) {
         found = 1;
         if (avail) {
            ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
         } else {
            ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
         }
      }
 
      ao2_iterator_destroy(&miter);
 
      ao2_unlock(q);
      queue_t_unref(q, "Done with iterator");
   }
   ao2_iterator_destroy(&qiter);
 
   if (found) {
      ast_debug(1, "Device '%s' changed to state '%u' (%s)\n",
         dev_state->device,
         dev_state->state,
         ast_devstate2str(dev_state->state));
   } else {
      ast_debug(3, "Device '%s' changed to state '%u' (%s) but we don't care because they're not a member of any queue.\n",
         dev_state->device,
         dev_state->state,
         ast_devstate2str(dev_state->state));
   }
 
   return;
}
 
/*! \brief Helper function which converts from extension state to device state values */
static int extensionstate2devicestate(int state)
{
   switch (state) {
   case AST_EXTENSION_NOT_INUSE:
      state = AST_DEVICE_NOT_INUSE;
      break;
   case AST_EXTENSION_INUSE:
      state = AST_DEVICE_INUSE;
      break;
   case AST_EXTENSION_BUSY:
      state = AST_DEVICE_BUSY;
      break;
   case AST_EXTENSION_RINGING:
      state = AST_DEVICE_RINGING;
      break;
   case AST_EXTENSION_INUSE | AST_EXTENSION_RINGING:
      state = AST_DEVICE_RINGINUSE;
      break;
   case AST_EXTENSION_ONHOLD:
      state = AST_DEVICE_ONHOLD;
      break;
   case AST_EXTENSION_INUSE | AST_EXTENSION_ONHOLD:
      state = AST_DEVICE_INUSE;
      break;
   case AST_EXTENSION_UNAVAILABLE:
      state = AST_DEVICE_UNAVAILABLE;
      break;
   case AST_EXTENSION_REMOVED:
   case AST_EXTENSION_DEACTIVATED:
   default:
      state = AST_DEVICE_INVALID;
      break;
   }
 
   return state;
}
 
/*!
 * \brief Returns if one context includes another context
 *
 * \param parent Parent context to search for child
 * \param child Context to check for inclusion in parent
 *
 * This function recursively checks if the context child is included in the context parent.
 *
 * \retval 1 if child is included in parent
 * \retval 0 if not
 */
static int context_included(const char *parent, const char *child);
static int context_included(const char *parent, const char *child)
{
   struct ast_context *c = NULL;
 
   c = ast_context_find(parent);
   if (!c) {
      /* well, if parent doesn't exist, how can the child be included in it? */
      return 0;
   }
   if (!strcmp(ast_get_context_name(c), parent)) {
      /* found the context of the hint app_queue is using. Now, see
         if that context includes the one that just changed state */
      struct ast_include *inc = NULL;
 
      while ((inc = (struct ast_include*) ast_walk_context_includes(c, inc))) {
         const char *includename = ast_get_include_name(inc);
         if (!strcasecmp(child, includename)) {
            return 1;
         }
         /* recurse on this context, for nested includes. The
            PBX extension parser will prevent infinite recursion. */
         if (context_included(includename, child)) {
            return 1;
         }
      }
   }
   return 0;
}
 
static int extension_state_cb(const char *context, const char *exten, struct ast_state_cb_info *info, void *data)
{
   struct ao2_iterator miter, qiter;
   struct member *m;
   struct call_queue *q;
   int state = info->exten_state;
   int found = 0, device_state = extensionstate2devicestate(state);
 
   /* only interested in extension state updates involving device states */
   if (info->reason != AST_HINT_UPDATE_DEVICE) {
      return 0;
   }
 
   qiter = ao2_iterator_init(queues, 0);
   while ((q = ao2_t_iterator_next(&qiter, "Iterate through queues"))) {
      ao2_lock(q);
 
      miter = ao2_iterator_init(q->members, 0);
      for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
         if (!strcmp(m->state_context, context) && !strcmp(m->state_exten, exten)) {
            found = 1;
         } else if (!strcmp(m->state_exten, exten) && context_included(m->state_context, context)) {
            /* context could be included in m->state_context. We need to check. */
            found = 1;
         }
         if (found) {
            update_status(q, m, device_state);
            ao2_ref(m, -1);
            break;
         }
      }
      ao2_iterator_destroy(&miter);
 
      ao2_unlock(q);
      queue_t_unref(q, "Done with iterator");
   }
   ao2_iterator_destroy(&qiter);
 
   if (found) {
      ast_debug(1, "Extension '%s@%s' changed to state '%d' (%s)\n", exten, context, device_state, ast_devstate2str(device_state));
   } else {
      ast_debug(3, "Extension '%s@%s' changed to state '%d' (%s) but we don't care because they're not a member of any queue.\n",
           exten, context, device_state, ast_devstate2str(device_state));
   }
 
   return 0;
}
 
/*! \brief Return the current state of a member */
static int get_queue_member_status(struct member *cur)
{
   return ast_strlen_zero(cur->state_exten) ? ast_device_state(cur->state_interface) : extensionstate2devicestate(ast_extension_state(NULL, cur->state_context, cur->state_exten));
}
 
static void destroy_queue_member_cb(void *obj)
{
   struct member *mem = obj;
 
   if (mem->state_id != -1) {
      ast_extension_state_del(mem->state_id, extension_state_cb);
   }
}
 
/*! \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, const char *state_interface, int ringinuse, int wrapuptime)
{
   struct member *cur;
 
   if ((cur = ao2_alloc(sizeof(*cur), destroy_queue_member_cb))) {
      cur->ringinuse = ringinuse;
      cur->penalty = penalty;
      cur->paused = paused;
      cur->wrapuptime = wrapuptime;
      if (paused) {
         time(&cur->lastpause); /* Update time of last pause */
      }
      time(&cur->logintime);
      ast_copy_string(cur->interface, interface, sizeof(cur->interface));
      if (!ast_strlen_zero(state_interface)) {
         ast_copy_string(cur->state_interface, state_interface, sizeof(cur->state_interface));
      } else {
         ast_copy_string(cur->state_interface, interface, sizeof(cur->state_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);
      }
      if (!strncmp(cur->state_interface, "hint:", 5)) {
         char *tmp = ast_strdupa(cur->state_interface), *context = tmp;
         char *exten = strsep(&context, "@") + 5;
 
         ast_copy_string(cur->state_exten, exten, sizeof(cur->state_exten));
         ast_copy_string(cur->state_context, S_OR(context, "default"), sizeof(cur->state_context));
 
         cur->state_id = ast_extension_state_add(cur->state_context, cur->state_exten, extension_state_cb, NULL);
      } else {
         cur->state_id = -1;
      }
      cur->status = get_queue_member_status(cur);
   }
 
   return cur;
}
 
 
static int compress_char(const char c)
{
   if (c < 32) {
      return 0;
   } else if (c > 96) {
      return c - 64;
   }
   return c - 32;
}
 
static int member_hash_fn(const void *obj, const int flags)
{
   const struct member *mem = obj;
   const char *interface = (flags & OBJ_KEY) ? obj : mem->interface;
   const char *chname = strchr(interface, '/');
   int ret = 0, i;
 
   if (!chname) {
      chname = 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;
   struct member *mem2 = obj2;
   const char *interface = (flags & OBJ_KEY) ? obj2 : mem2->interface;
 
   return strcasecmp(mem1->interface, interface) ? 0 : CMP_MATCH | CMP_STOP;
}
 
/*!
 * \brief Initialize Queue default values.
 * \note the queue's lock  must be held before executing this function
*/
static void init_queue(struct call_queue *q)
{
   int i;
   struct penalty_rule *pr_iter;
 
   q->dead = 0;
   q->retry = DEFAULT_RETRY;
   q->timeout = DEFAULT_TIMEOUT;
   q->maxlen = 0;
 
   ast_string_field_set(q, context, "");
 
   q->announcefrequency = 0;
   q->minannouncefrequency = DEFAULT_MIN_ANNOUNCE_FREQUENCY;
   q->announceholdtime = 1;
   q->announceposition_only_up = 0;
   q->announcepositionlimit = 10; /* Default 10 positions */
   q->announceposition = ANNOUNCEPOSITION_YES; /* Default yes */
   q->roundingseconds = 0; /* Default - don't announce seconds */
   q->servicelevel = 0;
   q->ringinuse = 1;
   q->announce_to_first_user = 0;
   q->setinterfacevar = 0;
   q->setqueuevar = 0;
   q->setqueueentryvar = 0;
   q->autofill = autofill_default;
   q->montype = montype_default;
   q->monfmt[0] = '\0';
   q->reportholdtime = 0;
   q->wrapuptime = 0;
   q->penaltymemberslimit = 0;
   q->joinempty = 0;
   q->leavewhenempty = 0;
   q->memberdelay = 0;
   q->weight = 0;
   q->timeoutrestart = 0;
   q->periodicannouncefrequency = 0;
   q->randomperiodicannounce = 0;
   q->numperiodicannounce = 0;
   q->autopause = QUEUE_AUTOPAUSE_OFF;
   q->timeoutpriority = TIMEOUT_PRIORITY_APP;
   q->autopausedelay = 0;
   if (!q->members) {
      if (q->strategy == QUEUE_STRATEGY_LINEAR || q->strategy == QUEUE_STRATEGY_RRORDERED) {
         /* linear strategy depends on order, so we have to place all members in a list */
         q->members = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, member_cmp_fn);
      } else {
         q->members = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
            member_hash_fn, NULL, member_cmp_fn);
      }
   }
   q->found = 1;
 
   ast_string_field_set(q, moh, "");
   ast_string_field_set(q, sound_next, "queue-youarenext");
   ast_string_field_set(q, sound_thereare, "queue-thereare");
   ast_string_field_set(q, sound_calls, "queue-callswaiting");
   ast_string_field_set(q, queue_quantity1, "queue-quantity1");
   ast_string_field_set(q, queue_quantity2, "queue-quantity2");
   ast_string_field_set(q, sound_holdtime, "queue-holdtime");
   ast_string_field_set(q, sound_minutes, "queue-minutes");
   ast_string_field_set(q, sound_minute, "queue-minute");
   ast_string_field_set(q, sound_seconds, "queue-seconds");
   ast_string_field_set(q, sound_thanks, "queue-thankyou");
   ast_string_field_set(q, sound_reporthold, "queue-reporthold");
 
   if (!q->sound_periodicannounce[0]) {
      q->sound_periodicannounce[0] = ast_str_create(32);
   }
 
   if (q->sound_periodicannounce[0]) {
      ast_str_set(&q->sound_periodicannounce[0], 0, "queue-periodic-announce");
   }
 
   for (i = 1; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
      if (q->sound_periodicannounce[i]) {
         ast_str_set(&q->sound_periodicannounce[i], 0, "%s", "");
      }
   }
 
   while ((pr_iter = AST_LIST_REMOVE_HEAD(&q->rules,list))) {
      ast_free(pr_iter);
   }
 
   /* On restart assume no members are available.
    * The queue_avail hint is a boolean state to indicate whether a member is available or not.
    *
    * This seems counter intuitive, but is required to light a BLF
    * AST_DEVICE_INUSE indicates no members are available.
    * AST_DEVICE_NOT_INUSE indicates a member is available.
    */
   ast_devstate_changed(AST_DEVICE_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s_avail", q->name);
}
 
static void clear_queue(struct call_queue *q)
{
   q->holdtime = 0;
   q->callscompleted = 0;
   q->callsabandoned = 0;
   q->callscompletedinsl = 0;
   q->callsabandonedinsl = 0;
   q->talktime = 0;
 
   if (q->members) {
      struct member *mem;
      struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
      while ((mem = ao2_iterator_next(&mem_iter))) {
         mem->calls = 0;
         mem->callcompletedinsl = 0;
         mem->lastcall = 0;
         mem->starttime = 0;
         ao2_ref(mem, -1);
      }
      ao2_iterator_destroy(&mem_iter);
   }
}
 
/*!
 * \brief Change queue penalty by adding rule.
 *
 * Check rule for errors with time or formatting, see if rule is relative to rest
 * of queue, iterate list of rules to find correct insertion point, insert and return.
 * \retval -1 on failure
 * \retval 0 on success
 * \note Call this with the rule_lists locked
*/
static int insert_penaltychange(const char *list_name, const char *content, const int linenum)
{
   char *timestr, *maxstr, *minstr, *raisestr, *contentdup;
   struct penalty_rule *rule = NULL, *rule_iter;
   struct rule_list *rl_iter;
   int penaltychangetime, inserted = 0;
 
   if (!(rule = ast_calloc(1, sizeof(*rule)))) {
      return -1;
   }
 
   contentdup = ast_strdupa(content);
 
   if (!(maxstr = strchr(contentdup, ','))) {
      ast_log(LOG_WARNING, "Improperly formatted penaltychange rule at line %d. Ignoring.\n", linenum);
      ast_free(rule);
      return -1;
   }
 
   *maxstr++ = '\0';
   if ((minstr = strchr(maxstr,','))) {
      *minstr++ = '\0';
      if ((raisestr = strchr(minstr,','))) {
         *raisestr++ = '\0';
      }
   } else {
      raisestr = NULL;
   }
 
   timestr = contentdup;
   if ((penaltychangetime = atoi(timestr)) < 0) {
      ast_log(LOG_WARNING, "Improper time parameter specified for penaltychange rule at line %d. Ignoring.\n", linenum);
      ast_free(rule);
      return -1;
   }
 
   rule->time = penaltychangetime;
 
   /* The last check will evaluate true if either no penalty change is indicated for a given rule
    * OR if a min penalty change is indicated but no max penalty change is */
   if (*maxstr == '+' || *maxstr == '-' || *maxstr == '\0') {
      rule->max_relative = 1;
   }
 
   rule->max_value = atoi(maxstr);
 
   if (!ast_strlen_zero(minstr)) {
      if (*minstr == '+' || *minstr == '-') {
         rule->min_relative = 1;
      }
      rule->min_value = atoi(minstr);
   } else { /*there was no minimum specified, so assume this means no change*/
      rule->min_relative = 1;
   }
 
   if (!ast_strlen_zero(raisestr)) {
      if (*raisestr == '+' || *raisestr == '-') {
         rule->raise_relative = 1;
      }
      rule->raise_value = atoi(raisestr);
   } else { /*there was no raise specified, so assume this means no change*/
      rule->raise_relative = 1;
   }
 
   /*We have the rule made, now we need to insert it where it belongs*/
   AST_LIST_TRAVERSE(&rule_lists, rl_iter, list){
      if (strcasecmp(rl_iter->name, list_name)) {
         continue;
      }
 
      AST_LIST_TRAVERSE_SAFE_BEGIN(&rl_iter->rules, rule_iter, list) {
         if (rule->time < rule_iter->time) {
            AST_LIST_INSERT_BEFORE_CURRENT(rule, list);
            inserted = 1;
            break;
         }
      }
      AST_LIST_TRAVERSE_SAFE_END;
 
      if (!inserted) {
         AST_LIST_INSERT_TAIL(&rl_iter->rules, rule, list);
         inserted = 1;
      }
 
      break;
   }
 
   if (!inserted) {
      ast_log(LOG_WARNING, "Unknown rule list name %s; ignoring.\n", list_name);
      ast_free(rule);
      return -1;
   }
   return 0;
}
 
/*!
 * \brief Load queue rules from realtime.
 *
 * Check rule for errors with time or formatting, see if rule is relative to rest
 * of queue, iterate list of rules to find correct insertion point, insert and return.
 * \retval -1 on failure
 * \retval 0 on success
 * \note Call this with the rule_lists locked
*/
static int load_realtime_rules(void)
{
   struct ast_config *cfg;
        struct rule_list *rl_iter, *new_rl;
        struct penalty_rule *pr_iter;
        char *rulecat = NULL;
 
   if (!ast_check_realtime("queue_rules")) {
      ast_log(LOG_WARNING, "Missing \"queue_rules\" in extconfig.conf\n");
      return 0;
   }
   if (!(cfg = ast_load_realtime_multientry("queue_rules", "rule_name LIKE", "%", SENTINEL))) {
      ast_log(LOG_WARNING, "Failed to load queue rules from realtime\n");
      return 0;
   }
   while ((rulecat = ast_category_browse(cfg, rulecat))) {
      const char *timestr, *maxstr, *minstr, *raisestr, *rule_name;
      int penaltychangetime, rule_exists = 0, inserted = 0;
      int max_penalty = 0, min_penalty = 0, raise_penalty = 0;
      int min_relative = 0, max_relative = 0, raise_relative = 0;
      struct penalty_rule *new_penalty_rule = NULL;
 
      rule_name = ast_variable_retrieve(cfg, rulecat, "rule_name");
      if (ast_strlen_zero(rule_name)) {
         continue;
      }
 
      AST_LIST_TRAVERSE(&rule_lists, rl_iter, list) {
         if (!(strcasecmp(rl_iter->name, rule_name))) {
            rule_exists = 1;
            new_rl = rl_iter;
            break;
         }
      }
      if (!rule_exists) {
         if (!(new_rl = ast_calloc(1, sizeof(*new_rl)))) {
            ast_config_destroy(cfg);
            return -1;
         }
         ast_copy_string(new_rl->name, rule_name, sizeof(new_rl->name));
         AST_LIST_INSERT_TAIL(&rule_lists, new_rl, list);
      }
      timestr = ast_variable_retrieve(cfg, rulecat, "time");
      if (!(timestr) || sscanf(timestr, "%30d", &penaltychangetime) != 1) {
         ast_log(LOG_NOTICE, "Failed to parse time (%s) for one of the %s rules, skipping it\n",
            (ast_strlen_zero(timestr) ? "invalid value" : timestr), rule_name);
         continue;
      }
      if (!(new_penalty_rule = ast_calloc(1, sizeof(*new_penalty_rule)))) {
         ast_config_destroy(cfg);
         return -1;
      }
      if (!(maxstr = ast_variable_retrieve(cfg, rulecat, "max_penalty")) ||
         ast_strlen_zero(maxstr) || sscanf(maxstr, "%30d", &max_penalty) != 1) {
         max_penalty = 0;
         max_relative = 1;
      } else {
         if (*maxstr == '+' || *maxstr == '-') {
            max_relative = 1;
         }
      }
      if (!(minstr = ast_variable_retrieve(cfg, rulecat, "min_penalty")) ||
         ast_strlen_zero(minstr) || sscanf(minstr, "%30d", &min_penalty) != 1) {
         min_penalty = 0;
         min_relative = 1;
      } else {
         if (*minstr == '+' || *minstr == '-') {
            min_relative = 1;
         }
      }
      if (!(raisestr = ast_variable_retrieve(cfg, rulecat, "raise_penalty")) ||
         ast_strlen_zero(raisestr) || sscanf(raisestr, "%30d", &raise_penalty) != 1) {
         raise_penalty = 0;
         raise_relative = 1;
      } else {
         if (*raisestr == '+' || *raisestr == '-') {
            raise_relative = 1;
         }
      }
      new_penalty_rule->time = penaltychangetime;
      new_penalty_rule->max_relative = max_relative;
      new_penalty_rule->max_value = max_penalty;
      new_penalty_rule->min_relative = min_relative;
      new_penalty_rule->min_value = min_penalty;
      new_penalty_rule->raise_relative = raise_relative;
      new_penalty_rule->raise_value = raise_penalty;
      AST_LIST_TRAVERSE_SAFE_BEGIN(&new_rl->rules, pr_iter, list) {
         if (new_penalty_rule->time < pr_iter->time) {
            AST_LIST_INSERT_BEFORE_CURRENT(new_penalty_rule, list);
            inserted = 1;
         }
      }
      AST_LIST_TRAVERSE_SAFE_END;
      if (!inserted) {
         AST_LIST_INSERT_TAIL(&new_rl->rules, new_penalty_rule, list);
      }
   }
 
   ast_config_destroy(cfg);
   return 0;
}
 
static void parse_empty_options(const char *value, enum empty_conditions *empty, int joinempty)
{
   char *value_copy = ast_strdupa(value);
   char *option = NULL;
   while ((option = strsep(&value_copy, ","))) {
      if (!strcasecmp(option, "paused")) {
         *empty |= QUEUE_EMPTY_PAUSED;
      } else if (!strcasecmp(option, "penalty")) {
         *empty |= QUEUE_EMPTY_PENALTY;
      } else if (!strcasecmp(option, "inuse")) {
         *empty |= QUEUE_EMPTY_INUSE;
      } else if (!strcasecmp(option, "ringing")) {
         *empty |= QUEUE_EMPTY_RINGING;
      } else if (!strcasecmp(option, "invalid")) {
         *empty |= QUEUE_EMPTY_INVALID;
      } else if (!strcasecmp(option, "wrapup")) {
         *empty |= QUEUE_EMPTY_WRAPUP;
      } else if (!strcasecmp(option, "unavailable")) {
         *empty |= QUEUE_EMPTY_UNAVAILABLE;
      } else if (!strcasecmp(option, "unknown")) {
         *empty |= QUEUE_EMPTY_UNKNOWN;
      } else if (!strcasecmp(option, "loose")) {
         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID);
      } else if (!strcasecmp(option, "strict")) {
         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED | QUEUE_EMPTY_UNAVAILABLE);
      } else if ((ast_false(option) && joinempty) || (ast_true(option) && !joinempty)) {
         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED);
      } else if ((ast_false(option) && !joinempty) || (ast_true(option) && joinempty)) {
         *empty = 0;
      } else {
         ast_log(LOG_WARNING, "Unknown option %s for '%s'\n", option, joinempty ? "joinempty" : "leavewhenempty");
      }
   }
}
 
/*! \brief Configure a queue parameter.
 *
 * The failunknown flag is set for config files (and static realtime) to show
 * errors for unknown parameters. It is cleared for dynamic realtime to allow
 *  extra fields in the tables.
 * \note For error reporting, line number is passed for .conf static configuration,
 * for Realtime queues, linenum is -1.
*/
static void queue_set_param(struct call_queue *q, const char *param, const char *val, int linenum, int failunknown)
{
   if (!strcasecmp(param, "musicclass") ||
      !strcasecmp(param, "music") || !strcasecmp(param, "musiconhold")) {
      ast_string_field_set(q, moh, val);
   } else if (!strcasecmp(param, "announce")) {
      ast_string_field_set(q, announce, val);
   } else if (!strcasecmp(param, "context")) {
      ast_string_field_set(q, context, val);
   } else if (!strcasecmp(param, "timeout")) {
      q->timeout = atoi(val);
      if (q->timeout < 0) {
         q->timeout = DEFAULT_TIMEOUT;
      }
   } else if (!strcasecmp(param, "ringinuse")) {
      q->ringinuse = ast_true(val);
   } else if (!strcasecmp(param, "setinterfacevar")) {
      q->setinterfacevar = ast_true(val);
   } else if (!strcasecmp(param, "setqueuevar")) {
      q->setqueuevar = ast_true(val);
   } else if (!strcasecmp(param, "setqueueentryvar")) {
      q->setqueueentryvar = ast_true(val);
   } else if (!strcasecmp(param, "monitor-format")) {
      ast_copy_string(q->monfmt, val, sizeof(q->monfmt));
   } else if (!strcasecmp(param, "membermacro")) {
      ast_string_field_set(q, membermacro, val);
   } else if (!strcasecmp(param, "membergosub")) {
      ast_string_field_set(q, membergosub, val);
   } else if (!strcasecmp(param, "queue-youarenext")) {
      ast_string_field_set(q, sound_next, val);
   } else if (!strcasecmp(param, "queue-thereare")) {
      ast_string_field_set(q, sound_thereare, val);
   } else if (!strcasecmp(param, "queue-callswaiting")) {
      ast_string_field_set(q, sound_calls, val);
   } else if (!strcasecmp(param, "queue-quantity1")) {
      ast_string_field_set(q, queue_quantity1, val);
   } else if (!strcasecmp(param, "queue-quantity2")) {
      ast_string_field_set(q, queue_quantity2, val);
   } else if (!strcasecmp(param, "queue-holdtime")) {
      ast_string_field_set(q, sound_holdtime, val);
   } else if (!strcasecmp(param, "queue-minutes")) {
      ast_string_field_set(q, sound_minutes, val);
   } else if (!strcasecmp(param, "queue-minute")) {
      ast_string_field_set(q, sound_minute, val);
   } else if (!strcasecmp(param, "queue-seconds")) {
      ast_string_field_set(q, sound_seconds, val);
   } else if (!strcasecmp(param, "queue-thankyou")) {
      ast_string_field_set(q, sound_thanks, val);
   } else if (!strcasecmp(param, "queue-callerannounce")) {
      ast_string_field_set(q, sound_callerannounce, val);
   } else if (!strcasecmp(param, "queue-reporthold")) {
      ast_string_field_set(q, sound_reporthold, val);
   } else if (!strcasecmp(param, "announce-frequency")) {
      q->announcefrequency = atoi(val);
   } else if (!strcasecmp(param, "announce-to-first-user")) {
      q->announce_to_first_user = ast_true(val);
   } else if (!strcasecmp(param, "min-announce-frequency")) {
      q->minannouncefrequency = atoi(val);
      ast_debug(1, "%s=%s for queue '%s'\n", param, val, q->name);
   } else if (!strcasecmp(param, "announce-round-seconds")) {
      q->roundingseconds = atoi(val);
      /* Rounding to any other values just doesn't make sense... */
      if (!(q->roundingseconds == 0 || q->roundingseconds == 5 || q->roundingseconds == 10
         || q->roundingseconds == 15 || q->roundingseconds == 20 || q->roundingseconds == 30)) {
         if (linenum >= 0) {
            ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
               "using 0 instead for queue '%s' at line %d of queues.conf\n",
               val, param, q->name, linenum);
         } else {
            ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
               "using 0 instead for queue '%s'\n", val, param, q->name);
         }
         q->roundingseconds=0;
      }
   } else if (!strcasecmp(param, "announce-holdtime")) {
      if (!strcasecmp(val, "once")) {
         q->announceholdtime = ANNOUNCEHOLDTIME_ONCE;
      } else if (ast_true(val)) {
         q->announceholdtime = ANNOUNCEHOLDTIME_ALWAYS;
      } else {
         q->announceholdtime = 0;
      }
   } else if (!strcasecmp(param, "announce-position")) {
      if (!strcasecmp(val, "limit")) {
         q->announceposition = ANNOUNCEPOSITION_LIMIT;
      } else if (!strcasecmp(val, "more")) {
         q->announceposition = ANNOUNCEPOSITION_MORE_THAN;
      } else if (ast_true(val)) {
         q->announceposition = ANNOUNCEPOSITION_YES;
      } else {
         q->announceposition = ANNOUNCEPOSITION_NO;
      }
   } else if (!strcasecmp(param, "announce-position-only-up")) {
      q->announceposition_only_up = ast_true(val);
   } else if (!strcasecmp(param, "announce-position-limit")) {
      q->announcepositionlimit = atoi(val);
   } else if (!strcasecmp(param, "periodic-announce")) {
      if (strchr(val, ',')) {
         char *s, *buf = ast_strdupa(val);
         unsigned int i = 0;
 
         while ((s = strsep(&buf, ",|"))) {
            if (!q->sound_periodicannounce[i]) {
               q->sound_periodicannounce[i] = ast_str_create(16);
            }
            ast_str_set(&q->sound_periodicannounce[i], 0, "%s", s);
            i++;
            if (i == MAX_PERIODIC_ANNOUNCEMENTS) {
               break;
            }
         }
         q->numperiodicannounce = i;
      } else {
         ast_str_set(&q->sound_periodicannounce[0], 0, "%s", val);
         q->numperiodicannounce = 1;
      }
   } else if (!strcasecmp(param, "periodic-announce-frequency")) {
      q->periodicannouncefrequency = atoi(val);
   } else if (!strcasecmp(param, "relative-periodic-announce")) {
      q->relativeperiodicannounce = ast_true(val);
   } else if (!strcasecmp(param, "random-periodic-announce")) {
      q->randomperiodicannounce = ast_true(val);
   } else if (!strcasecmp(param, "retry")) {
      q->retry = atoi(val);
      if (q->retry <= 0) {
         q->retry = DEFAULT_RETRY;
      }
   } else if (!strcasecmp(param, "wrapuptime")) {
      q->wrapuptime = atoi(val);
   } else if (!strcasecmp(param, "penaltymemberslimit")) {
      if ((sscanf(val, "%10d", &q->penaltymemberslimit) != 1)) {
         q->penaltymemberslimit = 0;
      }
   } else if (!strcasecmp(param, "autofill")) {
      q->autofill = ast_true(val);
   } else if (!strcasecmp(param, "monitor-type")) {
      if (!strcasecmp(val, "mixmonitor")) {
         q->montype = 1;
      }
   } else if (!strcasecmp(param, "autopause")) {
      q->autopause = autopause2int(val);
   } else if (!strcasecmp(param, "autopausedelay")) {
      q->autopausedelay = atoi(val);
   } else if (!strcasecmp(param, "autopausebusy")) {
      q->autopausebusy = ast_true(val);
   } else if (!strcasecmp(param, "autopauseunavail")) {
      q->autopauseunavail = ast_true(val);
   } else if (!strcasecmp(param, "maxlen")) {
      q->maxlen = atoi(val);
      if (q->maxlen < 0) {
         q->maxlen = 0;
      }
   } else if (!strcasecmp(param, "servicelevel")) {
      q->servicelevel= atoi(val);
   } else if (!strcasecmp(param, "strategy")) {
      int strategy;
 
      /* We are a static queue and already have set this, no need to do it again */
      if (failunknown) {
         return;
      }
      strategy = strat2int(val);
      if (strategy < 0) {
         ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
            val, q->name);
         q->strategy = QUEUE_STRATEGY_RINGALL;
      }
      if (strategy == q->strategy) {
         return;
      }
      if (strategy == QUEUE_STRATEGY_LINEAR) {
         ast_log(LOG_WARNING, "Changing to the linear strategy currently requires asterisk to be restarted.\n");
         return;
      }
      q->strategy = strategy;
   } else if (!strcasecmp(param, "joinempty")) {
      parse_empty_options(val, &q->joinempty, 1);
   } else if (!strcasecmp(param, "leavewhenempty")) {
      parse_empty_options(val, &q->leavewhenempty, 0);
   } else if (!strcasecmp(param, "reportholdtime")) {
      q->reportholdtime = ast_true(val);
   } else if (!strcasecmp(param, "memberdelay")) {
      q->memberdelay = atoi(val);
   } else if (!strcasecmp(param, "weight")) {
      q->weight = atoi(val);
   } else if (!strcasecmp(param, "timeoutrestart")) {
      q->timeoutrestart = ast_true(val);
   } else if (!strcasecmp(param, "defaultrule")) {
      ast_string_field_set(q, defaultrule, val);
   } else if (!strcasecmp(param, "timeoutpriority")) {
      if (!strcasecmp(val, "conf")) {
         q->timeoutpriority = TIMEOUT_PRIORITY_CONF;
      } else {
         q->timeoutpriority = TIMEOUT_PRIORITY_APP;
      }
   } else if (failunknown) {
      if (linenum >= 0) {
         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s at line %d of queues.conf\n",
            q->name, param, linenum);
      } else {
         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s\n", q->name, param);
      }
   }
}
 
 
#define QUEUE_PAUSED_DEVSTATE AST_DEVICE_INUSE
#define QUEUE_UNPAUSED_DEVSTATE AST_DEVICE_NOT_INUSE
#define QUEUE_UNKNOWN_PAUSED_DEVSTATE AST_DEVICE_NOT_INUSE
 
/*! \internal
 * \brief If adding a single new member to a queue, use this function instead of ao2_linking.
 *        This adds round robin queue position data for a fresh member as well as links it.
 * \param queue Which queue the member is being added to
 * \param mem Which member is being added to the queue
 */
static void member_add_to_queue(struct call_queue *queue, struct member *mem)
{
   ao2_lock(queue->members);
   mem->queuepos = ao2_container_count(queue->members);
   ao2_link(queue->members, mem);
   ast_devstate_changed(mem->paused ? QUEUE_PAUSED_DEVSTATE : QUEUE_UNPAUSED_DEVSTATE,
      AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", queue->name, mem->interface);
   ao2_unlock(queue->members);
}
 
/*! \internal
 * \brief If removing a single member from a queue, use this function instead of ao2_unlinking.
 *        This will perform round robin queue position reordering for the remaining members.
 * \param queue Which queue the member is being removed from
 * \param mem Which member is being removed from the queue
 */
static void member_remove_from_queue(struct call_queue *queue, struct member *mem)
{
   pending_members_remove(mem);
   ao2_lock(queue->members);
   ast_devstate_changed(QUEUE_UNKNOWN_PAUSED_DEVSTATE, AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", queue->name, mem->interface);
   queue_member_follower_removal(queue, mem);
   ao2_unlink(queue->members, mem);
   ao2_unlock(queue->members);
}
 
/*!
 * \brief Find rt member record to update otherwise create one.
 *
 * Search for member in queue, if found update penalty/paused state,
 * if no member exists create one flag it as a RT member and add to queue member list.
*/
static void rt_handle_member_record(struct call_queue *q, char *category, struct ast_config *member_config)
{
   struct member *m;
   struct ao2_iterator mem_iter;
   int penalty = 0;
   int paused  = 0;
   int found = 0;
   int wrapuptime = 0;
   int ringinuse = q->ringinuse;
 
   const char *config_val;
   const char *interface = ast_variable_retrieve(member_config, category, "interface");
   const char *rt_uniqueid = ast_variable_retrieve(member_config, category, "uniqueid");
   const char *membername = S_OR(ast_variable_retrieve(member_config, category, "membername"), interface);
   const char *state_interface = S_OR(ast_variable_retrieve(member_config, category, "state_interface"), interface);
   const char *penalty_str = ast_variable_retrieve(member_config, category, "penalty");
   const char *paused_str = ast_variable_retrieve(member_config, category, "paused");
   const char *wrapuptime_str = ast_variable_retrieve(member_config, category, "wrapuptime");
 
   if (ast_strlen_zero(rt_uniqueid)) {
      ast_log(LOG_WARNING, "Realtime field 'uniqueid' is empty for member %s\n",
         S_OR(membername, "NULL"));
      return;
   }
 
   if (ast_strlen_zero(interface)) {
      ast_log(LOG_WARNING, "Realtime field 'interface' is empty for member %s\n",
         S_OR(membername, "NULL"));
      return;
   }
 
   if (penalty_str) {
      penalty = atoi(penalty_str);
      if ((penalty < 0) && negative_penalty_invalid) {
         return;
      } else if (penalty < 0) {
         penalty = 0;
      }
   }
 
   if (paused_str) {
      paused = atoi(paused_str);
      if (paused < 0) {
         paused = 0;
      }
   }
 
   if (wrapuptime_str) {
      wrapuptime = atoi(wrapuptime_str);
      if (wrapuptime < 0) {
         wrapuptime = 0;
      }
   }
 
   if ((config_val = ast_variable_retrieve(member_config, category, realtime_ringinuse_field))) {
      if (ast_true(config_val)) {
         ringinuse = 1;
      } else if (ast_false(config_val)) {
         ringinuse = 0;
      } else {
         ast_log(LOG_WARNING, "Invalid value of '%s' field for %s in queue '%s'\n", realtime_ringinuse_field, interface, q->name);
      }
   }
 
   /* Find member by realtime uniqueid and update */
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((m = ao2_iterator_next(&mem_iter))) {
      if (!strcasecmp(m->rt_uniqueid, rt_uniqueid)) {
         m->dead = 0;   /* Do not delete this one. */
         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
         if (paused_str) {
            m->paused = paused;
            if (paused && m->lastpause == 0) {
               time(&m->lastpause); /* XXX: Should this come from realtime? */
            }
            ast_devstate_changed(m->paused ? QUEUE_PAUSED_DEVSTATE : QUEUE_UNPAUSED_DEVSTATE,
               AST_DEVSTATE_CACHABLE, "Queue:%s_pause_%s", q->name, m->interface);
         }
         if (strcasecmp(state_interface, m->state_interface)) {
            ast_copy_string(m->state_interface, state_interface, sizeof(m->state_interface));
         }
         m->penalty = penalty;
         m->ringinuse = ringinuse;
         m->wrapuptime = wrapuptime;
         found = 1;
         ao2_ref(m, -1);
         break;
      }
      ao2_ref(m, -1);
   }
   ao2_iterator_destroy(&mem_iter);
 
   /* Create a new member */
   if (!found) {
      if ((m = create_queue_member(interface, membername, penalty, paused, state_interface, ringinuse, wrapuptime))) {
         m->dead = 0;
         m->realtime = 1;
         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
         if (!log_membername_as_agent) {
            ast_queue_log(q->name, "REALTIME", m->interface, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
         } else {
            ast_queue_log(q->name, "REALTIME", m->membername, "ADDMEMBER", "%s", paused ? "PAUSED" : "");
         }
         member_add_to_queue(q, m);
         ao2_ref(m, -1);
         m = NULL;
      }
   }
}
 
/*! \brief Iterate through queue's member list and delete them */
static void free_members(struct call_queue *q, int all)
{
   /* Free non-dynamic members */
   struct member *cur;
   struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
 
   while ((cur = ao2_iterator_next(&mem_iter))) {
      if (all || !cur->dynamic) {
         member_remove_from_queue(q, cur);
      }
      ao2_ref(cur, -1);
   }
   ao2_iterator_destroy(&mem_iter);
}
 
/*! \brief Free queue's member list then its string fields */
static void destroy_queue(void *obj)
{
   struct call_queue *q = obj;
   int i;
 
   free_members(q, 1);
   ast_string_field_free_memory(q);
   for (i = 0; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
      if (q->sound_periodicannounce[i]) {
         ast_free(q->sound_periodicannounce[i]);
      }
   }
   ao2_ref(q->members, -1);
}
 
static struct call_queue *alloc_queue(const char *queuename)
{
   struct call_queue *q;
 
   if ((q = ao2_t_alloc(sizeof(*q), destroy_queue, "Allocate queue"))) {
      if (ast_string_field_init(q, 64)) {
         queue_t_unref(q, "String field allocation failed");
         return NULL;
      }
      ast_string_field_set(q, name, queuename);
   }
   return q;
}
 
/*!
 * \brief Reload a single queue via realtime.
 *
 * Check for statically defined queue first, check if deleted RT queue,
 * check for new RT queue, if queue vars are not defined init them with defaults.
 * reload RT queue vars, set RT queue members dead and reload them, return finished queue.
 * \retval the queue,
 * \retval NULL if it doesn't exist.
 * \note Should be called with the "queues" container locked.
*/
static struct call_queue *find_queue_by_name_rt(const char *queuename, struct ast_variable *queue_vars, struct ast_config *member_config)
{
   struct ast_variable *v;
   struct call_queue *q, tmpq = {
      .name = queuename,
   };
   struct member *m;
   struct ao2_iterator mem_iter;
   char *category = NULL;
   const char *tmp_name;
   char *tmp;
   char tmpbuf[64];  /* Must be longer than the longest queue param name. */
 
   /* Static queues override realtime. */
   if ((q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Check if static queue exists"))) {
      ao2_lock(q);
      if (!q->realtime) {
         if (q->dead) {
            ao2_unlock(q);
            queue_t_unref(q, "Queue is dead; can't return it");
            return NULL;
         }
         ast_log(LOG_WARNING, "Static queue '%s' already exists. Not loading from realtime\n", q->name);
         ao2_unlock(q);
         return q;
      }
   } else if (!member_config) {
      /* Not found in the list, and it's not realtime ... */
      return NULL;
   }
   /* Check if queue is defined in realtime. */
   if (!queue_vars) {
      /* Delete queue from in-core list if it has been deleted in realtime. */
      if (q) {
         /*! \note Hmm, can't seem to distinguish a DB failure from a not
            found condition... So we might delete an in-core queue
            in case of DB failure. */
         ast_debug(1, "Queue %s not found in realtime.\n", queuename);
 
         q->dead = 1;
         /* Delete if unused (else will be deleted when last caller leaves). */
         queues_t_unlink(queues, q, "Unused; removing from container");
         ao2_unlock(q);
         queue_t_unref(q, "Queue is dead; can't return it");
      }
      return NULL;
   }
 
   /* Create a new queue if an in-core entry does not exist yet. */
   if (!q) {
      struct ast_variable *tmpvar = NULL;
      if (!(q = alloc_queue(queuename))) {
         return NULL;
      }
      ao2_lock(q);
      clear_queue(q);
      q->realtime = 1;
      /*Before we initialize the queue, we need to set the strategy, so that linear strategy
       * will allocate the members properly
       */
      for (tmpvar = queue_vars; tmpvar; tmpvar = tmpvar->next) {
         if (!strcasecmp(tmpvar->name, "strategy")) {
            q->strategy = strat2int(tmpvar->value);
            if (q->strategy < 0) {
               ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
               tmpvar->value, q->name);
               q->strategy = QUEUE_STRATEGY_RINGALL;
            }
            break;
         }
      }
      /* We traversed all variables and didn't find a strategy */
      if (!tmpvar) {
         q->strategy = QUEUE_STRATEGY_RINGALL;
      }
      queues_t_link(queues, q, "Add queue to container");
   }
   init_queue(q);    /* Ensure defaults for all parameters not set explicitly. */
 
   memset(tmpbuf, 0, sizeof(tmpbuf));
   for (v = queue_vars; v; v = v->next) {
      /* Convert to dashes `-' from underscores `_' as the latter are more SQL friendly. */
      if (strchr(v->name, '_')) {
         ast_copy_string(tmpbuf, v->name, sizeof(tmpbuf));
         tmp_name = tmpbuf;
         tmp = tmpbuf;
         while ((tmp = strchr(tmp, '_'))) {
            *tmp++ = '-';
         }
      } else {
         tmp_name = v->name;
      }
 
      /* NULL values don't get returned from realtime; blank values should
       * still get set.  If someone doesn't want a value to be set, they
       * should set the realtime column to NULL, not blank. */
      queue_set_param(q, tmp_name, v->value, -1, 0);
   }
 
   /* Temporarily set realtime members dead so we can detect deleted ones. */
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((m = ao2_iterator_next(&mem_iter))) {
      if (m->realtime) {
         m->dead = 1;
      }
      ao2_ref(m, -1);
   }
   ao2_iterator_destroy(&mem_iter);
 
   while ((category = ast_category_browse(member_config, category))) {
      rt_handle_member_record(q, category, member_config);
   }
 
   /* Delete all realtime members that have been deleted in DB. */
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((m = ao2_iterator_next(&mem_iter))) {
      if (m->dead) {
         if (ast_strlen_zero(m->membername) || !log_membername_as_agent) {
            ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
         } else {
            ast_queue_log(q->name, "REALTIME", m->membername, "REMOVEMEMBER", "%s", "");
         }
         member_remove_from_queue(q, m);
      }
      ao2_ref(m, -1);
   }
   ao2_iterator_destroy(&mem_iter);
 
   ao2_unlock(q);
 
   return q;
}
 
/*!
 * note  */
 
/*!
 * \internal
 * \brief Returns reference to the named queue. If the queue is realtime, it will load the queue as well.
 * \param queuename - name of the desired queue
 *
 * \retval the queue
 * \retval NULL if it doesn't exist
 */
static struct call_queue *find_load_queue_rt_friendly(const char *queuename)
{
   struct ast_variable *queue_vars;
   struct ast_config *member_config = NULL;
   struct call_queue *q = NULL, tmpq = {
      .name = queuename,
   };
   int prev_weight = 0;
 
   /* Find the queue in the in-core list first. */
   q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Look for queue in memory first");
 
   if (!q || q->realtime) {
      /*! \note Load from realtime before taking the "queues" container lock, to avoid blocking all
         queue operations while waiting for the DB.
 
         This will be two separate database transactions, so we might
         see queue parameters as they were before another process
         changed the queue and member list as it was after the change.
         Thus we might see an empty member list when a queue is
         deleted. In practise, this is unlikely to cause a problem. */
 
      queue_vars = ast_load_realtime("queues", "name", queuename, SENTINEL);
      if (queue_vars) {
         member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", queuename, SENTINEL);
         if (!member_config) {
            ast_debug(1, "No queue_members defined in config extconfig.conf\n");
            member_config = ast_config_new();
         }
      }
      if (q) {
         prev_weight = q->weight ? 1 : 0;
         queue_t_unref(q, "Need to find realtime queue");
      }
 
      q = find_queue_by_name_rt(queuename, queue_vars, member_config);
      ast_config_destroy(member_config);
      ast_variables_destroy(queue_vars);
 
      /* update the use_weight value if the queue's has gained or lost a weight */
      if (q) {
         if (!q->weight && prev_weight) {
            ast_atomic_fetchadd_int(&use_weight, -1);
         }
         if (q->weight && !prev_weight) {
            ast_atomic_fetchadd_int(&use_weight, +1);
         }
      }
      /* Other cases will end up with the proper value for use_weight */
   } else {
      update_realtime_members(q);
   }
   return q;
}
 
static int update_realtime_member_field(struct member *mem, const char *queue_name, const char *field, const char *value)
{
   int ret = -1;
 
   if (ast_strlen_zero(mem->rt_uniqueid)) {
      return ret;
   }
 
   if ((ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, field, value, SENTINEL)) > 0) {
      ret = 0;
   }
 
   return ret;
}
 
 
static void update_realtime_members(struct call_queue *q)
{
   struct ast_config *member_config = NULL;
   struct member *m;
   char *category = NULL;
   struct ao2_iterator mem_iter;
 
   if (!(member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", q->name , SENTINEL))) {
      /* This queue doesn't have realtime members. If the queue still has any realtime
       * members in memory, they need to be removed.
       */
      ao2_lock(q);
      mem_iter = ao2_iterator_init(q->members, 0);
      while ((m = ao2_iterator_next(&mem_iter))) {
         if (m->realtime) {
            member_remove_from_queue(q, m);
         }
         ao2_ref(m, -1);
      }
      ao2_iterator_destroy(&mem_iter);
      ast_debug(3, "Queue %s has no realtime members defined. No need for update\n", q->name);
      ao2_unlock(q);
      return;
   }
 
   ao2_lock(q);
 
   /* Temporarily set realtime  members dead so we can detect deleted ones.*/
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((m = ao2_iterator_next(&mem_iter))) {
      if (m->realtime) {
         m->dead = 1;
      }
      ao2_ref(m, -1);
   }
   ao2_iterator_destroy(&mem_iter);
 
   while ((category = ast_category_browse(member_config, category))) {
      rt_handle_member_record(q, category, member_config);
   }
 
   /* Delete all realtime members that have been deleted in DB. */
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((m = ao2_iterator_next(&mem_iter))) {
      if (m->dead) {
         if (ast_strlen_zero(m->membername) || !log_membername_as_agent) {
            ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
         } else {
            ast_queue_log(q->name, "REALTIME", m->membername, "REMOVEMEMBER", "%s", "");
         }
         member_remove_from_queue(q, m);
      }
      ao2_ref(m, -1);
   }
   ao2_iterator_destroy(&mem_iter);
   ao2_unlock(q);
   ast_config_destroy(member_config);
}
 
static int join_queue(char *queuename, struct queue_ent *qe, enum queue_result *reason, int position)
{
   struct call_queue *q;
   struct queue_ent *cur, *prev = NULL;
   int res = -1;
   int pos = 0;
   int inserted = 0;
 
   if (!(q = find_load_queue_rt_friendly(queuename))) {
      return res;
   }
   ao2_lock(q);
 
   /* This is our one */
   if (q->joinempty) {
      int status = 0;
      if ((status = get_member_status(q, qe->max_penalty, qe->min_penalty, qe->raise_penalty, q->joinempty, 0))) {
         *reason = QUEUE_JOINEMPTY;
         ao2_unlock(q);
         queue_t_unref(q, "Done with realtime queue");
         return res;
      }
   }
   if (*reason == QUEUE_UNKNOWN && q->maxlen && (q->count >= q->maxlen)) {
      *reason = QUEUE_FULL;
   } else if (*reason == QUEUE_UNKNOWN) {
      RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
      /* There's space for us, put us at the right position inside
       * the queue.
       * Take into account the priority of the calling user */
      inserted = 0;
      prev = NULL;
      cur = q->head;
      while (cur) {
         /* We have higher priority than the current user, enter
          * before him, after all the other users with priority
          * higher or equal to our priority. */
         if ((!inserted) && (qe->prio > cur->prio)) {
            insert_entry(q, prev, qe, &pos);
            inserted = 1;
         }
         /* <= is necessary for the position comparison because it may not be possible to enter
          * at our desired position since higher-priority callers may have taken the position we want
          */
         if (!inserted && (qe->prio >= cur->prio) && position && (position <= pos + 1)) {
            insert_entry(q, prev, qe, &pos);
            inserted = 1;
            /*pos is incremented inside insert_entry, so don't need to add 1 here*/
            if (position < pos) {
               ast_log(LOG_NOTICE, "Asked to be inserted at position %d but forced into position %d due to higher priority callers\n", position, pos);
            }
         }
         cur->pos = ++pos;
         prev = cur;
         cur = cur->next;
      }
      /* No luck, join at the end of the queue */
      if (!inserted) {
         insert_entry(q, prev, qe, &pos);
      }
      ast_copy_string(qe->moh, q->moh, sizeof(qe->moh));
      ast_copy_string(qe->announce, q->announce, sizeof(qe->announce));
      ast_copy_string(qe->context, q->context, sizeof(qe->context));
      q->count++;
      if (q->count == 1) {
         ast_devstate_changed(AST_DEVICE_RINGING, AST_DEVSTATE_CACHABLE, "Queue:%s", q->name);
      }
 
      res = 0;
 
      blob = ast_json_pack("{s: s, s: i, s: i}",
                 "Queue", q->name,
                 "Position", qe->pos,
                 "Count", q->count);
      ast_channel_publish_cached_blob(qe->chan, queue_caller_join_type(), blob);
      ast_debug(1, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, ast_channel_name(qe->chan), qe->pos );
   }
   ao2_unlock(q);
   queue_t_unref(q, "Done with realtime queue");
 
   return res;
}
 
static int play_file(struct ast_channel *chan, const char *filename)
{
   int res;
 
   if (ast_strlen_zero(filename)) {
      return 0;
   }
 
   if (!ast_fileexists(filename, NULL, ast_channel_language(chan))) {
      return 0;
   }
 
   ast_stopstream(chan);
 
   res = ast_streamfile(chan, filename, ast_channel_language(chan));
   if (!res) {
      res = ast_waitstream(chan, AST_DIGIT_ANY);
   }
 
   ast_stopstream(chan);
 
   return res;
}
 
/*!
 * \brief Check for valid exit from queue via goto
 * \retval 0 if failure
 * \retval 1 if successful
*/
static int valid_exit(struct queue_ent *qe, char digit)
{
   int digitlen = strlen(qe->digits);
 
   /* Prevent possible buffer overflow */
   if (digitlen < sizeof(qe->digits) - 2) {
      qe->digits[digitlen] = digit;
      qe->digits[digitlen + 1] = '\0';
   } else {
      qe->digits[0] = '\0';
      return 0;
   }
 
   /* If there's no context to goto, short-circuit */
   if (ast_strlen_zero(qe->context)) {
      return 0;
   }
 
   /* If the extension is bad, then reset the digits to blank */
   if (!ast_canmatch_extension(qe->chan, qe->context, qe->digits, 1,
      S_COR(ast_channel_caller(qe->chan)->id.number.valid, ast_channel_caller(qe->chan)->id.number.str, NULL))) {
      qe->digits[0] = '\0';
      return 0;
   }
 
   /* We have an exact match */
   if (!ast_goto_if_exists(qe->chan, qe->context, qe->digits, 1)) {
      qe->valid_digits = 1;
      /* Return 1 on a successful goto */
      return 1;
   }
 
   return 0;
}
 
static int say_position(struct queue_ent *qe, int ringing)
{
   int res = 0, announceposition = 0;
   long avgholdmins, avgholdsecs;
   int say_thanks = 1;
   time_t now;
 
   /* Let minannouncefrequency seconds pass between the start of each position announcement */
   time(&now);
   if ((now - qe->last_pos) < qe->parent->minannouncefrequency) {
      return 0;
   }
 
   /* If either our position has changed, or we are over the freq timer, say position */
   if ((qe->last_pos_said == qe->pos) && ((now - qe->last_pos) < qe->parent->announcefrequency)) {
      return 0;
   }
 
   /* Only announce if the caller's queue position has improved since last time */
   if (qe->parent->announceposition_only_up && qe->last_pos_said <= qe->pos) {
      return 0;
   }
 
   if (ringing) {
      ast_indicate(qe->chan,-1);
   } else {
      ast_moh_stop(qe->chan);
   }
 
   if (qe->parent->announceposition == ANNOUNCEPOSITION_YES ||
      qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN ||
      (qe->parent->announceposition == ANNOUNCEPOSITION_LIMIT &&
      qe->pos <= qe->parent->announcepositionlimit)) {
         announceposition = 1;
   }
 
 
   if (announceposition == 1) {
      /* Say we're next, if we are */
      if (qe->pos == 1) {
         res = play_file(qe->chan, qe->parent->sound_next);
         if (!res) {
            goto posout;
         }
      /* Say there are more than N callers */
      } else if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit) {
         res = (
            play_file(qe->chan, qe->parent->queue_quantity1) ||
            ast_say_number(qe->chan, qe->parent->announcepositionlimit, AST_DIGIT_ANY,
                  ast_channel_language(qe->chan), NULL) || /* Needs gender */
            play_file(qe->chan, qe->parent->queue_quantity2));
      /* Say there are currently N callers waiting */
      } else {
         res = (
            play_file(qe->chan, qe->parent->sound_thereare) ||
            ast_say_number(qe->chan, qe->pos, AST_DIGIT_ANY,
                  ast_channel_language(qe->chan), NULL) || /* Needs gender */
            play_file(qe->chan, qe->parent->sound_calls));
      }
      if (res) {
         goto playout;
      }
   }
   /* Round hold time to nearest minute */
   avgholdmins = labs(((qe->parent->holdtime + 30) - (now - qe->start)) / 60);
 
   /* If they have specified a rounding then round the seconds as well */
   if (qe->parent->roundingseconds) {
      avgholdsecs = (labs(((qe->parent->holdtime + 30) - (now - qe->start))) - 60 * avgholdmins) / qe->parent->roundingseconds;
      avgholdsecs *= qe->parent->roundingseconds;
   } else {
      avgholdsecs = 0;
   }
 
   ast_verb(3, "Hold time for %s is %ld minute(s) %ld seconds\n", qe->parent->name, avgholdmins, avgholdsecs);
 
   /* If the hold time is >1 min, if it's enabled, and if it's not
      supposed to be only once and we have already said it, say it */
   if ((avgholdmins+avgholdsecs) > 0 && qe->parent->announceholdtime &&
      ((qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE && !qe->last_pos) ||
      !(qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE))) {
      res = play_file(qe->chan, qe->parent->sound_holdtime);
      if (res) {
         goto playout;
      }
 
      if (avgholdmins >= 1) {
         res = ast_say_number(qe->chan, avgholdmins, AST_DIGIT_ANY, ast_channel_language(qe->chan), NULL);
         if (res) {
            goto playout;
         }
 
         if (avgholdmins == 1) {
            res = play_file(qe->chan, qe->parent->sound_minute);
            if (res) {
               goto playout;
            }
         } else {
            res = play_file(qe->chan, qe->parent->sound_minutes);
            if (res) {
               goto playout;
            }
         }
      }
      if (avgholdsecs >= 1) {
         res = ast_say_number(qe->chan, avgholdsecs, AST_DIGIT_ANY, ast_channel_language(qe->chan), NULL);
         if (res) {
            goto playout;
         }
 
         res = play_file(qe->chan, qe->parent->sound_seconds);
         if (res) {
            goto playout;
         }
      }
   } else if (qe->parent->announceholdtime && !qe->parent->announceposition) {
      say_thanks = 0;
   }
 
posout:
   if (qe->parent->announceposition) {
      ast_verb(3, "Told %s in %s their queue position (which was %d)\n",
         ast_channel_name(qe->chan), qe->parent->name, qe->pos);
   }
   if (say_thanks) {
      res = play_file(qe->chan, qe->parent->sound_thanks);
   }
playout:
 
   if ((res > 0 && !valid_exit(qe, res))) {
      res = 0;
   }
 
   /* Set our last_pos indicators */
   qe->last_pos = now;
   qe->last_pos_said = qe->pos;
 
   /* Don't restart music on hold if we're about to exit the caller from the queue */
   if (!res) {
      if (ringing) {
         ast_indicate(qe->chan, AST_CONTROL_RINGING);
      } else {
         ast_moh_start(qe->chan, qe->moh, NULL);
      }
   }
   return res;
}
 
static void recalc_holdtime(struct queue_ent *qe, int newholdtime)
{
   int oldvalue;
 
   /* Calculate holdtime using an exponential average */
   /* Thanks to SRT for this contribution */
   /* 2^2 (4) is the filter coefficient; a higher exponent would give old entries more weight */
 
   ao2_lock(qe->parent);
   if ((qe->parent->callscompleted + qe->parent->callsabandoned) == 0) {
      qe->parent->holdtime = newholdtime;
   } else {
      oldvalue = qe->parent->holdtime;
      qe->parent->holdtime = (((oldvalue << 2) - oldvalue) + newholdtime) >> 2;
   }
   ao2_unlock(qe->parent);
}
 
/*! \brief Caller leaving queue.
 *
 * Search the queue to find the leaving client, if found remove from queue
 * create manager event, move others up the queue.
*/
static void leave_queue(struct queue_ent *qe)
{
   struct call_queue *q;
   struct queue_ent *current, *prev = NULL;
   struct penalty_rule *pr_iter;
   int pos = 0;
 
   if (!(q = qe->parent)) {
      return;
   }
   queue_t_ref(q, "Copy queue pointer from queue entry");
   ao2_lock(q);
 
   prev = NULL;
   for (current = q->head; current; current = current->next) {
      if (current == qe) {
         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
         char posstr[20];
         q->count--;
         if (!q->count) {
            ast_devstate_changed(AST_DEVICE_NOT_INUSE, AST_DEVSTATE_CACHABLE, "Queue:%s", q->name);
         }
 
         blob = ast_json_pack("{s: s, s: i, s: i}",
                    "Queue", q->name,
                    "Position", qe->pos,
                    "Count", q->count);
         ast_channel_publish_cached_blob(qe->chan, queue_caller_leave_type(), blob);
         ast_debug(1, "Queue '%s' Leave, Channel '%s'\n", q->name, ast_channel_name(qe->chan));
         /* Take us out of the queue */
         if (prev) {
            prev->next = current->next;
         } else {
            q->head = current->next;
         }
         /* Free penalty rules */
         while ((pr_iter = AST_LIST_REMOVE_HEAD(&qe->qe_rules, list))) {
            ast_free(pr_iter);
         }
         qe->pr = NULL;
         snprintf(posstr, sizeof(posstr), "%d", qe->pos);
         pbx_builtin_setvar_helper(qe->chan, "QUEUEPOSITION", posstr);
      } else {
         /* Renumber the people after us in the queue based on a new count */
         current->pos = ++pos;
         prev = current;
      }
   }
   ao2_unlock(q);
 
   /*If the queue is a realtime queue, check to see if it's still defined in real time*/
   if (q->realtime) {
      struct ast_variable *var;
      if (!(var = ast_load_realtime("queues", "name", q->name, SENTINEL))) {
         q->dead = 1;
      } else {
         ast_variables_destroy(var);
      }
   }
 
   if (q->dead) {
      /* It's dead and nobody is in it, so kill it */
      queues_t_unlink(queues, q, "Queue is now dead; remove it from the container");
   }
   /* unref the explicit ref earlier in the function */
   queue_t_unref(q, "Expire copied reference");
}
 
/*!
 * \internal
 * \brief Destroy the given callattempt structure and free it.
 * \since 1.8
 *
 * \param doomed callattempt structure to destroy.
 */
static void callattempt_free(struct callattempt *doomed)
{
   if (doomed->member) {
      ao2_ref(doomed->member, -1);
   }
   ast_party_connected_line_free(&doomed->connected);
   ast_free(doomed->orig_chan_name);
   ast_free(doomed);
}
 
static void publish_dial_end_event(struct ast_channel *in, struct callattempt *outgoing, struct ast_channel *exception, const char *status)
{
   struct callattempt *cur;
 
   for (cur = outgoing; cur; cur = cur->q_next) {
      if (cur->chan && cur->chan != exception) {
         ast_channel_publish_dial(in, cur->chan, NULL, status);
      }
   }
}
 
/*! \brief Hang up a list of outgoing calls */
static void hangupcalls(struct queue_ent *qe, struct callattempt *outgoing, struct ast_channel *exception, int cancel_answered_elsewhere)
{
   struct callattempt *oo;
 
   while (outgoing) {
      /* If someone else answered the call we should indicate this in the CANCEL */
      /* Hangup any existing lines we have open */
      if (outgoing->chan && (outgoing->chan != exception)) {
         if (exception || cancel_answered_elsewhere) {
            ast_channel_hangupcause_set(outgoing->chan, AST_CAUSE_ANSWERED_ELSEWHERE);
         }
         ast_channel_publish_dial(qe->chan, outgoing->chan, outgoing->interface, "CANCEL");
 
         /* When dialing channels it is possible that they may not ever
          * leave the not in use state (Local channels in particular) by
          * the time we cancel them. If this occurs but we know they were
          * dialed we explicitly remove them from the pending members
          * container so that subsequent call attempts occur.
          */
         if (outgoing->member->status == AST_DEVICE_NOT_INUSE) {
            pending_members_remove(outgoing->member);
         }
 
         ast_hangup(outgoing->chan);
      }
      oo = outgoing;
      outgoing = outgoing->q_next;
      ast_aoc_destroy_decoded(oo->aoc_s_rate_list);
      callattempt_free(oo);
   }
}
 
/*!
 * \brief Get the number of members available to accept a call.
 *
 * \note The queue passed in should be locked prior to this function call
 *
 * \param[in] q The queue for which we are counting the number of available members
 * \return Return the number of available members in queue q
 */
static int num_available_members(struct call_queue *q)
{
   struct member *mem;
   int avl = 0;
   struct ao2_iterator mem_iter;
 
   mem_iter = ao2_iterator_init(q->members, 0);
   while ((mem = ao2_iterator_next(&mem_iter))) {
 
      avl += is_member_available(q, mem);
      ao2_ref(mem, -1);
 
      /* If autofill is not enabled or if the queue's strategy is ringall, then
       * we really don't care about the number of available members so much as we
       * do that there is at least one available.
       *
       * In fact, we purposely will return from this function stating that only
       * one member is available if either of those conditions hold. That way,
       * functions which determine what action to take based on the number of available
       * members will operate properly. The reasoning is that even if multiple
       * members are available, only the head caller can actually be serviced.
       */
      if ((!q->autofill || q->strategy == QUEUE_STRATEGY_RINGALL) && avl) {
         break;
      }
   }
   ao2_iterator_destroy(&mem_iter);
 
   return avl;
}
 
/* traverse all defined queues which have calls waiting and contain this member
   return 0 if no other queue has precedence (higher weight) or 1 if found  */
static int compare_weight(struct call_queue *rq, struct member *member)
{
   struct call_queue *q;
   struct member *mem;
   int found = 0;
   struct ao2_iterator queue_iter;
 
   queue_iter = ao2_iterator_init(queues, 0);
   while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
      if (q == rq) { /* don't check myself, could deadlock */
         queue_t_unref(q, "Done with iterator");
         continue;
      }
      ao2_lock(q);
      if (q->count && q->members) {
         if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
            ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
            if (q->weight > rq->weight && q->count >= num_available_members(q)) {
               ast_debug(1, "Queue '%s' (weight %d, calls %d) is preferred over '%s' (weight %d, calls %d)\n", q->name, q->weight, q->count, rq->name, rq->weight, rq->count);
               found = 1;
            }
            ao2_ref(mem, -1);
         }
      }
      ao2_unlock(q);
      queue_t_unref(q, "Done with iterator");
      if (found) {
         break;
      }
   }
   ao2_iterator_destroy(&queue_iter);
   return found;
}
 
/*! \brief common hangup actions */
static void do_hang(struct callattempt *o)
{
   o->stillgoing = 0;
   ast_hangup(o->chan);
   pending_members_remove(o->member);
   o->chan = NULL;
}
 
/*!
 * \internal
 * \brief Check if the member status is available.
 *
 * \param status Member status to check if available.
 *
 * \retval non-zero if the member status is available.
 */
static int member_status_available(int status)
{
   return status == AST_DEVICE_NOT_INUSE || status == AST_DEVICE_UNKNOWN;
}
 
/*!
 * \internal
 * \brief Determine if can ring a queue entry.
 *
 * \param qe Queue entry to check.
 * \param call Member call attempt.
 *
 * \retval non-zero if an entry can be called.
 */
static int can_ring_entry(struct queue_ent *qe, struct callattempt *call)
{
   struct member *memberp = call->member;
   int wrapuptime;
 
   if (memberp->paused) {
      ast_debug(1, "%s paused, can't receive call\n", call->interface);
      return 0;
   }
 
   if (!memberp->ringinuse && !member_status_available(memberp->status)) {
      ast_debug(1, "%s not available, can't receive call\n", call->interface);
      return 0;
   }
 
   if (memberp->lastqueue) {
      wrapuptime = get_wrapuptime(memberp->lastqueue, memberp);
   } else {
      wrapuptime = get_wrapuptime(qe->parent, memberp);
   }
   if (wrapuptime && (time(NULL) - memberp->lastcall) < wrapuptime) {
      ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n",
         (memberp->lastqueue ? memberp->lastqueue->name : qe->parent->name),
         call->interface);
      return 0;
   }
 
   if (use_weight && compare_weight(qe->parent, memberp)) {
      ast_debug(1, "Priority queue delaying call to %s:%s\n",
         qe->parent->name, call->interface);
      return 0;
   }
 
   if (!memberp->ringinuse) {
      struct member *mem;
 
      ao2_lock(pending_members);
 
      mem = ao2_find(pending_members, memberp,
              OBJ_SEARCH_OBJECT | OBJ_NOLOCK);
      if (mem) {
         /*
          * If found that means this member is currently being attempted
          * from another calling thread, so stop trying from this thread
          */
         ast_debug(1, "%s has another call trying, can't receive call\n",
              call->interface);
         ao2_ref(mem, -1);
         ao2_unlock(pending_members);
         return 0;
      }
 
      /*
       * If not found add it to the container so another queue
       * won't attempt to call this member at the same time.
       */
      ast_debug(3, "Add %s to pending_members\n", memberp->membername);
      ao2_link(pending_members, memberp);
      ao2_unlock(pending_members);
 
      /*
       * The queue member is available.  Get current status to be sure
       * because the device state and extension state callbacks may
       * not have updated the status yet.
       */
      if (!member_status_available(get_queue_member_status(memberp))) {
         ast_debug(1, "%s actually not available, can't receive call\n",
            call->interface);
         pending_members_remove(memberp);
         return 0;
      }
   }
 
   return 1;
}
 
/*!
 * \brief Part 2 of ring_one
 *
 * Does error checking before attempting to request a channel and call a member.
 * This function is only called from ring_one().
 * Failure can occur if:
 * - Agent on call
 * - Agent is paused
 * - Wrapup time not expired
 * - Priority by another queue
 *
 * \retval 1 on success to reach a free agent
 * \retval 0 on failure to get agent.
 */
static int ring_entry(struct queue_ent *qe, struct callattempt *tmp, int *busies)
{
   int res;
   int status;
   char tech[256];
   char *location;
   const char *macrocontext, *macroexten;
   struct ast_format_cap *nativeformats;
   RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
 
   /* on entry here, we know that tmp->chan == NULL */
   if (!can_ring_entry(qe, tmp)) {
      tmp->stillgoing = 0;
      ++*busies;
      return 0;
   }
 
   ast_copy_string(tech, tmp->interface, sizeof(tech));
   if ((location = strchr(tech, '/'))) {
      *location++ = '\0';
   } else {
      location = "";
   }
 
   ast_channel_lock(qe->chan);
   nativeformats = ao2_bump(ast_channel_nativeformats(qe->chan));
   ast_channel_unlock(qe->chan);
 
   /* Request the peer */
   tmp->chan = ast_request(tech, nativeformats, NULL, qe->chan, location, &status);
   ao2_cleanup(nativeformats);
   if (!tmp->chan) {       /* If we can't, just go on to the next call */
      ao2_lock(qe->parent);
      qe->parent->rrpos++;
      qe->linpos++;
      ao2_unlock(qe->parent);
 
      pending_members_remove(tmp->member);
 
      publish_dial_end_event(qe->chan, tmp, NULL, "BUSY");
      tmp->stillgoing = 0;
      ++*busies;
      return 0;
   }
 
   ast_channel_lock_both(tmp->chan, qe->chan);
 
   ast_channel_req_accountcodes_precious(tmp->chan, qe->chan,
      AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
   if (qe->cancel_answered_elsewhere) {
      ast_channel_hangupcause_set(tmp->chan, AST_CAUSE_ANSWERED_ELSEWHERE);
   }
   ast_channel_appl_set(tmp->chan, "AppQueue");
   ast_channel_data_set(tmp->chan, "(Outgoing Line)");
   memset(ast_channel_whentohangup(tmp->chan), 0, sizeof(*ast_channel_whentohangup(tmp->chan)));
 
   /* If the new channel has no callerid, try to guess what it should be */
   if (!ast_channel_caller(tmp->chan)->id.number.valid) {
      if (ast_channel_connected(qe->chan)->id.number.valid) {
         struct ast_party_caller caller;
 
         ast_party_caller_set_init(&caller, ast_channel_caller(tmp->chan));
         caller.id = ast_channel_connected(qe->chan)->id;
         caller.ani = ast_channel_connected(qe->chan)->ani;
         ast_channel_set_caller_event(tmp->chan, &caller, NULL);
      } else if (!ast_strlen_zero(ast_channel_dialed(qe->chan)->number.str)) {
         ast_set_callerid(tmp->chan, ast_channel_dialed(qe->chan)->number.str, NULL, NULL);
      } else if (!ast_strlen_zero(S_OR(ast_channel_macroexten(qe->chan), ast_channel_exten(qe->chan)))) {
         ast_set_callerid(tmp->chan, S_OR(ast_channel_macroexten(qe->chan), ast_channel_exten(qe->chan)), NULL, NULL);
      }
      tmp->dial_callerid_absent = 1;
   }
 
   ast_party_redirecting_copy(ast_channel_redirecting(tmp->chan), ast_channel_redirecting(qe->chan));
 
   ast_channel_dialed(tmp->chan)->transit_network_select = ast_channel_dialed(qe->chan)->transit_network_select;
 
   ast_connected_line_copy_from_caller(ast_channel_connected(tmp->chan), ast_channel_caller(qe->chan));
 
   /* Inherit specially named variables from parent channel */
   ast_channel_inherit_variables(qe->chan, tmp->chan);
   ast_channel_datastore_inherit(qe->chan, tmp->chan);
   ast_max_forwards_decrement(tmp->chan);
 
   /* Presense of ADSI CPE on outgoing channel follows ours */
   ast_channel_adsicpe_set(tmp->chan, ast_channel_adsicpe(qe->chan));
 
   /* Inherit context and extension */
   macrocontext = pbx_builtin_getvar_helper(qe->chan, "MACRO_CONTEXT");
   ast_channel_dialcontext_set(tmp->chan, ast_strlen_zero(macrocontext) ? ast_channel_context(qe->chan) : macrocontext);
   macroexten = pbx_builtin_getvar_helper(qe->chan, "MACRO_EXTEN");
   if (!ast_strlen_zero(macroexten)) {
      ast_channel_exten_set(tmp->chan, macroexten);
   } else {
      ast_channel_exten_set(tmp->chan, ast_channel_exten(qe->chan));
   }
 
   /* Save the original channel name to detect call pickup masquerading in. */
   tmp->orig_chan_name = ast_strdup(ast_channel_name(tmp->chan));
 
   ast_channel_unlock(tmp->chan);
   ast_channel_unlock(qe->chan);
 
   /* PREDIAL: Run gosub on the callee's channel */
   if (qe->predial_callee) {
      ast_pre_call(tmp->chan, qe->predial_callee);
   }
 
   /* Place the call, but don't wait on the answer */
   if ((res = ast_call(tmp->chan, location, 0))) {
      /* Again, keep going even if there's an error */
      ast_verb(3, "Couldn't call %s\n", tmp->interface);
      do_hang(tmp);
      ++*busies;
      return 0;
   }
 
   ast_channel_lock_both(tmp->chan, qe->chan);
 
   blob = ast_json_pack("{s: s, s: s, s: s}",
              "Queue", qe->parent->name,
              "Interface", tmp->interface,
              "MemberName", tmp->member->membername);
   queue_publish_multi_channel_blob(qe->chan, tmp->chan, queue_agent_called_type(), blob);
 
   ast_channel_publish_dial(qe->chan, tmp->chan, tmp->interface, NULL);
 
   ast_channel_unlock(tmp->chan);
   ast_channel_unlock(qe->chan);
 
   ast_verb(3, "Called %s\n", tmp->interface);
 
   return 1;
}
 
/*! \brief find the entry with the best metric, or NULL */
static struct callattempt *find_best(struct callattempt *outgoing)
{
   struct callattempt *best = NULL, *cur;
 
   for (cur = outgoing; cur; cur = cur->q_next) {
      if (cur->stillgoing &&              /* Not already done */
         !cur->chan &&              /* Isn't already going */
         (!best || cur->metric < best->metric)) {     /* We haven't found one yet, or it's better */
         best = cur;
      }
   }
 
   return best;
}
 
/*!
 * \brief Place a call to a queue member.
 *
 * Once metrics have been calculated for each member, this function is used
 * to place a call to the appropriate member (or members). The low-level
 * channel-handling and error detection is handled in ring_entry
 *
 * \retval 1 if a member was called successfully
 * \retval 0 otherwise
 */
static int ring_one(struct queue_ent *qe, struct callattempt *outgoing, int *busies)
{
   int ret = 0;
   struct callattempt *cur;
 
   if (qe->predial_callee) {
      ast_autoservice_start(qe->chan);
      for (cur = outgoing; cur; cur = cur->q_next) {
         if (cur->stillgoing && cur->chan) {
            ast_autoservice_start(cur->chan);
         }
      }
   }
 
   while (ret == 0) {
      struct callattempt *best = find_best(outgoing);
      if (!best) {
         ast_debug(1, "Nobody left to try ringing in queue\n");
         break;
      }
      if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
         /* Ring everyone who shares this best metric (for ringall) */
         for (cur = outgoing; cur; cur = cur->q_next) {
            if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
               ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
               ret |= ring_entry(qe, cur, busies);
               if (qe->predial_callee && cur->chan) {
                  ast_autoservice_start(cur->chan);
               }
            }
         }
      } else {
         /* Ring just the best channel */
         ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
         ret = ring_entry(qe, best, busies);
         if (qe->predial_callee && best->chan) {
            ast_autoservice_start(best->chan);
         }
      }
 
      /* If we have timed out, break out */
      if (qe->expire && (time(NULL) >= qe->expire)) {
         ast_debug(1, "Queue timed out while ringing members.\n");
         ret = 0;
         break;
      }
   }
   if (qe->predial_callee) {
      for (cur = outgoing; cur; cur = cur->q_next) {
         if (cur->stillgoing && cur->chan) {
            ast_autoservice_stop(cur->chan);
         }
      }
      ast_autoservice_stop(qe->chan);
   }
 
   return ret;
}
 
/*! \brief Search for best metric and add to Round Robbin queue */
static int store_next_rr(struct queue_ent *qe, struct callattempt *outgoing)
{
   struct callattempt *best = find_best(outgoing);
 
   if (best) {
      /* Ring just the best channel */
      ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
      qe->parent->rrpos = best->metric % 1000;
   } else {
      /* Just increment rrpos */
      if (qe->parent->wrapped) {
         /* No more channels, start over */
         qe->parent->rrpos = 0;
      } else {
         /* Prioritize next entry */
         qe->parent->rrpos++;
      }
   }
   qe->parent->wrapped = 0;
 
   return 0;
}
 
/*! \brief Search for best metric and add to Linear queue */
static int store_next_lin(struct queue_ent *qe, struct callattempt *outgoing)
{
   struct callattempt *best = find_best(outgoing);
 
   if (best) {
      /* Ring just the best channel */
      ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
      qe->linpos = best->metric % 1000;
   } else {
      /* Just increment rrpos */
      if (qe->linwrapped) {
         /* No more channels, start over */
         qe->linpos = 0;
      } else {
         /* Prioritize next entry */
         qe->linpos++;
      }
   }
   qe->linwrapped = 0;
 
   return 0;
}
 
/*! \brief Playback announcement to queued members if period has elapsed */
static int say_periodic_announcement(struct queue_ent *qe, int ringing)
{
   int res = 0;
   time_t now;
 
   /* Get the current time */
   time(&now);
 
   /* Check to see if it is time to announce */
   if ((now - qe->last_periodic_announce_time) < qe->parent->periodicannouncefrequency) {