75cec83b22200ba745b6caf58c68a760b80aff77
[asterisk/asterisk.git] / apps / app_queue.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief True call queues with optional send URL on answer
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \arg Config in \ref Config_qu queues.conf
26  *
27  * \par Development notes
28  * \note 2004-11-25: Persistent Dynamic Members added by:
29  *             NetNation Communications (www.netnation.com)
30  *             Kevin Lindsay <kevinl@netnation.com>
31  *
32  *             Each dynamic agent in each queue is now stored in the astdb.
33  *             When asterisk is restarted, each agent will be automatically
34  *             readded into their recorded queues. This feature can be
35  *             configured with the 'persistent_members=<1|0>' setting in the
36  *             '[general]' category in queues.conf. The default is on.
37  *
38  * \note 2004-06-04: Priorities in queues added by inAccess Networks (work funded by Hellas On Line (HOL) www.hol.gr).
39  *
40  * \note These features added by David C. Troy <dave@toad.net>:
41  *    - Per-queue holdtime calculation
42  *    - Estimated holdtime announcement
43  *    - Position announcement
44  *    - Abandoned/completed call counters
45  *    - Failout timer passed as optional app parameter
46  *    - Optional monitoring of calls, started when call is answered
47  *
48  * Patch Version 1.07 2003-12-24 01
49  *
50  * Added servicelevel statistic by Michiel Betel <michiel@betel.nl>
51  * Added Priority jumping code for adding and removing queue members by Jonathan Stanton <asterisk@doilooklikeicare.com>
52  *
53  * Fixed to work with CVS as of 2004-02-25 and released as 1.07a
54  * by Matthew Enger <m.enger@xi.com.au>
55  *
56  * \ingroup applications
57  */
58
59 /*** MODULEINFO
60         <use type="module">res_monitor</use>
61         <support_level>core</support_level>
62  ***/
63
64 #include "asterisk.h"
65
66 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
67
68 #include <sys/time.h>
69 #include <sys/signal.h>
70 #include <netinet/in.h>
71 #include <ctype.h>
72
73 #include "asterisk/lock.h"
74 #include "asterisk/file.h"
75 #include "asterisk/channel.h"
76 #include "asterisk/pbx.h"
77 #include "asterisk/app.h"
78 #include "asterisk/linkedlists.h"
79 #include "asterisk/module.h"
80 #include "asterisk/translate.h"
81 #include "asterisk/say.h"
82 #include "asterisk/features.h"
83 #include "asterisk/musiconhold.h"
84 #include "asterisk/cli.h"
85 #include "asterisk/manager.h"
86 #include "asterisk/config.h"
87 #include "asterisk/monitor.h"
88 #include "asterisk/utils.h"
89 #include "asterisk/causes.h"
90 #include "asterisk/astdb.h"
91 #include "asterisk/devicestate.h"
92 #include "asterisk/stringfields.h"
93 #include "asterisk/event.h"
94 #include "asterisk/astobj2.h"
95 #include "asterisk/strings.h"
96 #include "asterisk/global_datastores.h"
97 #include "asterisk/taskprocessor.h"
98 #include "asterisk/aoc.h"
99 #include "asterisk/callerid.h"
100 #include "asterisk/cel.h"
101 #include "asterisk/data.h"
102
103 /* Define, to debug reference counts on queues, without debugging reference counts on queue members */
104 /* #define REF_DEBUG_ONLY_QUEUES */
105
106 /*!
107  * \par Please read before modifying this file.
108  * There are three locks which are regularly used
109  * throughout this file, the queue list lock, the lock
110  * for each individual queue, and the interface list lock.
111  * Please be extra careful to always lock in the following order
112  * 1) queue list lock
113  * 2) individual queue lock
114  * 3) interface list lock
115  * This order has sort of "evolved" over the lifetime of this
116  * application, but it is now in place this way, so please adhere
117  * to this order!
118  */
119
120 /*** DOCUMENTATION
121         <application name="Queue" language="en_US">
122                 <synopsis>
123                         Queue a call for a call queue.
124                 </synopsis>
125                 <syntax>
126                         <parameter name="queuename" required="true" />
127                         <parameter name="options">
128                                 <optionlist>
129                                         <option name="C">
130                                                 <para>Mark all calls as "answered elsewhere" when cancelled.</para>
131                                         </option>
132                                         <option name="c">
133                                                 <para>Continue in the dialplan if the callee hangs up.</para>
134                                         </option>
135                                         <option name="d">
136                                                 <para>data-quality (modem) call (minimum delay).</para>
137                                         </option>
138                                         <option name="h">
139                                                 <para>Allow <emphasis>callee</emphasis> to hang up by pressing <literal>*</literal>.</para>
140                                         </option>
141                                         <option name="H">
142                                                 <para>Allow <emphasis>caller</emphasis> to hang up by pressing <literal>*</literal>.</para>
143                                         </option>
144                                         <option name="n">
145                                                 <para>No retries on the timeout; will exit this application and
146                                                 go to the next step.</para>
147                                         </option>
148                                         <option name="i">
149                                                 <para>Ignore call forward requests from queue members and do nothing
150                                                 when they are requested.</para>
151                                         </option>
152                                         <option name="I">
153                                                 <para>Asterisk will ignore any connected line update requests or any redirecting party
154                                                 update requests it may receive on this dial attempt.</para>
155                                         </option>
156                                         <option name="r">
157                                                 <para>Ring instead of playing MOH. Periodic Announcements are still made, if applicable.</para>
158                                         </option>
159                                         <option name="R">
160                                                 <para>Ring instead of playing MOH when a member channel is actually ringing.</para>
161                                         </option>
162                                         <option name="t">
163                                                 <para>Allow the <emphasis>called</emphasis> user to transfer the calling user.</para>
164                                         </option>
165                                         <option name="T">
166                                                 <para>Allow the <emphasis>calling</emphasis> user to transfer the call.</para>
167                                         </option>
168                                         <option name="w">
169                                                 <para>Allow the <emphasis>called</emphasis> user to write the conversation to
170                                                 disk via Monitor.</para>
171                                         </option>
172                                         <option name="W">
173                                                 <para>Allow the <emphasis>calling</emphasis> user to write the conversation to
174                                                 disk via Monitor.</para>
175                                         </option>
176                                         <option name="k">
177                                                 <para>Allow the <emphasis>called</emphasis> party to enable parking of the call by sending
178                                                 the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
179                                         </option>
180                                         <option name="K">
181                                                 <para>Allow the <emphasis>calling</emphasis> party to enable parking of the call by sending
182                                                 the DTMF sequence defined for call parking in <filename>features.conf</filename>.</para>
183                                         </option>
184                                         <option name="x">
185                                                 <para>Allow the <emphasis>called</emphasis> user to write the conversation
186                                                 to disk via MixMonitor.</para>
187                                         </option>
188                                         <option name="X">
189                                                 <para>Allow the <emphasis>calling</emphasis> user to write the conversation to
190                                                 disk via MixMonitor.</para>
191                                         </option>
192                                 </optionlist>
193                         </parameter>
194                         <parameter name="URL">
195                                 <para><replaceable>URL</replaceable> will be sent to the called party if the channel supports it.</para>
196                         </parameter>
197                         <parameter name="announceoverride" />
198                         <parameter name="timeout">
199                                 <para>Will cause the queue to fail out after a specified number of
200                                 seconds, checked between each <filename>queues.conf</filename> <replaceable>timeout</replaceable> and
201                                 <replaceable>retry</replaceable> cycle.</para>
202                         </parameter>
203                         <parameter name="AGI">
204                                 <para>Will setup an AGI script to be executed on the calling party's channel once they are
205                                 connected to a queue member.</para>
206                         </parameter>
207                         <parameter name="macro">
208                                 <para>Will run a macro on the calling party's channel once they are connected to a queue member.</para>
209                         </parameter>
210                         <parameter name="gosub">
211                                 <para>Will run a gosub on the calling party's channel once they are connected to a queue member.</para>
212                         </parameter>
213                         <parameter name="rule">
214                                 <para>Will cause the queue's defaultrule to be overridden by the rule specified.</para>
215                         </parameter>
216                         <parameter name="position">
217                                 <para>Attempt to enter the caller into the queue at the numerical position specified. <literal>1</literal>
218                                 would attempt to enter the caller at the head of the queue, and <literal>3</literal> would attempt to place
219                                 the caller third in the queue.</para>
220                         </parameter>
221                 </syntax>
222                 <description>
223                         <para>In addition to transferring the call, a call may be parked and then picked
224                         up by another user.</para>
225                         <para>This application will return to the dialplan if the queue does not exist, or
226                         any of the join options cause the caller to not enter the queue.</para>
227                         <para>This application sets the following channel variable upon completion:</para>
228                         <variablelist>
229                                 <variable name="QUEUESTATUS">
230                                         <para>The status of the call as a text string.</para>
231                                         <value name="TIMEOUT" />
232                                         <value name="FULL" />
233                                         <value name="JOINEMPTY" />
234                                         <value name="LEAVEEMPTY" />
235                                         <value name="JOINUNAVAIL" />
236                                         <value name="LEAVEUNAVAIL" />
237                                         <value name="CONTINUE" />
238                                 </variable>
239                         </variablelist>
240                 </description>
241                 <see-also>
242                         <ref type="application">Queue</ref>
243                         <ref type="application">QueueLog</ref>
244                         <ref type="application">AddQueueMember</ref>
245                         <ref type="application">RemoveQueueMember</ref>
246                         <ref type="application">PauseQueueMember</ref>
247                         <ref type="application">UnpauseQueueMember</ref>
248                         <ref type="function">QUEUE_VARIABLES</ref>
249                         <ref type="function">QUEUE_MEMBER</ref>
250                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
251                         <ref type="function">QUEUE_EXISTS</ref>
252                         <ref type="function">QUEUE_WAITING_COUNT</ref>
253                         <ref type="function">QUEUE_MEMBER_LIST</ref>
254                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
255                 </see-also>
256         </application>
257         <application name="AddQueueMember" language="en_US">
258                 <synopsis>
259                         Dynamically adds queue members.
260                 </synopsis>
261                 <syntax>
262                         <parameter name="queuename" required="true" />
263                         <parameter name="interface" />
264                         <parameter name="penalty" />
265                         <parameter name="options" />
266                         <parameter name="membername" />
267                         <parameter name="stateinterface" />
268                 </syntax>
269                 <description>
270                         <para>Dynamically adds interface to an existing queue. If the interface is
271                         already in the queue it will return an error.</para>
272                         <para>This application sets the following channel variable upon completion:</para>
273                         <variablelist>
274                                 <variable name="AQMSTATUS">
275                                         <para>The status of the attempt to add a queue member as a text string.</para>
276                                         <value name="ADDED" />
277                                         <value name="MEMBERALREADY" />
278                                         <value name="NOSUCHQUEUE" />
279                                 </variable>
280                         </variablelist>
281                 </description>
282                 <see-also>
283                         <ref type="application">Queue</ref>
284                         <ref type="application">QueueLog</ref>
285                         <ref type="application">AddQueueMember</ref>
286                         <ref type="application">RemoveQueueMember</ref>
287                         <ref type="application">PauseQueueMember</ref>
288                         <ref type="application">UnpauseQueueMember</ref>
289                         <ref type="function">QUEUE_VARIABLES</ref>
290                         <ref type="function">QUEUE_MEMBER</ref>
291                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
292                         <ref type="function">QUEUE_EXISTS</ref>
293                         <ref type="function">QUEUE_WAITING_COUNT</ref>
294                         <ref type="function">QUEUE_MEMBER_LIST</ref>
295                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
296                 </see-also>
297         </application>
298         <application name="RemoveQueueMember" language="en_US">
299                 <synopsis>
300                         Dynamically removes queue members.
301                 </synopsis>
302                 <syntax>
303                         <parameter name="queuename" required="true" />
304                         <parameter name="interface" />
305                         <parameter name="options" />
306                 </syntax>
307                 <description>
308                         <para>If the interface is <emphasis>NOT</emphasis> in the queue it will return an error.</para>
309                         <para>This application sets the following channel variable upon completion:</para>
310                         <variablelist>
311                                 <variable name="RQMSTATUS">
312                                         <value name="REMOVED" />
313                                         <value name="NOTINQUEUE" />
314                                         <value name="NOSUCHQUEUE" />
315                                 </variable>
316                         </variablelist>
317                         <para>Example: RemoveQueueMember(techsupport,SIP/3000)</para>
318                 </description>
319                 <see-also>
320                         <ref type="application">Queue</ref>
321                         <ref type="application">QueueLog</ref>
322                         <ref type="application">AddQueueMember</ref>
323                         <ref type="application">RemoveQueueMember</ref>
324                         <ref type="application">PauseQueueMember</ref>
325                         <ref type="application">UnpauseQueueMember</ref>
326                         <ref type="function">QUEUE_VARIABLES</ref>
327                         <ref type="function">QUEUE_MEMBER</ref>
328                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
329                         <ref type="function">QUEUE_EXISTS</ref>
330                         <ref type="function">QUEUE_WAITING_COUNT</ref>
331                         <ref type="function">QUEUE_MEMBER_LIST</ref>
332                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
333                 </see-also>
334         </application>
335         <application name="PauseQueueMember" language="en_US">
336                 <synopsis>
337                         Pauses a queue member.
338                 </synopsis>
339                 <syntax>
340                         <parameter name="queuename" />
341                         <parameter name="interface" required="true" />
342                         <parameter name="options" />
343                         <parameter name="reason">
344                                 <para>Is used to add extra information to the appropriate queue_log entries and manager events.</para>
345                         </parameter>
346                 </syntax>
347                 <description>
348                         <para>Pauses (blocks calls for) a queue member. The given interface will be paused in the given queue.
349                         This prevents any calls from being sent from the queue to the interface until it is
350                         unpaused with UnpauseQueueMember or the manager interface.  If no queuename is given,
351                         the interface is paused in every queue it is a member of. The application will fail if the
352                         interface is not found.</para>
353                         <para>This application sets the following channel variable upon completion:</para>
354                         <variablelist>
355                                 <variable name="PQMSTATUS">
356                                         <para>The status of the attempt to pause a queue member as a text string.</para>
357                                         <value name="PAUSED" />
358                                         <value name="NOTFOUND" />
359                                 </variable>
360                         </variablelist>
361                         <para>Example: PauseQueueMember(,SIP/3000)</para>
362                 </description>
363                 <see-also>
364                         <ref type="application">Queue</ref>
365                         <ref type="application">QueueLog</ref>
366                         <ref type="application">AddQueueMember</ref>
367                         <ref type="application">RemoveQueueMember</ref>
368                         <ref type="application">PauseQueueMember</ref>
369                         <ref type="application">UnpauseQueueMember</ref>
370                         <ref type="function">QUEUE_VARIABLES</ref>
371                         <ref type="function">QUEUE_MEMBER</ref>
372                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
373                         <ref type="function">QUEUE_EXISTS</ref>
374                         <ref type="function">QUEUE_WAITING_COUNT</ref>
375                         <ref type="function">QUEUE_MEMBER_LIST</ref>
376                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
377                 </see-also>
378         </application>
379         <application name="UnpauseQueueMember" language="en_US">
380                 <synopsis>
381                         Unpauses a queue member.                
382                 </synopsis>
383                 <syntax>
384                         <parameter name="queuename" />
385                         <parameter name="interface" required="true" />
386                         <parameter name="options" />
387                         <parameter name="reason">
388                                 <para>Is used to add extra information to the appropriate queue_log entries and manager events.</para>
389                         </parameter>
390                 </syntax>
391                 <description>
392                         <para>Unpauses (resumes calls to) a queue member. This is the counterpart to <literal>PauseQueueMember()</literal>
393                         and operates exactly the same way, except it unpauses instead of pausing the given interface.</para>
394                         <para>This application sets the following channel variable upon completion:</para>
395                         <variablelist>
396                                 <variable name="UPQMSTATUS">
397                                         <para>The status of the attempt to unpause a queue member as a text string.</para>
398                                         <value name="UNPAUSED" />
399                                         <value name="NOTFOUND" />
400                                 </variable>
401                         </variablelist>
402                         <para>Example: UnpauseQueueMember(,SIP/3000)</para>
403                 </description>
404                 <see-also>
405                         <ref type="application">Queue</ref>
406                         <ref type="application">QueueLog</ref>
407                         <ref type="application">AddQueueMember</ref>
408                         <ref type="application">RemoveQueueMember</ref>
409                         <ref type="application">PauseQueueMember</ref>
410                         <ref type="application">UnpauseQueueMember</ref>
411                         <ref type="function">QUEUE_VARIABLES</ref>
412                         <ref type="function">QUEUE_MEMBER</ref>
413                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
414                         <ref type="function">QUEUE_EXISTS</ref>
415                         <ref type="function">QUEUE_WAITING_COUNT</ref>
416                         <ref type="function">QUEUE_MEMBER_LIST</ref>
417                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
418                 </see-also>
419         </application>
420         <application name="QueueLog" language="en_US">
421                 <synopsis>
422                         Writes to the queue_log file.
423                 </synopsis>
424                 <syntax>
425                         <parameter name="queuename" required="true" />
426                         <parameter name="uniqueid" required="true" />
427                         <parameter name="agent" required="true" />
428                         <parameter name="event" required="true" />
429                         <parameter name="additionalinfo" />
430                 </syntax>
431                 <description>
432                         <para>Allows you to write your own events into the queue log.</para>
433                         <para>Example: QueueLog(101,${UNIQUEID},${AGENT},WENTONBREAK,600)</para>
434                 </description>
435                 <see-also>
436                         <ref type="application">Queue</ref>
437                         <ref type="application">QueueLog</ref>
438                         <ref type="application">AddQueueMember</ref>
439                         <ref type="application">RemoveQueueMember</ref>
440                         <ref type="application">PauseQueueMember</ref>
441                         <ref type="application">UnpauseQueueMember</ref>
442                         <ref type="function">QUEUE_VARIABLES</ref>
443                         <ref type="function">QUEUE_MEMBER</ref>
444                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
445                         <ref type="function">QUEUE_EXISTS</ref>
446                         <ref type="function">QUEUE_WAITING_COUNT</ref>
447                         <ref type="function">QUEUE_MEMBER_LIST</ref>
448                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
449                 </see-also>
450         </application>
451         <function name="QUEUE_VARIABLES" language="en_US">
452                 <synopsis>
453                         Return Queue information in variables.
454                 </synopsis>
455                 <syntax>
456                         <parameter name="queuename" required="true">
457                                 <enumlist>
458                                         <enum name="QUEUEMAX">
459                                                 <para>Maxmimum number of calls allowed.</para>
460                                         </enum>
461                                         <enum name="QUEUESTRATEGY">
462                                                 <para>The strategy of the queue.</para>
463                                         </enum>
464                                         <enum name="QUEUECALLS">
465                                                 <para>Number of calls currently in the queue.</para>
466                                         </enum>
467                                         <enum name="QUEUEHOLDTIME">
468                                                 <para>Current average hold time.</para>
469                                         </enum>
470                                         <enum name="QUEUECOMPLETED">
471                                                 <para>Number of completed calls for the queue.</para>
472                                         </enum>
473                                         <enum name="QUEUEABANDONED">
474                                                 <para>Number of abandoned calls.</para>
475                                         </enum>
476                                         <enum name="QUEUESRVLEVEL">
477                                                 <para>Queue service level.</para>
478                                         </enum>
479                                         <enum name="QUEUESRVLEVELPERF">
480                                                 <para>Current service level performance.</para>
481                                         </enum>
482                                 </enumlist>
483                         </parameter>
484                 </syntax>
485                 <description>
486                         <para>Makes the following queue variables available.</para>
487                         <para>Returns <literal>0</literal> if queue is found and setqueuevar is defined, <literal>-1</literal> otherwise.</para>
488                 </description>
489                 <see-also>
490                         <ref type="application">Queue</ref>
491                         <ref type="application">QueueLog</ref>
492                         <ref type="application">AddQueueMember</ref>
493                         <ref type="application">RemoveQueueMember</ref>
494                         <ref type="application">PauseQueueMember</ref>
495                         <ref type="application">UnpauseQueueMember</ref>
496                         <ref type="function">QUEUE_VARIABLES</ref>
497                         <ref type="function">QUEUE_MEMBER</ref>
498                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
499                         <ref type="function">QUEUE_EXISTS</ref>
500                         <ref type="function">QUEUE_WAITING_COUNT</ref>
501                         <ref type="function">QUEUE_MEMBER_LIST</ref>
502                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
503                 </see-also>
504         </function>
505         <function name="QUEUE_MEMBER" language="en_US">
506                 <synopsis>
507                         Count number of members answering a queue.
508                 </synopsis>
509                 <syntax>
510                         <parameter name="queuename" required="true" />
511                         <parameter name="option" required="true">
512                                 <enumlist>
513                                         <enum name="logged">
514                                                 <para>Returns the number of logged-in members for the specified queue.</para>
515                                         </enum>
516                                         <enum name="free">
517                                                 <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>
518                                         </enum>
519                                         <enum name="ready">
520                                                 <para>Returns the number of logged-in members for the specified queue that are immediately available to answer a call.</para>
521                                         </enum>
522                                         <enum name="count">
523                                                 <para>Returns the total number of members for the specified queue.</para>
524                                         </enum>
525                                         <enum name="penalty">
526                                                 <para>Gets or sets queue member penalty.</para>
527                                         </enum>
528                                         <enum name="paused">
529                                                 <para>Gets or sets queue member paused status.</para>
530                                         </enum>
531                                         <enum name="ignorebusy">
532                                                 <para>Gets or sets queue member ignorebusy.</para>
533                                         </enum>
534                                 </enumlist>
535                         </parameter>
536                         <parameter name="interface" required="false" />
537                 </syntax>
538                 <description>
539                         <para>Allows access to queue counts [R] and member information [R/W].</para>
540                         <para>
541                                 <replaceable>queuename</replaceable> is required for all operations
542                                 <replaceable>interface</replaceable> is required for all member operations.
543                         </para>
544                 </description>
545                 <see-also>
546                         <ref type="application">Queue</ref>
547                         <ref type="application">QueueLog</ref>
548                         <ref type="application">AddQueueMember</ref>
549                         <ref type="application">RemoveQueueMember</ref>
550                         <ref type="application">PauseQueueMember</ref>
551                         <ref type="application">UnpauseQueueMember</ref>
552                         <ref type="function">QUEUE_VARIABLES</ref>
553                         <ref type="function">QUEUE_MEMBER</ref>
554                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
555                         <ref type="function">QUEUE_EXISTS</ref>
556                         <ref type="function">QUEUE_WAITING_COUNT</ref>
557                         <ref type="function">QUEUE_MEMBER_LIST</ref>
558                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
559                 </see-also>
560         </function>
561         <function name="QUEUE_MEMBER_COUNT" language="en_US">
562                 <synopsis>
563                         Count number of members answering a queue.
564                 </synopsis>
565                 <syntax>
566                         <parameter name="queuename" required="true" />
567                 </syntax>
568                 <description>
569                         <para>Returns the number of members currently associated with the specified <replaceable>queuename</replaceable>.</para>
570                         <warning><para>This function has been deprecated in favor of the <literal>QUEUE_MEMBER()</literal> function</para></warning>
571                 </description>
572                 <see-also>
573                         <ref type="application">Queue</ref>
574                         <ref type="application">QueueLog</ref>
575                         <ref type="application">AddQueueMember</ref>
576                         <ref type="application">RemoveQueueMember</ref>
577                         <ref type="application">PauseQueueMember</ref>
578                         <ref type="application">UnpauseQueueMember</ref>
579                         <ref type="function">QUEUE_VARIABLES</ref>
580                         <ref type="function">QUEUE_MEMBER</ref>
581                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
582                         <ref type="function">QUEUE_EXISTS</ref>
583                         <ref type="function">QUEUE_WAITING_COUNT</ref>
584                         <ref type="function">QUEUE_MEMBER_LIST</ref>
585                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
586                 </see-also>
587         </function>
588         <function name="QUEUE_EXISTS" language="en_US">
589                 <synopsis>
590                         Check if a named queue exists on this server
591                 </synopsis>
592                 <syntax>
593                         <parameter name="queuename" />
594                 </syntax>
595                 <description>
596                         <para>Returns 1 if the specified queue exists, 0 if it does not</para>
597                 </description>
598                 <see-also>
599                         <ref type="application">Queue</ref>
600                         <ref type="application">QueueLog</ref>
601                         <ref type="application">AddQueueMember</ref>
602                         <ref type="application">RemoveQueueMember</ref>
603                         <ref type="application">PauseQueueMember</ref>
604                         <ref type="application">UnpauseQueueMember</ref>
605                         <ref type="function">QUEUE_VARIABLES</ref>
606                         <ref type="function">QUEUE_MEMBER</ref>
607                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
608                         <ref type="function">QUEUE_EXISTS</ref>
609                         <ref type="function">QUEUE_WAITING_COUNT</ref>
610                         <ref type="function">QUEUE_MEMBER_LIST</ref>
611                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
612                 </see-also>
613         </function>
614         <function name="QUEUE_WAITING_COUNT" language="en_US">
615                 <synopsis>
616                         Count number of calls currently waiting in a queue.
617                 </synopsis>
618                 <syntax>
619                         <parameter name="queuename" />
620                 </syntax>
621                 <description>
622                         <para>Returns the number of callers currently waiting in the specified <replaceable>queuename</replaceable>.</para>
623                 </description>
624                 <see-also>
625                         <ref type="application">Queue</ref>
626                         <ref type="application">QueueLog</ref>
627                         <ref type="application">AddQueueMember</ref>
628                         <ref type="application">RemoveQueueMember</ref>
629                         <ref type="application">PauseQueueMember</ref>
630                         <ref type="application">UnpauseQueueMember</ref>
631                         <ref type="function">QUEUE_VARIABLES</ref>
632                         <ref type="function">QUEUE_MEMBER</ref>
633                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
634                         <ref type="function">QUEUE_EXISTS</ref>
635                         <ref type="function">QUEUE_WAITING_COUNT</ref>
636                         <ref type="function">QUEUE_MEMBER_LIST</ref>
637                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
638                 </see-also>
639         </function>
640         <function name="QUEUE_MEMBER_LIST" language="en_US">
641                 <synopsis>
642                         Returns a list of interfaces on a queue.
643                 </synopsis>
644                 <syntax>
645                         <parameter name="queuename" required="true" />
646                 </syntax>
647                 <description>
648                         <para>Returns a comma-separated list of members associated with the specified <replaceable>queuename</replaceable>.</para>
649                 </description>
650                 <see-also>
651                         <ref type="application">Queue</ref>
652                         <ref type="application">QueueLog</ref>
653                         <ref type="application">AddQueueMember</ref>
654                         <ref type="application">RemoveQueueMember</ref>
655                         <ref type="application">PauseQueueMember</ref>
656                         <ref type="application">UnpauseQueueMember</ref>
657                         <ref type="function">QUEUE_VARIABLES</ref>
658                         <ref type="function">QUEUE_MEMBER</ref>
659                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
660                         <ref type="function">QUEUE_EXISTS</ref>
661                         <ref type="function">QUEUE_WAITING_COUNT</ref>
662                         <ref type="function">QUEUE_MEMBER_LIST</ref>
663                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
664                 </see-also>
665         </function>
666         <function name="QUEUE_MEMBER_PENALTY" language="en_US">
667                 <synopsis>
668                         Gets or sets queue members penalty.
669                 </synopsis>
670                 <syntax>
671                         <parameter name="queuename" required="true" />
672                         <parameter name="interface" required="true" />
673                 </syntax>
674                 <description>
675                         <para>Gets or sets queue members penalty.</para>
676                         <warning><para>This function has been deprecated in favor of the <literal>QUEUE_MEMBER()</literal> function</para></warning>
677                 </description>
678                 <see-also>
679                         <ref type="application">Queue</ref>
680                         <ref type="application">QueueLog</ref>
681                         <ref type="application">AddQueueMember</ref>
682                         <ref type="application">RemoveQueueMember</ref>
683                         <ref type="application">PauseQueueMember</ref>
684                         <ref type="application">UnpauseQueueMember</ref>
685                         <ref type="function">QUEUE_VARIABLES</ref>
686                         <ref type="function">QUEUE_MEMBER</ref>
687                         <ref type="function">QUEUE_MEMBER_COUNT</ref>
688                         <ref type="function">QUEUE_EXISTS</ref>
689                         <ref type="function">QUEUE_WAITING_COUNT</ref>
690                         <ref type="function">QUEUE_MEMBER_LIST</ref>
691                         <ref type="function">QUEUE_MEMBER_PENALTY</ref>
692                 </see-also>
693         </function>
694         <manager name="Queues" language="en_US">
695                 <synopsis>
696                         Queues.
697                 </synopsis>
698                 <syntax>
699                 </syntax>
700                 <description>
701                 </description>
702         </manager>
703         <manager name="QueueStatus" language="en_US">
704                 <synopsis>
705                         Show queue status.
706                 </synopsis>
707                 <syntax>
708                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
709                         <parameter name="Queue" />
710                         <parameter name="Member" />
711                 </syntax>
712                 <description>
713                 </description>
714         </manager>
715         <manager name="QueueSummary" language="en_US">
716                 <synopsis>
717                         Show queue summary.
718                 </synopsis>
719                 <syntax>
720                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
721                         <parameter name="Queue" />
722                 </syntax>
723                 <description>
724                 </description>
725         </manager>
726         <manager name="QueueAdd" language="en_US">
727                 <synopsis>
728                         Add interface to queue.
729                 </synopsis>
730                 <syntax>
731                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
732                         <parameter name="Queue" required="true" />
733                         <parameter name="Interface" required="true" />
734                         <parameter name="Penalty" />
735                         <parameter name="Paused" />
736                         <parameter name="MemberName" />
737                         <parameter name="StateInterface" />
738                 </syntax>
739                 <description>
740                 </description>
741         </manager>
742         <manager name="QueueRemove" language="en_US">
743                 <synopsis>
744                         Remove interface from queue.
745                 </synopsis>
746                 <syntax>
747                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
748                         <parameter name="Queue" required="true" />
749                         <parameter name="Interface" required="true" />
750                 </syntax>
751                 <description>
752                 </description>
753         </manager>
754         <manager name="QueuePause" language="en_US">
755                 <synopsis>
756                         Makes a queue member temporarily unavailable.
757                 </synopsis>
758                 <syntax>
759                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
760                         <parameter name="Interface" required="true" />
761                         <parameter name="Paused" required="true" />
762                         <parameter name="Queue" />
763                         <parameter name="Reason" />
764                 </syntax>
765                 <description>
766                 </description>
767         </manager>
768         <manager name="QueueLog" language="en_US">
769                 <synopsis>
770                         Adds custom entry in queue_log.
771                 </synopsis>
772                 <syntax>
773                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
774                         <parameter name="Queue" required="true" />
775                         <parameter name="Event" required="true" />
776                         <parameter name="Uniqueid" />
777                         <parameter name="Interface" />
778                         <parameter name="Message" />
779                 </syntax>
780                 <description>
781                 </description>
782         </manager>
783         <manager name="QueuePenalty" language="en_US">
784                 <synopsis>
785                         Set the penalty for a queue member.
786                 </synopsis>
787                 <syntax>
788                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
789                         <parameter name="Interface" required="true" />
790                         <parameter name="Penalty" required="true" />
791                         <parameter name="Queue" />
792                 </syntax>
793                 <description>
794                 </description>
795         </manager>
796         <manager name="QueueRule" language="en_US">
797                 <synopsis>
798                         Queue Rules.
799                 </synopsis>
800                 <syntax>
801                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
802                         <parameter name="Rule" />
803                 </syntax>
804                 <description>
805                 </description>
806         </manager>
807         <manager name="QueueReload" language="en_US">
808                 <synopsis>
809                         Reload a queue, queues, or any sub-section of a queue or queues.
810                 </synopsis>
811                 <syntax>
812                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
813                         <parameter name="Queue" />
814                         <parameter name="Members">
815                                 <enumlist>
816                                         <enum name="yes" />
817                                         <enum name="no" />
818                                 </enumlist>
819                         </parameter>
820                         <parameter name="Rules">
821                                 <enumlist>
822                                         <enum name="yes" />
823                                         <enum name="no" />
824                                 </enumlist>
825                         </parameter>
826                         <parameter name="Parameters">
827                                 <enumlist>
828                                         <enum name="yes" />
829                                         <enum name="no" />
830                                 </enumlist>
831                         </parameter>
832                 </syntax>
833                 <description>
834                 </description>
835         </manager>
836         <manager name="QueueReset" language="en_US">
837                 <synopsis>
838                         Reset queue statistics.
839                 </synopsis>
840                 <syntax>
841                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
842                         <parameter name="Queue" />
843                 </syntax>
844                 <description>
845                 </description>
846         </manager>
847  ***/
848
849 enum {
850         QUEUE_STRATEGY_RINGALL = 0,
851         QUEUE_STRATEGY_LEASTRECENT,
852         QUEUE_STRATEGY_FEWESTCALLS,
853         QUEUE_STRATEGY_RANDOM,
854         QUEUE_STRATEGY_RRMEMORY,
855         QUEUE_STRATEGY_LINEAR,
856         QUEUE_STRATEGY_WRANDOM,
857         QUEUE_STRATEGY_RRORDERED,
858 };
859
860 enum {
861      QUEUE_AUTOPAUSE_OFF = 0,
862      QUEUE_AUTOPAUSE_ON,
863      QUEUE_AUTOPAUSE_ALL
864 };
865
866 enum queue_reload_mask {
867         QUEUE_RELOAD_PARAMETERS = (1 << 0),
868         QUEUE_RELOAD_MEMBER = (1 << 1),
869         QUEUE_RELOAD_RULES = (1 << 2),
870         QUEUE_RESET_STATS = (1 << 3),
871 };
872
873 static const struct strategy {
874         int strategy;
875         const char *name;
876 } strategies[] = {
877         { QUEUE_STRATEGY_RINGALL, "ringall" },
878         { QUEUE_STRATEGY_LEASTRECENT, "leastrecent" },
879         { QUEUE_STRATEGY_FEWESTCALLS, "fewestcalls" },
880         { QUEUE_STRATEGY_RANDOM, "random" },
881         { QUEUE_STRATEGY_RRMEMORY, "rrmemory" },
882         { QUEUE_STRATEGY_RRMEMORY, "roundrobin" },
883         { QUEUE_STRATEGY_LINEAR, "linear" },
884         { QUEUE_STRATEGY_WRANDOM, "wrandom"},
885         { QUEUE_STRATEGY_RRORDERED, "rrordered"},
886 };
887
888 static const struct autopause {
889         int autopause;
890         const char *name;
891 } autopausesmodes [] = {
892         { QUEUE_AUTOPAUSE_OFF,"no" },
893         { QUEUE_AUTOPAUSE_ON, "yes" },
894         { QUEUE_AUTOPAUSE_ALL,"all" },
895 };
896
897
898 static struct ast_taskprocessor *devicestate_tps;
899
900 #define DEFAULT_RETRY           5
901 #define DEFAULT_TIMEOUT         15
902 #define RECHECK                 1               /*!< Recheck every second to see we we're at the top yet */
903 #define MAX_PERIODIC_ANNOUNCEMENTS 10           /*!< The maximum periodic announcements we can have */
904 #define DEFAULT_MIN_ANNOUNCE_FREQUENCY 15       /*!< The minimum number of seconds between position announcements \
905                                                      The default value of 15 provides backwards compatibility */
906 #define MAX_QUEUE_BUCKETS 53
907
908 #define RES_OKAY        0               /*!< Action completed */
909 #define RES_EXISTS      (-1)            /*!< Entry already exists */
910 #define RES_OUTOFMEMORY (-2)            /*!< Out of memory */
911 #define RES_NOSUCHQUEUE (-3)            /*!< No such queue */
912 #define RES_NOT_DYNAMIC (-4)            /*!< Member is not dynamic */
913
914 static char *app = "Queue";
915
916 static char *app_aqm = "AddQueueMember" ;
917
918 static char *app_rqm = "RemoveQueueMember" ;
919
920 static char *app_pqm = "PauseQueueMember" ;
921
922 static char *app_upqm = "UnpauseQueueMember" ;
923
924 static char *app_ql = "QueueLog" ;
925
926 /*! \brief Persistent Members astdb family */
927 static const char * const pm_family = "Queue/PersistentMembers";
928 /* The maximum length of each persistent member queue database entry */
929 #define PM_MAX_LEN 8192
930
931 /*! \brief queues.conf [general] option */
932 static int queue_persistent_members = 0;
933
934 /*! \brief queues.conf per-queue weight option */
935 static int use_weight = 0;
936
937 /*! \brief queues.conf [general] option */
938 static int autofill_default = 1;
939
940 /*! \brief queues.conf [general] option */
941 static int montype_default = 0;
942
943 /*! \brief queues.conf [general] option */
944 static int shared_lastcall = 1;
945
946 /*! \brief Subscription to device state change events */
947 static struct ast_event_sub *device_state_sub;
948
949 /*! \brief queues.conf [general] option */
950 static int update_cdr = 0;
951
952 /*! \brief queues.conf [general] option */
953 static int negative_penalty_invalid = 0;
954
955 enum queue_result {
956         QUEUE_UNKNOWN = 0,
957         QUEUE_TIMEOUT = 1,
958         QUEUE_JOINEMPTY = 2,
959         QUEUE_LEAVEEMPTY = 3,
960         QUEUE_JOINUNAVAIL = 4,
961         QUEUE_LEAVEUNAVAIL = 5,
962         QUEUE_FULL = 6,
963         QUEUE_CONTINUE = 7,
964 };
965
966 static const struct {
967         enum queue_result id;
968         char *text;
969 } queue_results[] = {
970         { QUEUE_UNKNOWN, "UNKNOWN" },
971         { QUEUE_TIMEOUT, "TIMEOUT" },
972         { QUEUE_JOINEMPTY,"JOINEMPTY" },
973         { QUEUE_LEAVEEMPTY, "LEAVEEMPTY" },
974         { QUEUE_JOINUNAVAIL, "JOINUNAVAIL" },
975         { QUEUE_LEAVEUNAVAIL, "LEAVEUNAVAIL" },
976         { QUEUE_FULL, "FULL" },
977         { QUEUE_CONTINUE, "CONTINUE" },
978 };
979
980 enum queue_timeout_priority {
981         TIMEOUT_PRIORITY_APP,
982         TIMEOUT_PRIORITY_CONF,
983 };
984
985 /*! \brief We define a custom "local user" structure because we
986  *  use it not only for keeping track of what is in use but
987  *  also for keeping track of who we're dialing.
988  *
989  *  There are two "links" defined in this structure, q_next and call_next.
990  *  q_next links ALL defined callattempt structures into a linked list. call_next is
991  *  a link which allows for a subset of the callattempts to be traversed. This subset
992  *  is used in wait_for_answer so that irrelevant callattempts are not traversed. This
993  *  also is helpful so that queue logs are always accurate in the case where a call to 
994  *  a member times out, especially if using the ringall strategy. 
995 */
996
997 struct callattempt {
998         struct callattempt *q_next;
999         struct callattempt *call_next;
1000         struct ast_channel *chan;
1001         char interface[256];
1002         int stillgoing;
1003         int metric;
1004         time_t lastcall;
1005         struct call_queue *lastqueue;
1006         struct member *member;
1007         /*! Saved connected party info from an AST_CONTROL_CONNECTED_LINE. */
1008         struct ast_party_connected_line connected;
1009         /*! TRUE if an AST_CONTROL_CONNECTED_LINE update was saved to the connected element. */
1010         unsigned int pending_connected_update:1;
1011         /*! TRUE if caller id is not available for connected line */
1012         unsigned int dial_callerid_absent:1;
1013         struct ast_aoc_decoded *aoc_s_rate_list;
1014 };
1015
1016
1017 struct queue_ent {
1018         struct call_queue *parent;             /*!< What queue is our parent */
1019         char moh[80];                          /*!< Name of musiconhold to be used */
1020         char announce[PATH_MAX];               /*!< Announcement to play for member when call is answered */
1021         char context[AST_MAX_CONTEXT];         /*!< Context when user exits queue */
1022         char digits[AST_MAX_EXTENSION];        /*!< Digits entered while in queue */
1023         int valid_digits;                      /*!< Digits entered correspond to valid extension. Exited */
1024         int pos;                               /*!< Where we are in the queue */
1025         int prio;                              /*!< Our priority */
1026         int last_pos_said;                     /*!< Last position we told the user */
1027         int ring_when_ringing;                 /*!< Should we only use ring indication when a channel is ringing? */
1028         time_t last_periodic_announce_time;    /*!< The last time we played a periodic announcement */
1029         int last_periodic_announce_sound;      /*!< The last periodic announcement we made */
1030         time_t last_pos;                       /*!< Last time we told the user their position */
1031         int opos;                              /*!< Where we started in the queue */
1032         int handled;                           /*!< Whether our call was handled */
1033         int pending;                           /*!< Non-zero if we are attempting to call a member */
1034         int max_penalty;                       /*!< Limit the members that can take this call to this penalty or lower */
1035         int min_penalty;                       /*!< Limit the members that can take this call to this penalty or higher */
1036         int linpos;                            /*!< If using linear strategy, what position are we at? */
1037         int linwrapped;                        /*!< Is the linpos wrapped? */
1038         time_t start;                          /*!< When we started holding */
1039         time_t expire;                         /*!< When this entry should expire (time out of queue) */
1040         int cancel_answered_elsewhere;         /*!< Whether we should force the CAE flag on this call (C) option*/
1041         struct ast_channel *chan;              /*!< Our channel */
1042         AST_LIST_HEAD_NOLOCK(,penalty_rule) qe_rules; /*!< Local copy of the queue's penalty rules */
1043         struct penalty_rule *pr;               /*!< Pointer to the next penalty rule to implement */
1044         struct queue_ent *next;                /*!< The next queue entry */
1045 };
1046
1047 struct member {
1048         char interface[80];                  /*!< Technology/Location to dial to reach this member*/
1049         char state_exten[AST_MAX_EXTENSION]; /*!< Extension to get state from (if using hint) */
1050         char state_context[AST_MAX_CONTEXT]; /*!< Context to use when getting state (if using hint) */
1051         char state_interface[80];            /*!< Technology/Location from which to read devicestate changes */
1052         char membername[80];                 /*!< Member name to use in queue logs */
1053         int penalty;                         /*!< Are we a last resort? */
1054         int calls;                           /*!< Number of calls serviced by this member */
1055         int dynamic;                         /*!< Are we dynamically added? */
1056         int realtime;                        /*!< Is this member realtime? */
1057         int status;                          /*!< Status of queue member */
1058         int paused;                          /*!< Are we paused (not accepting calls)? */
1059         time_t lastcall;                     /*!< When last successful call was hungup */
1060         struct call_queue *lastqueue;        /*!< Last queue we received a call */
1061         unsigned int dead:1;                 /*!< Used to detect members deleted in realtime */
1062         unsigned int delme:1;                /*!< Flag to delete entry on reload */
1063         char rt_uniqueid[80];                /*!< Unique id of realtime member entry */
1064         unsigned int ignorebusy:1;           /*!< Flag to ignore member if the status is not available */
1065 };
1066
1067 enum empty_conditions {
1068         QUEUE_EMPTY_PENALTY = (1 << 0),
1069         QUEUE_EMPTY_PAUSED = (1 << 1),
1070         QUEUE_EMPTY_INUSE = (1 << 2),
1071         QUEUE_EMPTY_RINGING = (1 << 3),
1072         QUEUE_EMPTY_UNAVAILABLE = (1 << 4),
1073         QUEUE_EMPTY_INVALID = (1 << 5),
1074         QUEUE_EMPTY_UNKNOWN = (1 << 6),
1075         QUEUE_EMPTY_WRAPUP = (1 << 7),
1076 };
1077
1078 /* values used in multi-bit flags in call_queue */
1079 #define ANNOUNCEHOLDTIME_ALWAYS 1
1080 #define ANNOUNCEHOLDTIME_ONCE 2
1081 #define QUEUE_EVENT_VARIABLES 3
1082
1083 struct penalty_rule {
1084         int time;                           /*!< Number of seconds that need to pass before applying this rule */
1085         int max_value;                      /*!< The amount specified in the penalty rule for max penalty */
1086         int min_value;                      /*!< The amount specified in the penalty rule for min penalty */
1087         int max_relative;                   /*!< Is the max adjustment relative? 1 for relative, 0 for absolute */
1088         int min_relative;                   /*!< Is the min adjustment relative? 1 for relative, 0 for absolute */
1089         AST_LIST_ENTRY(penalty_rule) list;  /*!< Next penalty_rule */
1090 };
1091
1092 #define ANNOUNCEPOSITION_YES 1 /*!< We announce position */
1093 #define ANNOUNCEPOSITION_NO 2 /*!< We don't announce position */
1094 #define ANNOUNCEPOSITION_MORE_THAN 3 /*!< We say "Currently there are more than <limit>" */
1095 #define ANNOUNCEPOSITION_LIMIT 4 /*!< We not announce position more than <limit> */
1096
1097 struct call_queue {
1098         AST_DECLARE_STRING_FIELDS(
1099                 /*! Queue name */
1100                 AST_STRING_FIELD(name);
1101                 /*! Music on Hold class */
1102                 AST_STRING_FIELD(moh);
1103                 /*! Announcement to play when call is answered */
1104                 AST_STRING_FIELD(announce);
1105                 /*! Exit context */
1106                 AST_STRING_FIELD(context);
1107                 /*! Macro to run upon member connection */
1108                 AST_STRING_FIELD(membermacro);
1109                 /*! Gosub to run upon member connection */
1110                 AST_STRING_FIELD(membergosub);
1111                 /*! Default rule to use if none specified in call to Queue() */
1112                 AST_STRING_FIELD(defaultrule);
1113                 /*! Sound file: "Your call is now first in line" (def. queue-youarenext) */
1114                 AST_STRING_FIELD(sound_next);
1115                 /*! Sound file: "There are currently" (def. queue-thereare) */
1116                 AST_STRING_FIELD(sound_thereare);
1117                 /*! Sound file: "calls waiting to speak to a representative." (def. queue-callswaiting) */
1118                 AST_STRING_FIELD(sound_calls);
1119                 /*! Sound file: "Currently there are more than" (def. queue-quantity1) */
1120                 AST_STRING_FIELD(queue_quantity1);
1121                 /*! Sound file: "callers waiting to speak with a representative" (def. queue-quantity2) */
1122                 AST_STRING_FIELD(queue_quantity2);
1123                 /*! Sound file: "The current estimated total holdtime is" (def. queue-holdtime) */
1124                 AST_STRING_FIELD(sound_holdtime);
1125                 /*! Sound file: "minutes." (def. queue-minutes) */
1126                 AST_STRING_FIELD(sound_minutes);
1127                 /*! Sound file: "minute." (def. queue-minute) */
1128                 AST_STRING_FIELD(sound_minute);
1129                 /*! Sound file: "seconds." (def. queue-seconds) */
1130                 AST_STRING_FIELD(sound_seconds);
1131                 /*! Sound file: "Thank you for your patience." (def. queue-thankyou) */
1132                 AST_STRING_FIELD(sound_thanks);
1133                 /*! Sound file: Custom announce for caller, no default */
1134                 AST_STRING_FIELD(sound_callerannounce);
1135                 /*! Sound file: "Hold time" (def. queue-reporthold) */
1136                 AST_STRING_FIELD(sound_reporthold);
1137         );
1138         /*! Sound files: Custom announce, no default */
1139         struct ast_str *sound_periodicannounce[MAX_PERIODIC_ANNOUNCEMENTS];
1140         unsigned int dead:1;
1141         unsigned int eventwhencalled:2;
1142         unsigned int ringinuse:1;
1143         unsigned int setinterfacevar:1;
1144         unsigned int setqueuevar:1;
1145         unsigned int setqueueentryvar:1;
1146         unsigned int reportholdtime:1;
1147         unsigned int wrapped:1;
1148         unsigned int timeoutrestart:1;
1149         unsigned int announceholdtime:2;
1150         unsigned int announceposition:3;
1151         int strategy:4;
1152         unsigned int maskmemberstatus:1;
1153         unsigned int realtime:1;
1154         unsigned int found:1;
1155         unsigned int relativeperiodicannounce:1;
1156         enum empty_conditions joinempty;
1157         enum empty_conditions leavewhenempty;
1158         int announcepositionlimit;          /*!< How many positions we announce? */
1159         int announcefrequency;              /*!< How often to announce their position */
1160         int minannouncefrequency;           /*!< The minimum number of seconds between position announcements (def. 15) */
1161         int periodicannouncefrequency;      /*!< How often to play periodic announcement */
1162         int numperiodicannounce;            /*!< The number of periodic announcements configured */
1163         int randomperiodicannounce;         /*!< Are periodic announcments randomly chosen */
1164         int roundingseconds;                /*!< How many seconds do we round to? */
1165         int holdtime;                       /*!< Current avg holdtime, based on an exponential average */
1166         int talktime;                       /*!< Current avg talktime, based on the same exponential average */
1167         int callscompleted;                 /*!< Number of queue calls completed */
1168         int callsabandoned;                 /*!< Number of queue calls abandoned */
1169         int servicelevel;                   /*!< seconds setting for servicelevel*/
1170         int callscompletedinsl;             /*!< Number of calls answered with servicelevel*/
1171         char monfmt[8];                     /*!< Format to use when recording calls */
1172         int montype;                        /*!< Monitor type  Monitor vs. MixMonitor */
1173         int count;                          /*!< How many entries */
1174         int maxlen;                         /*!< Max number of entries */
1175         int wrapuptime;                     /*!< Wrapup Time */
1176         int penaltymemberslimit;            /*!< Disregard penalty when queue has fewer than this many members */
1177
1178         int retry;                          /*!< Retry calling everyone after this amount of time */
1179         int timeout;                        /*!< How long to wait for an answer */
1180         int weight;                         /*!< Respective weight */
1181         int autopause;                      /*!< Auto pause queue members if they fail to answer */
1182         int autopausedelay;                 /*!< Delay auto pause for autopausedelay seconds since last call */
1183         int timeoutpriority;                /*!< Do we allow a fraction of the timeout to occur for a ring? */
1184
1185         /* Queue strategy things */
1186         int rrpos;                          /*!< Round Robin - position */
1187         int memberdelay;                    /*!< Seconds to delay connecting member to caller */
1188         int autofill;                       /*!< Ignore the head call status and ring an available agent */
1189         
1190         struct ao2_container *members;             /*!< Head of the list of members */
1191         /*! 
1192          * \brief Number of members _logged in_
1193          * \note There will be members in the members container that are not logged
1194          *       in, so this can not simply be replaced with ao2_container_count(). 
1195          */
1196         int membercount;
1197         struct queue_ent *head;             /*!< Head of the list of callers */
1198         AST_LIST_ENTRY(call_queue) list;    /*!< Next call queue */
1199         AST_LIST_HEAD_NOLOCK(, penalty_rule) rules; /*!< The list of penalty rules to invoke */
1200 };
1201
1202 struct rule_list {
1203         char name[80];
1204         AST_LIST_HEAD_NOLOCK(,penalty_rule) rules;
1205         AST_LIST_ENTRY(rule_list) list;
1206 };
1207
1208 static AST_LIST_HEAD_STATIC(rule_lists, rule_list);
1209
1210 static struct ao2_container *queues;
1211
1212 static void update_realtime_members(struct call_queue *q);
1213 static struct member *interface_exists(struct call_queue *q, const char *interface);
1214 static int set_member_paused(const char *queuename, const char *interface, const char *reason, int paused);
1215
1216 static void queue_transfer_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan);
1217 /*! \brief sets the QUEUESTATUS channel variable */
1218 static void set_queue_result(struct ast_channel *chan, enum queue_result res)
1219 {
1220         int i;
1221
1222         for (i = 0; i < ARRAY_LEN(queue_results); i++) {
1223                 if (queue_results[i].id == res) {
1224                         pbx_builtin_setvar_helper(chan, "QUEUESTATUS", queue_results[i].text);
1225                         return;
1226                 }
1227         }
1228 }
1229
1230 static const char *int2strat(int strategy)
1231 {
1232         int x;
1233
1234         for (x = 0; x < ARRAY_LEN(strategies); x++) {
1235                 if (strategy == strategies[x].strategy)
1236                         return strategies[x].name;
1237         }
1238
1239         return "<unknown>";
1240 }
1241
1242 static int strat2int(const char *strategy)
1243 {
1244         int x;
1245
1246         for (x = 0; x < ARRAY_LEN(strategies); x++) {
1247                 if (!strcasecmp(strategy, strategies[x].name))
1248                         return strategies[x].strategy;
1249         }
1250
1251         return -1;
1252 }
1253
1254 static int autopause2int(const char *autopause)
1255 {
1256         int x;
1257         /*This 'double check' that default value is OFF */
1258         if (ast_strlen_zero(autopause))
1259                 return QUEUE_AUTOPAUSE_OFF;
1260
1261         /*This 'double check' is to ensure old values works */
1262         if(ast_true(autopause))
1263                 return QUEUE_AUTOPAUSE_ON;
1264
1265         for (x = 0; x < ARRAY_LEN(autopausesmodes); x++) {
1266                 if (!strcasecmp(autopause, autopausesmodes[x].name))
1267                         return autopausesmodes[x].autopause;
1268         }
1269
1270         /*This 'double check' that default value is OFF */
1271         return QUEUE_AUTOPAUSE_OFF;
1272 }
1273
1274 static int queue_hash_cb(const void *obj, const int flags)
1275 {
1276         const struct call_queue *q = obj;
1277
1278         return ast_str_case_hash(q->name);
1279 }
1280
1281 static int queue_cmp_cb(void *obj, void *arg, int flags)
1282 {
1283         struct call_queue *q = obj, *q2 = arg;
1284         return !strcasecmp(q->name, q2->name) ? CMP_MATCH | CMP_STOP : 0;
1285 }
1286
1287 #ifdef REF_DEBUG_ONLY_QUEUES
1288 #define queue_ref(a)    __ao2_ref_debug(a,1,"",__FILE__,__LINE__,__PRETTY_FUNCTION__)
1289 #define queue_unref(a)  __ao2_ref_debug(a,-1,"",__FILE__,__LINE__,__PRETTY_FUNCTION__)
1290 #define queue_t_ref(a,b)        __ao2_ref_debug(a,1,b,__FILE__,__LINE__,__PRETTY_FUNCTION__)
1291 #define queue_t_unref(a,b)      __ao2_ref_debug(a,-1,b,__FILE__,__LINE__,__PRETTY_FUNCTION__)
1292 #define queues_t_link(c,q,tag)  __ao2_link_debug(c,q,tag,__FILE__,__LINE__,__PRETTY_FUNCTION__)
1293 #define queues_t_unlink(c,q,tag)        __ao2_unlink_debug(c,q,tag,__FILE__,__LINE__,__PRETTY_FUNCTION__)
1294 #else
1295 #define queue_t_ref(a,b)        queue_ref(a)
1296 #define queue_t_unref(a,b)      queue_unref(a)
1297 #define queues_t_link(c,q,tag)  ao2_t_link(c,q,tag)
1298 #define queues_t_unlink(c,q,tag)        ao2_t_unlink(c,q,tag)
1299 static inline struct call_queue *queue_ref(struct call_queue *q)
1300 {
1301         ao2_ref(q, 1);
1302         return q;
1303 }
1304
1305 static inline struct call_queue *queue_unref(struct call_queue *q)
1306 {
1307         ao2_ref(q, -1);
1308         return q;
1309 }
1310 #endif
1311
1312 /*! \brief Set variables of queue */
1313 static void set_queue_variables(struct call_queue *q, struct ast_channel *chan)
1314 {
1315         char interfacevar[256]="";
1316         float sl = 0;
1317
1318         ao2_lock(q);
1319
1320         if (q->setqueuevar) {
1321                 sl = 0;
1322                 if (q->callscompleted > 0) 
1323                         sl = 100 * ((float) q->callscompletedinsl / (float) q->callscompleted);
1324
1325                 snprintf(interfacevar, sizeof(interfacevar),
1326                         "QUEUENAME=%s,QUEUEMAX=%d,QUEUESTRATEGY=%s,QUEUECALLS=%d,QUEUEHOLDTIME=%d,QUEUETALKTIME=%d,QUEUECOMPLETED=%d,QUEUEABANDONED=%d,QUEUESRVLEVEL=%d,QUEUESRVLEVELPERF=%2.1f",
1327                         q->name, q->maxlen, int2strat(q->strategy), q->count, q->holdtime, q->talktime, q->callscompleted, q->callsabandoned,  q->servicelevel, sl);
1328
1329                 ao2_unlock(q);
1330         
1331                 pbx_builtin_setvar_multiple(chan, interfacevar); 
1332         } else {
1333                 ao2_unlock(q);
1334         }
1335 }
1336
1337 /*! \brief Insert the 'new' entry after the 'prev' entry of queue 'q' */
1338 static inline void insert_entry(struct call_queue *q, struct queue_ent *prev, struct queue_ent *new, int *pos)
1339 {
1340         struct queue_ent *cur;
1341
1342         if (!q || !new)
1343                 return;
1344         if (prev) {
1345                 cur = prev->next;
1346                 prev->next = new;
1347         } else {
1348                 cur = q->head;
1349                 q->head = new;
1350         }
1351         new->next = cur;
1352
1353         /* every queue_ent must have a reference to it's parent call_queue, this
1354          * reference does not go away until the end of the queue_ent's life, meaning
1355          * that even when the queue_ent leaves the call_queue this ref must remain. */
1356         queue_ref(q);
1357         new->parent = q;
1358         new->pos = ++(*pos);
1359         new->opos = *pos;
1360 }
1361
1362 /*! \brief Check if members are available
1363  *
1364  * This function checks to see if members are available to be called. If any member
1365  * is available, the function immediately returns 0. If no members are available,
1366  * then -1 is returned.
1367  */
1368 static int get_member_status(struct call_queue *q, int max_penalty, int min_penalty, enum empty_conditions conditions)
1369 {
1370         struct member *member;
1371         struct ao2_iterator mem_iter;
1372
1373         ao2_lock(q);
1374         mem_iter = ao2_iterator_init(q->members, 0);
1375         for (; (member = ao2_iterator_next(&mem_iter)); ao2_ref(member, -1)) {
1376                 if ((max_penalty && (member->penalty > max_penalty)) || (min_penalty && (member->penalty < min_penalty))) {
1377                         if (conditions & QUEUE_EMPTY_PENALTY) {
1378                                 ast_debug(4, "%s is unavailable because his penalty is not between %d and %d\n", member->membername, min_penalty, max_penalty);
1379                                 continue;
1380                         }
1381                 }
1382
1383                 switch (member->status) {
1384                 case AST_DEVICE_INVALID:
1385                         if (conditions & QUEUE_EMPTY_INVALID) {
1386                                 ast_debug(4, "%s is unavailable because his device state is 'invalid'\n", member->membername);
1387                                 break;
1388                         }
1389                         goto default_case;
1390                 case AST_DEVICE_UNAVAILABLE:
1391                         if (conditions & QUEUE_EMPTY_UNAVAILABLE) {
1392                                 ast_debug(4, "%s is unavailable because his device state is 'unavailable'\n", member->membername);
1393                                 break;
1394                         }
1395                         goto default_case;
1396                 case AST_DEVICE_INUSE:
1397                         if (conditions & QUEUE_EMPTY_INUSE) {
1398                                 ast_debug(4, "%s is unavailable because his device state is 'inuse'\n", member->membername);
1399                                 break;
1400                         }
1401                         goto default_case;
1402                 case AST_DEVICE_RINGING:
1403                         if (conditions & QUEUE_EMPTY_RINGING) {
1404                                 ast_debug(4, "%s is unavailable because his device state is 'ringing'\n", member->membername);
1405                                 break;
1406                         }
1407                         goto default_case;
1408                 case AST_DEVICE_UNKNOWN:
1409                         if (conditions & QUEUE_EMPTY_UNKNOWN) {
1410                                 ast_debug(4, "%s is unavailable because his device state is 'unknown'\n", member->membername);
1411                                 break;
1412                         }
1413                         /* Fall-through */
1414                 default:
1415                 default_case:
1416                         if (member->paused && (conditions & QUEUE_EMPTY_PAUSED)) {
1417                                 ast_debug(4, "%s is unavailable because he is paused'\n", member->membername);
1418                                 break;
1419                         } else if ((conditions & QUEUE_EMPTY_WRAPUP) && member->lastcall && q->wrapuptime && (time(NULL) - q->wrapuptime < member->lastcall)) {
1420                                 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), q->wrapuptime);
1421                                 break;
1422                         } else {
1423                                 ao2_unlock(q);
1424                                 ao2_ref(member, -1);
1425                                 ao2_iterator_destroy(&mem_iter);
1426                                 ast_debug(4, "%s is available.\n", member->membername);
1427                                 return 0;
1428                         }
1429                         break;
1430                 }
1431         }
1432         ao2_iterator_destroy(&mem_iter);
1433
1434         ao2_unlock(q);
1435         return -1;
1436 }
1437
1438 struct statechange {
1439         AST_LIST_ENTRY(statechange) entry;
1440         int state;
1441         char dev[0];
1442 };
1443
1444 /*! \brief set a member's status based on device state of that member's state_interface.
1445  *  
1446  * Lock interface list find sc, iterate through each queues queue_member list for member to
1447  * update state inside queues
1448 */
1449 static int update_status(struct call_queue *q, struct member *m, const int status)
1450 {
1451         m->status = status;
1452
1453         if (q->maskmemberstatus)
1454                 return 0;
1455
1456         manager_event(EVENT_FLAG_AGENT, "QueueMemberStatus",
1457                 "Queue: %s\r\n"
1458                 "Location: %s\r\n"
1459                 "MemberName: %s\r\n"
1460                 "StateInterface: %s\r\n"
1461                 "Membership: %s\r\n"
1462                 "Penalty: %d\r\n"
1463                 "CallsTaken: %d\r\n"
1464                 "LastCall: %d\r\n"
1465                 "Status: %d\r\n"
1466                 "Paused: %d\r\n",
1467                 q->name, m->interface, m->membername, m->state_interface, m->dynamic ? "dynamic" : m->realtime ? "realtime" : "static",
1468                 m->penalty, m->calls, (int)m->lastcall, m->status, m->paused
1469         );
1470
1471         return 0;
1472 }
1473
1474 /*! \brief set a member's status based on device state of that member's interface*/
1475 static int handle_statechange(void *datap)
1476 {
1477         struct statechange *sc = datap;
1478         struct ao2_iterator miter, qiter;
1479         struct member *m;
1480         struct call_queue *q;
1481         char interface[80], *slash_pos;
1482         int found = 0;
1483
1484         qiter = ao2_iterator_init(queues, 0);
1485         while ((q = ao2_t_iterator_next(&qiter, "Iterate over queues"))) {
1486                 ao2_lock(q);
1487
1488                 miter = ao2_iterator_init(q->members, 0);
1489                 for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
1490                         ast_copy_string(interface, m->state_interface, sizeof(interface));
1491
1492                         if ((slash_pos = strchr(interface, '/')))
1493                                 if (!strncasecmp(interface, "Local/", 6) && (slash_pos = strchr(slash_pos + 1, '/')))
1494                                         *slash_pos = '\0';
1495
1496                         if (!strcasecmp(interface, sc->dev)) {
1497                                 found = 1;
1498                                 update_status(q, m, sc->state);
1499                                 ao2_ref(m, -1);
1500                                 break;
1501                         }
1502                 }
1503                 ao2_iterator_destroy(&miter);
1504
1505                 ao2_unlock(q);
1506                 queue_t_unref(q, "Done with iterator");
1507         }
1508         ao2_iterator_destroy(&qiter);
1509
1510         if (found)
1511                 ast_debug(1, "Device '%s' changed to state '%d' (%s)\n", sc->dev, sc->state, ast_devstate2str(sc->state));
1512         else
1513                 ast_debug(3, "Device '%s' changed to state '%d' (%s) but we don't care because they're not a member of any queue.\n", sc->dev, sc->state, ast_devstate2str(sc->state));
1514
1515         ast_free(sc);
1516         return 0;
1517 }
1518
1519 static void device_state_cb(const struct ast_event *event, void *unused)
1520 {
1521         enum ast_device_state state;
1522         const char *device;
1523         struct statechange *sc;
1524         size_t datapsize;
1525
1526         state = ast_event_get_ie_uint(event, AST_EVENT_IE_STATE);
1527         device = ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE);
1528
1529         if (ast_strlen_zero(device)) {
1530                 ast_log(LOG_ERROR, "Received invalid event that had no device IE\n");
1531                 return;
1532         }
1533         datapsize = sizeof(*sc) + strlen(device) + 1;
1534         if (!(sc = ast_calloc(1, datapsize))) {
1535                 ast_log(LOG_ERROR, "failed to calloc a state change struct\n");
1536                 return;
1537         }
1538         sc->state = state;
1539         strcpy(sc->dev, device);
1540         if (ast_taskprocessor_push(devicestate_tps, handle_statechange, sc) < 0) {
1541                 ast_free(sc);
1542         }
1543 }
1544
1545 /*! \brief Helper function which converts from extension state to device state values */
1546 static int extensionstate2devicestate(int state)
1547 {
1548         switch (state) {
1549         case AST_EXTENSION_NOT_INUSE:
1550                 state = AST_DEVICE_NOT_INUSE;
1551                 break;
1552         case AST_EXTENSION_INUSE:
1553                 state = AST_DEVICE_INUSE;
1554                 break;
1555         case AST_EXTENSION_BUSY:
1556                 state = AST_DEVICE_BUSY;
1557                 break;
1558         case AST_EXTENSION_RINGING:
1559                 state = AST_DEVICE_RINGING;
1560                 break;
1561         case AST_EXTENSION_ONHOLD:
1562                 state = AST_DEVICE_ONHOLD;
1563                 break;
1564         case AST_EXTENSION_UNAVAILABLE:
1565                 state = AST_DEVICE_UNAVAILABLE;
1566                 break;
1567         case AST_EXTENSION_REMOVED:
1568         case AST_EXTENSION_DEACTIVATED:
1569         default:
1570                 state = AST_DEVICE_INVALID;
1571                 break;
1572         }
1573
1574         return state;
1575 }
1576
1577 static int extension_state_cb(const char *context, const char *exten, enum ast_extension_states state, void *data)
1578 {
1579         struct ao2_iterator miter, qiter;
1580         struct member *m;
1581         struct call_queue *q;
1582         int found = 0, device_state = extensionstate2devicestate(state);
1583
1584         qiter = ao2_iterator_init(queues, 0);
1585         while ((q = ao2_t_iterator_next(&qiter, "Iterate through queues"))) {
1586                 ao2_lock(q);
1587
1588                 miter = ao2_iterator_init(q->members, 0);
1589                 for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
1590                         if (!strcmp(m->state_context, context) && !strcmp(m->state_exten, exten)) {
1591                                 update_status(q, m, device_state);
1592                                 ao2_ref(m, -1);
1593                                 found = 1;
1594                                 break;
1595                         }
1596                 }
1597                 ao2_iterator_destroy(&miter);
1598
1599                 ao2_unlock(q);
1600                 queue_t_unref(q, "Done with iterator");
1601         }
1602         ao2_iterator_destroy(&qiter);
1603
1604         if (found) {
1605                 ast_debug(1, "Extension '%s@%s' changed to state '%d' (%s)\n", exten, context, device_state, ast_devstate2str(device_state));
1606         } else {
1607                 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",
1608                           exten, context, device_state, ast_devstate2str(device_state));
1609         }
1610
1611         return 0;
1612 }
1613
1614 /*! \brief Return the current state of a member */
1615 static int get_queue_member_status(struct member *cur)
1616 {
1617         return ast_strlen_zero(cur->state_exten) ? ast_device_state(cur->state_interface) : extensionstate2devicestate(ast_extension_state(NULL, cur->state_context, cur->state_exten));
1618 }
1619
1620 /*! \brief allocate space for new queue member and set fields based on parameters passed */
1621 static struct member *create_queue_member(const char *interface, const char *membername, int penalty, int paused, const char *state_interface)
1622 {
1623         struct member *cur;
1624         
1625         if ((cur = ao2_alloc(sizeof(*cur), NULL))) {
1626                 cur->penalty = penalty;
1627                 cur->paused = paused;
1628                 ast_copy_string(cur->interface, interface, sizeof(cur->interface));
1629                 if (!ast_strlen_zero(state_interface))
1630                         ast_copy_string(cur->state_interface, state_interface, sizeof(cur->state_interface));
1631                 else
1632                         ast_copy_string(cur->state_interface, interface, sizeof(cur->state_interface));
1633                 if (!ast_strlen_zero(membername))
1634                         ast_copy_string(cur->membername, membername, sizeof(cur->membername));
1635                 else
1636                         ast_copy_string(cur->membername, interface, sizeof(cur->membername));
1637                 if (!strchr(cur->interface, '/'))
1638                         ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
1639                 if (!strncmp(cur->state_interface, "hint:", 5)) {
1640                         char *tmp = ast_strdupa(cur->state_interface), *context = tmp;
1641                         char *exten = strsep(&context, "@") + 5;
1642
1643                         ast_copy_string(cur->state_exten, exten, sizeof(cur->state_exten));
1644                         ast_copy_string(cur->state_context, S_OR(context, "default"), sizeof(cur->state_context));
1645                 }
1646                 cur->status = get_queue_member_status(cur);
1647         }
1648
1649         return cur;
1650 }
1651
1652
1653 static int compress_char(const char c)
1654 {
1655         if (c < 32)
1656                 return 0;
1657         else if (c > 96)
1658                 return c - 64;
1659         else
1660                 return c - 32;
1661 }
1662
1663 static int member_hash_fn(const void *obj, const int flags)
1664 {
1665         const struct member *mem = obj;
1666         const char *chname = strchr(mem->interface, '/');
1667         int ret = 0, i;
1668         if (!chname)
1669                 chname = mem->interface;
1670         for (i = 0; i < 5 && chname[i]; i++)
1671                 ret += compress_char(chname[i]) << (i * 6);
1672         return ret;
1673 }
1674
1675 static int member_cmp_fn(void *obj1, void *obj2, int flags)
1676 {
1677         struct member *mem1 = obj1, *mem2 = obj2;
1678         return strcasecmp(mem1->interface, mem2->interface) ? 0 : CMP_MATCH | CMP_STOP;
1679 }
1680
1681 /*! 
1682  * \brief Initialize Queue default values.
1683  * \note the queue's lock  must be held before executing this function
1684 */
1685 static void init_queue(struct call_queue *q)
1686 {
1687         int i;
1688         struct penalty_rule *pr_iter;
1689
1690         q->dead = 0;
1691         q->retry = DEFAULT_RETRY;
1692         q->timeout = DEFAULT_TIMEOUT;
1693         q->maxlen = 0;
1694         q->announcefrequency = 0;
1695         q->minannouncefrequency = DEFAULT_MIN_ANNOUNCE_FREQUENCY;
1696         q->announceholdtime = 1;
1697         q->announcepositionlimit = 10; /* Default 10 positions */
1698         q->announceposition = ANNOUNCEPOSITION_YES; /* Default yes */
1699         q->roundingseconds = 0; /* Default - don't announce seconds */
1700         q->servicelevel = 0;
1701         q->ringinuse = 1;
1702         q->setinterfacevar = 0;
1703         q->setqueuevar = 0;
1704         q->setqueueentryvar = 0;
1705         q->autofill = autofill_default;
1706         q->montype = montype_default;
1707         q->monfmt[0] = '\0';
1708         q->reportholdtime = 0;
1709         q->wrapuptime = 0;
1710         q->penaltymemberslimit = 0;
1711         q->joinempty = 0;
1712         q->leavewhenempty = 0;
1713         q->memberdelay = 0;
1714         q->maskmemberstatus = 0;
1715         q->eventwhencalled = 0;
1716         q->weight = 0;
1717         q->timeoutrestart = 0;
1718         q->periodicannouncefrequency = 0;
1719         q->randomperiodicannounce = 0;
1720         q->numperiodicannounce = 0;
1721         q->autopause = QUEUE_AUTOPAUSE_OFF;
1722         q->timeoutpriority = TIMEOUT_PRIORITY_APP;
1723         q->autopausedelay = 0;
1724         if (!q->members) {
1725                 if (q->strategy == QUEUE_STRATEGY_LINEAR || q->strategy == QUEUE_STRATEGY_RRORDERED)
1726                         /* linear strategy depends on order, so we have to place all members in a single bucket */
1727                         q->members = ao2_container_alloc(1, member_hash_fn, member_cmp_fn);
1728                 else
1729                         q->members = ao2_container_alloc(37, member_hash_fn, member_cmp_fn);
1730         }
1731         q->found = 1;
1732
1733         ast_string_field_set(q, sound_next, "queue-youarenext");
1734         ast_string_field_set(q, sound_thereare, "queue-thereare");
1735         ast_string_field_set(q, sound_calls, "queue-callswaiting");
1736         ast_string_field_set(q, queue_quantity1, "queue-quantity1");
1737         ast_string_field_set(q, queue_quantity2, "queue-quantity2");
1738         ast_string_field_set(q, sound_holdtime, "queue-holdtime");
1739         ast_string_field_set(q, sound_minutes, "queue-minutes");
1740         ast_string_field_set(q, sound_minute, "queue-minute");
1741         ast_string_field_set(q, sound_seconds, "queue-seconds");
1742         ast_string_field_set(q, sound_thanks, "queue-thankyou");
1743         ast_string_field_set(q, sound_reporthold, "queue-reporthold");
1744
1745         if ((q->sound_periodicannounce[0] = ast_str_create(32)))
1746                 ast_str_set(&q->sound_periodicannounce[0], 0, "queue-periodic-announce");
1747
1748         for (i = 1; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
1749                 if (q->sound_periodicannounce[i])
1750                         ast_str_set(&q->sound_periodicannounce[i], 0, "%s", "");
1751         }
1752
1753         while ((pr_iter = AST_LIST_REMOVE_HEAD(&q->rules,list)))
1754                 ast_free(pr_iter);
1755 }
1756
1757 static void clear_queue(struct call_queue *q)
1758 {
1759         q->holdtime = 0;
1760         q->callscompleted = 0;
1761         q->callsabandoned = 0;
1762         q->callscompletedinsl = 0;
1763         q->talktime = 0;
1764
1765         if (q->members) {
1766                 struct member *mem;
1767                 struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
1768                 while ((mem = ao2_iterator_next(&mem_iter))) {
1769                         mem->calls = 0;
1770                         mem->lastcall = 0;
1771                         ao2_ref(mem, -1);
1772                 }
1773                 ao2_iterator_destroy(&mem_iter);
1774         }
1775 }
1776
1777 /*! 
1778  * \brief Change queue penalty by adding rule.
1779  *
1780  * Check rule for errors with time or fomatting, see if rule is relative to rest 
1781  * of queue, iterate list of rules to find correct insertion point, insert and return.
1782  * \retval -1 on failure
1783  * \retval 0 on success 
1784  * \note Call this with the rule_lists locked 
1785 */
1786 static int insert_penaltychange(const char *list_name, const char *content, const int linenum)
1787 {
1788         char *timestr, *maxstr, *minstr, *contentdup;
1789         struct penalty_rule *rule = NULL, *rule_iter;
1790         struct rule_list *rl_iter;
1791         int penaltychangetime, inserted = 0;
1792
1793         if (!(rule = ast_calloc(1, sizeof(*rule)))) {
1794                 return -1;
1795         }
1796
1797         contentdup = ast_strdupa(content);
1798         
1799         if (!(maxstr = strchr(contentdup, ','))) {
1800                 ast_log(LOG_WARNING, "Improperly formatted penaltychange rule at line %d. Ignoring.\n", linenum);
1801                 ast_free(rule);
1802                 return -1;
1803         }
1804
1805         *maxstr++ = '\0';
1806         timestr = contentdup;
1807
1808         if ((penaltychangetime = atoi(timestr)) < 0) {
1809                 ast_log(LOG_WARNING, "Improper time parameter specified for penaltychange rule at line %d. Ignoring.\n", linenum);
1810                 ast_free(rule);
1811                 return -1;
1812         }
1813
1814         rule->time = penaltychangetime;
1815
1816         if ((minstr = strchr(maxstr,',')))
1817                 *minstr++ = '\0';
1818         
1819         /* The last check will evaluate true if either no penalty change is indicated for a given rule
1820          * OR if a min penalty change is indicated but no max penalty change is */
1821         if (*maxstr == '+' || *maxstr == '-' || *maxstr == '\0') {
1822                 rule->max_relative = 1;
1823         }
1824
1825         rule->max_value = atoi(maxstr);
1826
1827         if (!ast_strlen_zero(minstr)) {
1828                 if (*minstr == '+' || *minstr == '-')
1829                         rule->min_relative = 1;
1830                 rule->min_value = atoi(minstr);
1831         } else /*there was no minimum specified, so assume this means no change*/
1832                 rule->min_relative = 1;
1833
1834         /*We have the rule made, now we need to insert it where it belongs*/
1835         AST_LIST_TRAVERSE(&rule_lists, rl_iter, list){
1836                 if (strcasecmp(rl_iter->name, list_name))
1837                         continue;
1838
1839                 AST_LIST_TRAVERSE_SAFE_BEGIN(&rl_iter->rules, rule_iter, list) {
1840                         if (rule->time < rule_iter->time) {
1841                                 AST_LIST_INSERT_BEFORE_CURRENT(rule, list);
1842                                 inserted = 1;
1843                                 break;
1844                         }
1845                 }
1846                 AST_LIST_TRAVERSE_SAFE_END;
1847         
1848                 if (!inserted) {
1849                         AST_LIST_INSERT_TAIL(&rl_iter->rules, rule, list);
1850                 }
1851         }
1852
1853         return 0;
1854 }
1855
1856 static void parse_empty_options(const char *value, enum empty_conditions *empty, int joinempty)
1857 {
1858         char *value_copy = ast_strdupa(value);
1859         char *option = NULL;
1860         while ((option = strsep(&value_copy, ","))) {
1861                 if (!strcasecmp(option, "paused")) {
1862                         *empty |= QUEUE_EMPTY_PAUSED;
1863                 } else if (!strcasecmp(option, "penalty")) {
1864                         *empty |= QUEUE_EMPTY_PENALTY;
1865                 } else if (!strcasecmp(option, "inuse")) {
1866                         *empty |= QUEUE_EMPTY_INUSE;
1867                 } else if (!strcasecmp(option, "ringing")) {
1868                         *empty |= QUEUE_EMPTY_RINGING;
1869                 } else if (!strcasecmp(option, "invalid")) {
1870                         *empty |= QUEUE_EMPTY_INVALID;
1871                 } else if (!strcasecmp(option, "wrapup")) {
1872                         *empty |= QUEUE_EMPTY_WRAPUP;
1873                 } else if (!strcasecmp(option, "unavailable")) {
1874                         *empty |= QUEUE_EMPTY_UNAVAILABLE;
1875                 } else if (!strcasecmp(option, "unknown")) {
1876                         *empty |= QUEUE_EMPTY_UNKNOWN;
1877                 } else if (!strcasecmp(option, "loose")) {
1878                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID);
1879                 } else if (!strcasecmp(option, "strict")) {
1880                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED | QUEUE_EMPTY_UNAVAILABLE);
1881                 } else if ((ast_false(option) && joinempty) || (ast_true(option) && !joinempty)) {
1882                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED);
1883                 } else if ((ast_false(option) && !joinempty) || (ast_true(option) && joinempty)) {
1884                         *empty = 0;
1885                 } else {
1886                         ast_log(LOG_WARNING, "Unknown option %s for '%s'\n", option, joinempty ? "joinempty" : "leavewhenempty");
1887                 }
1888         }
1889 }
1890
1891 /*! \brief Configure a queue parameter.
1892  * 
1893  * The failunknown flag is set for config files (and static realtime) to show
1894  * errors for unknown parameters. It is cleared for dynamic realtime to allow
1895  *  extra fields in the tables.
1896  * \note For error reporting, line number is passed for .conf static configuration,
1897  * for Realtime queues, linenum is -1.
1898 */
1899 static void queue_set_param(struct call_queue *q, const char *param, const char *val, int linenum, int failunknown)
1900 {
1901         if (!strcasecmp(param, "musicclass") || 
1902                 !strcasecmp(param, "music") || !strcasecmp(param, "musiconhold")) {
1903                 ast_string_field_set(q, moh, val);
1904         } else if (!strcasecmp(param, "announce")) {
1905                 ast_string_field_set(q, announce, val);
1906         } else if (!strcasecmp(param, "context")) {
1907                 ast_string_field_set(q, context, val);
1908         } else if (!strcasecmp(param, "timeout")) {
1909                 q->timeout = atoi(val);
1910                 if (q->timeout < 0)
1911                         q->timeout = DEFAULT_TIMEOUT;
1912         } else if (!strcasecmp(param, "ringinuse")) {
1913                 q->ringinuse = ast_true(val);
1914         } else if (!strcasecmp(param, "setinterfacevar")) {
1915                 q->setinterfacevar = ast_true(val);
1916         } else if (!strcasecmp(param, "setqueuevar")) {
1917                 q->setqueuevar = ast_true(val);
1918         } else if (!strcasecmp(param, "setqueueentryvar")) {
1919                 q->setqueueentryvar = ast_true(val);
1920         } else if (!strcasecmp(param, "monitor-format")) {
1921                 ast_copy_string(q->monfmt, val, sizeof(q->monfmt));
1922         } else if (!strcasecmp(param, "membermacro")) {
1923                 ast_string_field_set(q, membermacro, val);
1924         } else if (!strcasecmp(param, "membergosub")) {
1925                 ast_string_field_set(q, membergosub, val);
1926         } else if (!strcasecmp(param, "queue-youarenext")) {
1927                 ast_string_field_set(q, sound_next, val);
1928         } else if (!strcasecmp(param, "queue-thereare")) {
1929                 ast_string_field_set(q, sound_thereare, val);
1930         } else if (!strcasecmp(param, "queue-callswaiting")) {
1931                 ast_string_field_set(q, sound_calls, val);
1932         } else if (!strcasecmp(param, "queue-quantity1")) {
1933                 ast_string_field_set(q, queue_quantity1, val);
1934         } else if (!strcasecmp(param, "queue-quantity2")) {
1935                 ast_string_field_set(q, queue_quantity2, val);
1936         } else if (!strcasecmp(param, "queue-holdtime")) {
1937                 ast_string_field_set(q, sound_holdtime, val);
1938         } else if (!strcasecmp(param, "queue-minutes")) {
1939                 ast_string_field_set(q, sound_minutes, val);
1940         } else if (!strcasecmp(param, "queue-minute")) {
1941                 ast_string_field_set(q, sound_minute, val);
1942         } else if (!strcasecmp(param, "queue-seconds")) {
1943                 ast_string_field_set(q, sound_seconds, val);
1944         } else if (!strcasecmp(param, "queue-thankyou")) {
1945                 ast_string_field_set(q, sound_thanks, val);
1946         } else if (!strcasecmp(param, "queue-callerannounce")) {
1947                 ast_string_field_set(q, sound_callerannounce, val);
1948         } else if (!strcasecmp(param, "queue-reporthold")) {
1949                 ast_string_field_set(q, sound_reporthold, val);
1950         } else if (!strcasecmp(param, "announce-frequency")) {
1951                 q->announcefrequency = atoi(val);
1952         } else if (!strcasecmp(param, "min-announce-frequency")) {
1953                 q->minannouncefrequency = atoi(val);
1954                 ast_debug(1, "%s=%s for queue '%s'\n", param, val, q->name);
1955         } else if (!strcasecmp(param, "announce-round-seconds")) {
1956                 q->roundingseconds = atoi(val);
1957                 /* Rounding to any other values just doesn't make sense... */
1958                 if (!(q->roundingseconds == 0 || q->roundingseconds == 5 || q->roundingseconds == 10
1959                         || q->roundingseconds == 15 || q->roundingseconds == 20 || q->roundingseconds == 30)) {
1960                         if (linenum >= 0) {
1961                                 ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
1962                                         "using 0 instead for queue '%s' at line %d of queues.conf\n",
1963                                         val, param, q->name, linenum);
1964                         } else {
1965                                 ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
1966                                         "using 0 instead for queue '%s'\n", val, param, q->name);
1967                         }
1968                         q->roundingseconds=0;
1969                 }
1970         } else if (!strcasecmp(param, "announce-holdtime")) {
1971                 if (!strcasecmp(val, "once"))
1972                         q->announceholdtime = ANNOUNCEHOLDTIME_ONCE;
1973                 else if (ast_true(val))
1974                         q->announceholdtime = ANNOUNCEHOLDTIME_ALWAYS;
1975                 else
1976                         q->announceholdtime = 0;
1977         } else if (!strcasecmp(param, "announce-position")) {
1978                 if (!strcasecmp(val, "limit"))
1979                         q->announceposition = ANNOUNCEPOSITION_LIMIT;
1980                 else if (!strcasecmp(val, "more"))
1981                         q->announceposition = ANNOUNCEPOSITION_MORE_THAN;
1982                 else if (ast_true(val))
1983                         q->announceposition = ANNOUNCEPOSITION_YES;
1984                 else
1985                         q->announceposition = ANNOUNCEPOSITION_NO;
1986         } else if (!strcasecmp(param, "announce-position-limit")) {
1987                 q->announcepositionlimit = atoi(val);
1988         } else if (!strcasecmp(param, "periodic-announce")) {
1989                 if (strchr(val, ',')) {
1990                         char *s, *buf = ast_strdupa(val);
1991                         unsigned int i = 0;
1992
1993                         while ((s = strsep(&buf, ",|"))) {
1994                                 if (!q->sound_periodicannounce[i])
1995                                         q->sound_periodicannounce[i] = ast_str_create(16);
1996                                 ast_str_set(&q->sound_periodicannounce[i], 0, "%s", s);
1997                                 i++;
1998                                 if (i == MAX_PERIODIC_ANNOUNCEMENTS)
1999                                         break;
2000                         }
2001                         q->numperiodicannounce = i;
2002                 } else {
2003                         ast_str_set(&q->sound_periodicannounce[0], 0, "%s", val);
2004                         q->numperiodicannounce = 1;
2005                 }
2006         } else if (!strcasecmp(param, "periodic-announce-frequency")) {
2007                 q->periodicannouncefrequency = atoi(val);
2008         } else if (!strcasecmp(param, "relative-periodic-announce")) {
2009                 q->relativeperiodicannounce = ast_true(val);
2010         } else if (!strcasecmp(param, "random-periodic-announce")) {
2011                 q->randomperiodicannounce = ast_true(val);
2012         } else if (!strcasecmp(param, "retry")) {
2013                 q->retry = atoi(val);
2014                 if (q->retry <= 0)
2015                         q->retry = DEFAULT_RETRY;
2016         } else if (!strcasecmp(param, "wrapuptime")) {
2017                 q->wrapuptime = atoi(val);
2018         } else if (!strcasecmp(param, "penaltymemberslimit")) {
2019                 if ((sscanf(val, "%10d", &q->penaltymemberslimit) != 1)) {
2020                         q->penaltymemberslimit = 0;
2021                 }
2022         } else if (!strcasecmp(param, "autofill")) {
2023                 q->autofill = ast_true(val);
2024         } else if (!strcasecmp(param, "monitor-type")) {
2025                 if (!strcasecmp(val, "mixmonitor"))
2026                         q->montype = 1;
2027         } else if (!strcasecmp(param, "autopause")) {
2028                 q->autopause = autopause2int(val);
2029         } else if (!strcasecmp(param, "autopausedelay")) {
2030                 q->autopausedelay = atoi(val);
2031         } else if (!strcasecmp(param, "maxlen")) {
2032                 q->maxlen = atoi(val);
2033                 if (q->maxlen < 0)
2034                         q->maxlen = 0;
2035         } else if (!strcasecmp(param, "servicelevel")) {
2036                 q->servicelevel= atoi(val);
2037         } else if (!strcasecmp(param, "strategy")) {
2038                 int strategy;
2039
2040                 /* We are a static queue and already have set this, no need to do it again */
2041                 if (failunknown) {
2042                         return;
2043                 }
2044                 strategy = strat2int(val);
2045                 if (strategy < 0) {
2046                         ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
2047                                 val, q->name);
2048                         q->strategy = QUEUE_STRATEGY_RINGALL;
2049                 }
2050                 if (strategy == q->strategy) {
2051                         return;
2052                 }
2053                 if (strategy == QUEUE_STRATEGY_LINEAR) {
2054                         ast_log(LOG_WARNING, "Changing to the linear strategy currently requires asterisk to be restarted.\n");
2055                         return;
2056                 }
2057                 q->strategy = strategy;
2058         } else if (!strcasecmp(param, "joinempty")) {
2059                 parse_empty_options(val, &q->joinempty, 1);
2060         } else if (!strcasecmp(param, "leavewhenempty")) {
2061                 parse_empty_options(val, &q->leavewhenempty, 0);
2062         } else if (!strcasecmp(param, "eventmemberstatus")) {
2063                 q->maskmemberstatus = !ast_true(val);
2064         } else if (!strcasecmp(param, "eventwhencalled")) {
2065                 if (!strcasecmp(val, "vars")) {
2066                         q->eventwhencalled = QUEUE_EVENT_VARIABLES;
2067                 } else {
2068                         q->eventwhencalled = ast_true(val) ? 1 : 0;
2069                 }
2070         } else if (!strcasecmp(param, "reportholdtime")) {
2071                 q->reportholdtime = ast_true(val);
2072         } else if (!strcasecmp(param, "memberdelay")) {
2073                 q->memberdelay = atoi(val);
2074         } else if (!strcasecmp(param, "weight")) {
2075                 q->weight = atoi(val);
2076         } else if (!strcasecmp(param, "timeoutrestart")) {
2077                 q->timeoutrestart = ast_true(val);
2078         } else if (!strcasecmp(param, "defaultrule")) {
2079                 ast_string_field_set(q, defaultrule, val);
2080         } else if (!strcasecmp(param, "timeoutpriority")) {
2081                 if (!strcasecmp(val, "conf")) {
2082                         q->timeoutpriority = TIMEOUT_PRIORITY_CONF;
2083                 } else {
2084                         q->timeoutpriority = TIMEOUT_PRIORITY_APP;
2085                 }
2086         } else if (failunknown) {
2087                 if (linenum >= 0) {
2088                         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s at line %d of queues.conf\n",
2089                                 q->name, param, linenum);
2090                 } else {
2091                         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s\n", q->name, param);
2092                 }
2093         }
2094 }
2095
2096 /*!
2097  * \brief Find rt member record to update otherwise create one.
2098  *
2099  * Search for member in queue, if found update penalty/paused state,
2100  * if no member exists create one flag it as a RT member and add to queue member list.
2101 */
2102 static void rt_handle_member_record(struct call_queue *q, char *interface, struct ast_config *member_config)
2103 {
2104         struct member *m;
2105         struct ao2_iterator mem_iter;
2106         int penalty = 0;
2107         int paused  = 0;
2108         int found = 0;
2109         int ignorebusy = 0;
2110
2111         const char *config_val;
2112         const char *rt_uniqueid = ast_variable_retrieve(member_config, interface, "uniqueid");
2113         const char *membername = S_OR(ast_variable_retrieve(member_config, interface, "membername"), interface);
2114         const char *state_interface = S_OR(ast_variable_retrieve(member_config, interface, "state_interface"), interface);
2115         const char *penalty_str = ast_variable_retrieve(member_config, interface, "penalty");
2116         const char *paused_str = ast_variable_retrieve(member_config, interface, "paused");
2117
2118         if (ast_strlen_zero(rt_uniqueid)) {
2119                 ast_log(LOG_WARNING, "Realtime field uniqueid is empty for member %s\n", S_OR(membername, "NULL"));
2120                 return;
2121         }
2122
2123         if (penalty_str) {
2124                 penalty = atoi(penalty_str);
2125                 if ((penalty < 0) && negative_penalty_invalid) {
2126                         return;
2127                 } else if (penalty < 0) {
2128                         penalty = 0;
2129                 }
2130         }
2131
2132         if (paused_str) {
2133                 paused = atoi(paused_str);
2134                 if (paused < 0)
2135                         paused = 0;
2136         }
2137
2138         if ((config_val = ast_variable_retrieve(member_config, interface, "ignorebusy"))) {
2139                 ignorebusy = ast_true(config_val);
2140         } else {
2141                 ignorebusy = 1;
2142         }
2143
2144         /* Find member by realtime uniqueid and update */
2145         mem_iter = ao2_iterator_init(q->members, 0);
2146         while ((m = ao2_iterator_next(&mem_iter))) {
2147                 if (!strcasecmp(m->rt_uniqueid, rt_uniqueid)) {
2148                         m->dead = 0;    /* Do not delete this one. */
2149                         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
2150                         if (paused_str)
2151                                 m->paused = paused;
2152                         if (strcasecmp(state_interface, m->state_interface)) {
2153                                 ast_copy_string(m->state_interface, state_interface, sizeof(m->state_interface));
2154                         }
2155                         m->penalty = penalty;
2156                         m->ignorebusy = ignorebusy;
2157                         found = 1;
2158                         ao2_ref(m, -1);
2159                         break;
2160                 }
2161                 ao2_ref(m, -1);
2162         }
2163         ao2_iterator_destroy(&mem_iter);
2164
2165         /* Create a new member */
2166         if (!found) {
2167                 if ((m = create_queue_member(interface, membername, penalty, paused, state_interface))) {
2168                         m->dead = 0;
2169                         m->realtime = 1;
2170                         m->ignorebusy = ignorebusy;
2171                         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
2172                         ast_queue_log(q->name, "REALTIME", m->interface, "ADDMEMBER", "%s", "");
2173                         ao2_link(q->members, m);
2174                         ao2_ref(m, -1);
2175                         m = NULL;
2176                         q->membercount++;
2177                 }
2178         }
2179 }
2180
2181 /*! \brief Iterate through queue's member list and delete them */
2182 static void free_members(struct call_queue *q, int all)
2183 {
2184         /* Free non-dynamic members */
2185         struct member *cur;
2186         struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
2187
2188         while ((cur = ao2_iterator_next(&mem_iter))) {
2189                 if (all || !cur->dynamic) {
2190                         ao2_unlink(q->members, cur);
2191                         q->membercount--;
2192                 }
2193                 ao2_ref(cur, -1);
2194         }
2195         ao2_iterator_destroy(&mem_iter);
2196 }
2197
2198 /*! \brief Free queue's member list then its string fields */
2199 static void destroy_queue(void *obj)
2200 {
2201         struct call_queue *q = obj;
2202         int i;
2203
2204         free_members(q, 1);
2205         ast_string_field_free_memory(q);
2206         for (i = 0; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
2207                 if (q->sound_periodicannounce[i])
2208                         free(q->sound_periodicannounce[i]);
2209         }
2210         ao2_ref(q->members, -1);
2211 }
2212
2213 static struct call_queue *alloc_queue(const char *queuename)
2214 {
2215         struct call_queue *q;
2216
2217         if ((q = ao2_t_alloc(sizeof(*q), destroy_queue, "Allocate queue"))) {
2218                 if (ast_string_field_init(q, 64)) {
2219                         queue_t_unref(q, "String field allocation failed");
2220                         return NULL;
2221                 }
2222                 ast_string_field_set(q, name, queuename);
2223         }
2224         return q;
2225 }
2226
2227 /*!
2228  * \brief Reload a single queue via realtime.
2229  *
2230  * Check for statically defined queue first, check if deleted RT queue,
2231  * check for new RT queue, if queue vars are not defined init them with defaults.
2232  * reload RT queue vars, set RT queue members dead and reload them, return finished queue.
2233  * \retval the queue, 
2234  * \retval NULL if it doesn't exist.
2235  * \note Should be called with the "queues" container locked. 
2236 */
2237 static struct call_queue *find_queue_by_name_rt(const char *queuename, struct ast_variable *queue_vars, struct ast_config *member_config)
2238 {
2239         struct ast_variable *v;
2240         struct call_queue *q, tmpq = {
2241                 .name = queuename,      
2242         };
2243         struct member *m;
2244         struct ao2_iterator mem_iter;
2245         char *interface = NULL;
2246         const char *tmp_name;
2247         char *tmp;
2248         char tmpbuf[64];        /* Must be longer than the longest queue param name. */
2249
2250         /* Static queues override realtime. */
2251         if ((q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Check if static queue exists"))) {
2252                 ao2_lock(q);
2253                 if (!q->realtime) {
2254                         if (q->dead) {
2255                                 ao2_unlock(q);
2256                                 queue_t_unref(q, "Queue is dead; can't return it");
2257                                 return NULL;
2258                         } else {
2259                                 ast_log(LOG_WARNING, "Static queue '%s' already exists. Not loading from realtime\n", q->name);
2260                                 ao2_unlock(q);
2261                                 return q;
2262                         }
2263                 }
2264         } else if (!member_config)
2265                 /* Not found in the list, and it's not realtime ... */
2266                 return NULL;
2267
2268         /* Check if queue is defined in realtime. */
2269         if (!queue_vars) {
2270                 /* Delete queue from in-core list if it has been deleted in realtime. */
2271                 if (q) {
2272                         /*! \note Hmm, can't seem to distinguish a DB failure from a not
2273                            found condition... So we might delete an in-core queue
2274                            in case of DB failure. */
2275                         ast_debug(1, "Queue %s not found in realtime.\n", queuename);
2276
2277                         q->dead = 1;
2278                         /* Delete if unused (else will be deleted when last caller leaves). */
2279                         queues_t_unlink(queues, q, "Unused; removing from container");
2280                         ao2_unlock(q);
2281                         queue_t_unref(q, "Queue is dead; can't return it");
2282                 }
2283                 return NULL;
2284         }
2285
2286         /* Create a new queue if an in-core entry does not exist yet. */
2287         if (!q) {
2288                 struct ast_variable *tmpvar = NULL;
2289                 if (!(q = alloc_queue(queuename)))
2290                         return NULL;
2291                 ao2_lock(q);
2292                 clear_queue(q);
2293                 q->realtime = 1;
2294                 q->membercount = 0;
2295                 /*Before we initialize the queue, we need to set the strategy, so that linear strategy
2296                  * will allocate the members properly
2297                  */
2298                 for (tmpvar = queue_vars; tmpvar; tmpvar = tmpvar->next) {
2299                         if (!strcasecmp(tmpvar->name, "strategy")) {
2300                                 q->strategy = strat2int(tmpvar->value);
2301                                 if (q->strategy < 0) {
2302                                         ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
2303                                         tmpvar->value, q->name);
2304                                         q->strategy = QUEUE_STRATEGY_RINGALL;
2305                                 }
2306                                 break;
2307                         }
2308                 }
2309                 /* We traversed all variables and didn't find a strategy */
2310                 if (!tmpvar)
2311                         q->strategy = QUEUE_STRATEGY_RINGALL;
2312                 queues_t_link(queues, q, "Add queue to container");
2313         }
2314         init_queue(q);          /* Ensure defaults for all parameters not set explicitly. */
2315
2316         memset(tmpbuf, 0, sizeof(tmpbuf));
2317         for (v = queue_vars; v; v = v->next) {
2318                 /* Convert to dashes `-' from underscores `_' as the latter are more SQL friendly. */
2319                 if ((tmp = strchr(v->name, '_'))) {
2320                         ast_copy_string(tmpbuf, v->name, sizeof(tmpbuf));
2321                         tmp_name = tmpbuf;
2322                         tmp = tmpbuf;
2323                         while ((tmp = strchr(tmp, '_')))
2324                                 *tmp++ = '-';
2325                 } else
2326                         tmp_name = v->name;
2327
2328                 /* NULL values don't get returned from realtime; blank values should
2329                  * still get set.  If someone doesn't want a value to be set, they
2330                  * should set the realtime column to NULL, not blank. */
2331                 queue_set_param(q, tmp_name, v->value, -1, 0);
2332         }
2333
2334         /* Temporarily set realtime members dead so we can detect deleted ones. 
2335          * Also set the membercount correctly for realtime*/
2336         mem_iter = ao2_iterator_init(q->members, 0);
2337         while ((m = ao2_iterator_next(&mem_iter))) {
2338                 q->membercount++;
2339                 if (m->realtime)
2340                         m->dead = 1;
2341                 ao2_ref(m, -1);
2342         }
2343         ao2_iterator_destroy(&mem_iter);
2344
2345         while ((interface = ast_category_browse(member_config, interface))) {
2346                 rt_handle_member_record(q, interface, member_config);
2347         }
2348
2349         /* Delete all realtime members that have been deleted in DB. */
2350         mem_iter = ao2_iterator_init(q->members, 0);
2351         while ((m = ao2_iterator_next(&mem_iter))) {
2352                 if (m->dead) {
2353                         ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
2354                         ao2_unlink(q->members, m);
2355                         q->membercount--;
2356                 }
2357                 ao2_ref(m, -1);
2358         }
2359         ao2_iterator_destroy(&mem_iter);
2360
2361         ao2_unlock(q);
2362
2363         return q;
2364 }
2365
2366 static struct call_queue *load_realtime_queue(const char *queuename)
2367 {
2368         struct ast_variable *queue_vars;
2369         struct ast_config *member_config = NULL;
2370         struct call_queue *q = NULL, tmpq = {
2371                 .name = queuename,      
2372         };
2373         int prev_weight = 0;
2374
2375         /* Find the queue in the in-core list first. */
2376         q = ao2_t_find(queues, &tmpq, OBJ_POINTER, "Look for queue in memory first");
2377
2378         if (!q || q->realtime) {
2379                 /*! \note Load from realtime before taking the "queues" container lock, to avoid blocking all
2380                    queue operations while waiting for the DB.
2381
2382                    This will be two separate database transactions, so we might
2383                    see queue parameters as they were before another process
2384                    changed the queue and member list as it was after the change.
2385                    Thus we might see an empty member list when a queue is
2386                    deleted. In practise, this is unlikely to cause a problem. */
2387
2388                 queue_vars = ast_load_realtime("queues", "name", queuename, SENTINEL);
2389                 if (queue_vars) {
2390                         member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", queuename, SENTINEL);
2391                         if (!member_config) {
2392                                 ast_log(LOG_ERROR, "no queue_members defined in your config (extconfig.conf).\n");
2393                                 ast_variables_destroy(queue_vars);
2394                                 return NULL;
2395                         }
2396                 }
2397                 if (q) {
2398                         prev_weight = q->weight ? 1 : 0;
2399                 }
2400
2401                 ao2_lock(queues);
2402
2403                 q = find_queue_by_name_rt(queuename, queue_vars, member_config);
2404                 if (member_config) {
2405                         ast_config_destroy(member_config);
2406                 }
2407                 if (queue_vars) {
2408                         ast_variables_destroy(queue_vars);
2409                 }
2410                 /* update the use_weight value if the queue's has gained or lost a weight */ 
2411                 if (q) {
2412                         if (!q->weight && prev_weight) {
2413                                 ast_atomic_fetchadd_int(&use_weight, -1);
2414                         }
2415                         if (q->weight && !prev_weight) {
2416                                 ast_atomic_fetchadd_int(&use_weight, +1);
2417                         }
2418                 }
2419                 /* Other cases will end up with the proper value for use_weight */
2420                 ao2_unlock(queues);
2421
2422         } else {
2423                 update_realtime_members(q);
2424         }
2425         return q;
2426 }
2427
2428 static int update_realtime_member_field(struct member *mem, const char *queue_name, const char *field, const char *value)
2429 {
2430         int ret = -1;
2431
2432         if (ast_strlen_zero(mem->rt_uniqueid))
2433                 return ret;
2434
2435         if ((ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, field, value, SENTINEL)) > 0)
2436                 ret = 0;
2437
2438         return ret;
2439 }
2440
2441
2442 static void update_realtime_members(struct call_queue *q)
2443 {
2444         struct ast_config *member_config = NULL;
2445         struct member *m;
2446         char *interface = NULL;
2447         struct ao2_iterator mem_iter;
2448
2449         if (!(member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", q->name , SENTINEL))) {
2450                 /*This queue doesn't have realtime members*/
2451                 ast_debug(3, "Queue %s has no realtime members defined. No need for update\n", q->name);
2452                 return;
2453         }
2454
2455         ao2_lock(queues);
2456         ao2_lock(q);
2457         
2458         /* Temporarily set realtime  members dead so we can detect deleted ones.*/ 
2459         mem_iter = ao2_iterator_init(q->members, 0);
2460         while ((m = ao2_iterator_next(&mem_iter))) {
2461                 if (m->realtime)
2462                         m->dead = 1;
2463                 ao2_ref(m, -1);
2464         }
2465         ao2_iterator_destroy(&mem_iter);
2466
2467         while ((interface = ast_category_browse(member_config, interface))) {
2468                 rt_handle_member_record(q, interface, member_config);
2469         }
2470
2471         /* Delete all realtime members that have been deleted in DB. */
2472         mem_iter = ao2_iterator_init(q->members, 0);
2473         while ((m = ao2_iterator_next(&mem_iter))) {
2474                 if (m->dead) {
2475                         ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
2476                         ao2_unlink(q->members, m);
2477                         q->membercount--;
2478                 }
2479                 ao2_ref(m, -1);
2480         }
2481         ao2_iterator_destroy(&mem_iter);
2482         ao2_unlock(q);
2483         ao2_unlock(queues);
2484         ast_config_destroy(member_config);
2485 }
2486
2487 static int join_queue(char *queuename, struct queue_ent *qe, enum queue_result *reason, int position)
2488 {
2489         struct call_queue *q;
2490         struct queue_ent *cur, *prev = NULL;
2491         int res = -1;
2492         int pos = 0;
2493         int inserted = 0;
2494
2495         if (!(q = load_realtime_queue(queuename)))
2496                 return res;
2497
2498         ao2_lock(queues);
2499         ao2_lock(q);
2500
2501         /* This is our one */
2502         if (q->joinempty) {
2503                 int status = 0;
2504                 if ((status = get_member_status(q, qe->max_penalty, qe->min_penalty, q->joinempty))) {
2505                         *reason = QUEUE_JOINEMPTY;
2506                         ao2_unlock(q);
2507                         ao2_unlock(queues);
2508                         return res;
2509                 }
2510         }
2511         if (*reason == QUEUE_UNKNOWN && q->maxlen && (q->count >= q->maxlen))
2512                 *reason = QUEUE_FULL;
2513         else if (*reason == QUEUE_UNKNOWN) {
2514                 /* There's space for us, put us at the right position inside
2515                  * the queue.
2516                  * Take into account the priority of the calling user */
2517                 inserted = 0;
2518                 prev = NULL;
2519                 cur = q->head;
2520                 while (cur) {
2521                         /* We have higher priority than the current user, enter
2522                          * before him, after all the other users with priority
2523                          * higher or equal to our priority. */
2524                         if ((!inserted) && (qe->prio > cur->prio)) {
2525                                 insert_entry(q, prev, qe, &pos);
2526                                 inserted = 1;
2527                         }
2528                         /* <= is necessary for the position comparison because it may not be possible to enter
2529                          * at our desired position since higher-priority callers may have taken the position we want
2530                          */
2531                         if (!inserted && (qe->prio >= cur->prio) && position && (position <= pos + 1)) {
2532                                 insert_entry(q, prev, qe, &pos);
2533                                 /*pos is incremented inside insert_entry, so don't need to add 1 here*/
2534                                 if (position < pos) {
2535                                         ast_log(LOG_NOTICE, "Asked to be inserted at position %d but forced into position %d due to higher priority callers\n", position, pos);
2536                                 }
2537                                 inserted = 1;
2538                         }
2539                         cur->pos = ++pos;
2540                         prev = cur;
2541                         cur = cur->next;
2542                 }
2543                 /* No luck, join at the end of the queue */
2544                 if (!inserted)
2545                         insert_entry(q, prev, qe, &pos);
2546                 ast_copy_string(qe->moh, q->moh, sizeof(qe->moh));
2547                 ast_copy_string(qe->announce, q->announce, sizeof(qe->announce));
2548                 ast_copy_string(qe->context, q->context, sizeof(qe->context));
2549                 q->count++;
2550                 res = 0;
2551                 ast_manager_event(qe->chan, EVENT_FLAG_CALL, "Join",
2552                         "Channel: %s\r\n"
2553                         "CallerIDNum: %s\r\n"
2554                         "CallerIDName: %s\r\n"
2555                         "ConnectedLineNum: %s\r\n"
2556                         "ConnectedLineName: %s\r\n"
2557                         "Queue: %s\r\n"
2558                         "Position: %d\r\n"
2559                         "Count: %d\r\n"
2560                         "Uniqueid: %s\r\n",
2561                         qe->chan->name,
2562                         S_COR(qe->chan->caller.id.number.valid, qe->chan->caller.id.number.str, "unknown"),/* XXX somewhere else it is <unknown> */
2563                         S_COR(qe->chan->caller.id.name.valid, qe->chan->caller.id.name.str, "unknown"),
2564                         S_COR(qe->chan->connected.id.number.valid, qe->chan->connected.id.number.str, "unknown"),/* XXX somewhere else it is <unknown> */
2565                         S_COR(qe->chan->connected.id.name.valid, qe->chan->connected.id.name.str, "unknown"),
2566                         q->name, qe->pos, q->count, qe->chan->uniqueid );
2567                 ast_debug(1, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, qe->chan->name, qe->pos );
2568         }
2569         ao2_unlock(q);
2570         ao2_unlock(queues);
2571
2572         return res;
2573 }
2574
2575 static int play_file(struct ast_channel *chan, const char *filename)
2576 {
2577         int res;
2578
2579         if (ast_strlen_zero(filename)) {
2580                 return 0;
2581         }
2582
2583         if (!ast_fileexists(filename, NULL, chan->language)) {
2584                 return 0;
2585         }
2586
2587         ast_stopstream(chan);
2588
2589         res = ast_streamfile(chan, filename, chan->language);
2590         if (!res)
2591                 res = ast_waitstream(chan, AST_DIGIT_ANY);
2592
2593         ast_stopstream(chan);
2594
2595         return res;
2596 }
2597
2598 /*!
2599  * \brief Check for valid exit from queue via goto
2600  * \retval 0 if failure
2601  * \retval 1 if successful
2602 */
2603 static int valid_exit(struct queue_ent *qe, char digit)
2604 {
2605         int digitlen = strlen(qe->digits);
2606
2607         /* Prevent possible buffer overflow */
2608         if (digitlen < sizeof(qe->digits) - 2) {
2609                 qe->digits[digitlen] = digit;
2610                 qe->digits[digitlen + 1] = '\0';
2611         } else {
2612                 qe->digits[0] = '\0';
2613                 return 0;
2614         }
2615
2616         /* If there's no context to goto, short-circuit */
2617         if (ast_strlen_zero(qe->context))
2618                 return 0;
2619
2620         /* If the extension is bad, then reset the digits to blank */
2621         if (!ast_canmatch_extension(qe->chan, qe->context, qe->digits, 1,
2622                 S_COR(qe->chan->caller.id.number.valid, qe->chan->caller.id.number.str, NULL))) {
2623                 qe->digits[0] = '\0';
2624                 return 0;
2625         }
2626
2627         /* We have an exact match */
2628         if (!ast_goto_if_exists(qe->chan, qe->context, qe->digits, 1)) {
2629                 qe->valid_digits = 1;
2630                 /* Return 1 on a successful goto */
2631                 return 1;
2632         }
2633
2634         return 0;
2635 }
2636
2637 static int say_position(struct queue_ent *qe, int ringing)
2638 {
2639         int res = 0, avgholdmins, avgholdsecs, announceposition = 0;
2640         int say_thanks = 1;
2641         time_t now;
2642
2643         /* Let minannouncefrequency seconds pass between the start of each position announcement */
2644         time(&now);
2645         if ((now - qe->last_pos) < qe->parent->minannouncefrequency)
2646                 return 0;
2647
2648         /* If either our position has changed, or we are over the freq timer, say position */
2649         if ((qe->last_pos_said == qe->pos) && ((now - qe->last_pos) < qe->parent->announcefrequency))
2650                 return 0;
2651
2652         if (ringing) {
2653                 ast_indicate(qe->chan,-1);
2654         } else {
2655                 ast_moh_stop(qe->chan);
2656         }
2657
2658         if (qe->parent->announceposition == ANNOUNCEPOSITION_YES ||
2659                 qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN ||
2660                 (qe->parent->announceposition == ANNOUNCEPOSITION_LIMIT &&
2661                 qe->pos <= qe->parent->announcepositionlimit))
2662                         announceposition = 1;
2663
2664
2665         if (announceposition == 1) {
2666                 /* Say we're next, if we are */
2667                 if (qe->pos == 1) {
2668                         res = play_file(qe->chan, qe->parent->sound_next);
2669                         if (res)
2670                                 goto playout;
2671                         else
2672                                 goto posout;
2673                 } else {
2674                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
2675                                 /* More than Case*/
2676                                 res = play_file(qe->chan, qe->parent->queue_quantity1);
2677                                 if (res)
2678                                         goto playout;
2679                                 res = ast_say_number(qe->chan, qe->parent->announcepositionlimit, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
2680                                 if (res)
2681                                         goto playout;
2682                         } else {
2683                                 /* Normal Case */
2684                                 res = play_file(qe->chan, qe->parent->sound_thereare);
2685                                 if (res)
2686                                         goto playout;
2687                                 res = ast_say_number(qe->chan, qe->pos, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
2688                                 if (res)
2689                                         goto playout;
2690                         }
2691                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
2692                                 /* More than Case*/
2693                                 res = play_file(qe->chan, qe->parent->queue_quantity2);
2694                                 if (res)
2695                                         goto playout;
2696                         } else {
2697                                 res = play_file(qe->chan, qe->parent->sound_calls);
2698                                 if (res)
2699                                         goto playout;
2700                         }
2701                 }
2702         }
2703         /* Round hold time to nearest minute */
2704         avgholdmins = abs(((qe->parent->holdtime + 30) - (now - qe->start)) / 60);
2705
2706         /* If they have specified a rounding then round the seconds as well */
2707         if (qe->parent->roundingseconds) {
2708                 avgholdsecs = (abs(((qe->parent->holdtime + 30) - (now - qe->start))) - 60 * avgholdmins) / qe->parent->roundingseconds;
2709                 avgholdsecs *= qe->parent->roundingseconds;
2710         } else {
2711                 avgholdsecs = 0;
2712         }
2713
2714         ast_verb(3, "Hold time for %s is %d minute(s) %d seconds\n", qe->parent->name, avgholdmins, avgholdsecs);
2715
2716         /* If the hold time is >1 min, if it's enabled, and if it's not
2717            supposed to be only once and we have already said it, say it */
2718     if ((avgholdmins+avgholdsecs) > 0 && qe->parent->announceholdtime &&
2719         ((qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE && !qe->last_pos) ||
2720         !(qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE))) {
2721                 res = play_file(qe->chan, qe->parent->sound_holdtime);
2722                 if (res)
2723                         goto playout;
2724
2725                 if (avgholdmins >= 1) {
2726                         res = ast_say_number(qe->chan, avgholdmins, AST_DIGIT_ANY, qe->chan->language, NULL);
2727                         if (res)
2728                                 goto playout;
2729
2730                         if (avgholdmins == 1) {
2731                                 res = play_file(qe->chan, qe->parent->sound_minute);
2732                                 if (res)
2733                                         goto playout;
2734                         } else {
2735                                 res = play_file(qe->chan, qe->parent->sound_minutes);
2736                                 if (res)
2737                                         goto playout;
2738                         }
2739                 }
2740                 if (avgholdsecs >= 1) {
2741                         res = ast_say_number(qe->chan, avgholdsecs, AST_DIGIT_ANY, qe->chan->language, NULL);
2742                         if (res)
2743                                 goto playout;
2744
2745                         res = play_file(qe->chan, qe->parent->sound_seconds);
2746                         if (res)
2747                                 goto playout;
2748                 }
2749         } else if (qe->parent->announceholdtime && !qe->parent->announceposition) {
2750                 say_thanks = 0;
2751         }
2752
2753 posout:
2754         if (qe->parent->announceposition) {
2755                 ast_verb(3, "Told %s in %s their queue position (which was %d)\n",
2756                         qe->chan->name, qe->parent->name, qe->pos);
2757         }
2758         if (say_thanks) {
2759                 res = play_file(qe->chan, qe->parent->sound_thanks);
2760         }
2761 playout:
2762
2763         if ((res > 0 && !valid_exit(qe, res)))
2764                 res = 0;
2765
2766         /* Set our last_pos indicators */
2767         qe->last_pos = now;
2768         qe->last_pos_said = qe->pos;
2769
2770         /* Don't restart music on hold if we're about to exit the caller from the queue */
2771         if (!res) {
2772                 if (ringing) {
2773                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
2774                 } else {
2775                         ast_moh_start(qe->chan, qe->moh, NULL);
2776                 }
2777         }
2778         return res;
2779 }
2780
2781 static void recalc_holdtime(struct queue_ent *qe, int newholdtime)
2782 {
2783         int oldvalue;
2784
2785         /* Calculate holdtime using an exponential average */
2786         /* Thanks to SRT for this contribution */
2787         /* 2^2 (4) is the filter coefficient; a higher exponent would give old entries more weight */
2788
2789         ao2_lock(qe->parent);
2790         oldvalue = qe->parent->holdtime;
2791         qe->parent->holdtime = (((oldvalue << 2) - oldvalue) + newholdtime) >> 2;
2792         ao2_unlock(qe->parent);
2793 }
2794
2795 /*! \brief Caller leaving queue.
2796  * 
2797  * Search the queue to find the leaving client, if found remove from queue
2798  * create manager event, move others up the queue.
2799 */
2800 static void leave_queue(struct queue_ent *qe)
2801 {
2802         struct call_queue *q;
2803         struct queue_ent *current, *prev = NULL;
2804         struct penalty_rule *pr_iter;
2805         int pos = 0;
2806
2807         if (!(q = qe->parent))
2808                 return;
2809         queue_t_ref(q, "Copy queue pointer from queue entry");
2810         ao2_lock(q);
2811
2812         prev = NULL;
2813         for (current = q->head; current; current = current->next) {
2814                 if (current == qe) {
2815                         char posstr[20];
2816                         q->count--;
2817
2818                         /* Take us out of the queue */
2819                         ast_manager_event(qe->chan, EVENT_FLAG_CALL, "Leave",
2820                                 "Channel: %s\r\nQueue: %s\r\nCount: %d\r\nPosition: %d\r\nUniqueid: %s\r\n",
2821                                 qe->chan->name, q->name,  q->count, qe->pos, qe->chan->uniqueid);
2822                         ast_debug(1, "Queue '%s' Leave, Channel '%s'\n", q->name, qe->chan->name );
2823                         /* Take us out of the queue */
2824                         if (prev)
2825                                 prev->next = current->next;
2826                         else
2827                                 q->head = current->next;
2828                         /* Free penalty rules */
2829                         while ((pr_iter = AST_LIST_REMOVE_HEAD(&qe->qe_rules, list)))
2830                                 ast_free(pr_iter);
2831                         snprintf(posstr, sizeof(posstr), "%d", qe->pos);
2832                         pbx_builtin_setvar_helper(qe->chan, "QUEUEPOSITION", posstr);
2833                 } else {
2834                         /* Renumber the people after us in the queue based on a new count */
2835                         current->pos = ++pos;
2836                         prev = current;
2837                 }
2838         }
2839         ao2_unlock(q);
2840
2841         /*If the queue is a realtime queue, check to see if it's still defined in real time*/
2842         if (q->realtime) {
2843                 struct ast_variable *var;
2844                 if (!(var = ast_load_realtime("queues", "name", q->name, SENTINEL))) {
2845                         q->dead = 1;
2846                 } else {
2847                         ast_variables_destroy(var);
2848                 }
2849         }
2850
2851         if (q->dead) {  
2852                 /* It's dead and nobody is in it, so kill it */
2853                 queues_t_unlink(queues, q, "Queue is now dead; remove it from the container");
2854         }
2855         /* unref the explicit ref earlier in the function */
2856         queue_t_unref(q, "Expire copied reference");
2857 }
2858
2859 /*!
2860  * \internal
2861  * \brief Destroy the given callattempt structure and free it.
2862  * \since 1.8
2863  *
2864  * \param doomed callattempt structure to destroy.
2865  *
2866  * \return Nothing
2867  */
2868 static void callattempt_free(struct callattempt *doomed)
2869 {
2870         if (doomed->member) {
2871                 ao2_ref(doomed->member, -1);
2872         }
2873         ast_party_connected_line_free(&doomed->connected);
2874         ast_free(doomed);
2875 }
2876
2877 /*! \brief Hang up a list of outgoing calls */
2878 static void hangupcalls(struct callattempt *outgoing, struct ast_channel *exception, int cancel_answered_elsewhere)
2879 {
2880         struct callattempt *oo;
2881
2882         while (outgoing) {
2883                 /* If someone else answered the call we should indicate this in the CANCEL */
2884                 /* Hangup any existing lines we have open */
2885                 if (outgoing->chan && (outgoing->chan != exception)) {
2886                         if (exception || cancel_answered_elsewhere)
2887                                 ast_set_flag(outgoing->chan, AST_FLAG_ANSWERED_ELSEWHERE);
2888                         ast_hangup(outgoing->chan);
2889                 }
2890                 oo = outgoing;
2891                 outgoing = outgoing->q_next;
2892                 ast_aoc_destroy_decoded(oo->aoc_s_rate_list);
2893                 callattempt_free(oo);
2894         }
2895 }
2896
2897 /*!
2898  * \brief Get the number of members available to accept a call.
2899  *
2900  * \note The queue passed in should be locked prior to this function call
2901  *
2902  * \param[in] q The queue for which we are couting the number of available members
2903  * \return Return the number of available members in queue q
2904  */
2905 static int num_available_members(struct call_queue *q)
2906 {
2907         struct member *mem;
2908         int avl = 0;
2909         struct ao2_iterator mem_iter;
2910
2911         mem_iter = ao2_iterator_init(q->members, 0);
2912         while ((mem = ao2_iterator_next(&mem_iter))) {
2913                 switch (mem->status) {
2914                         case AST_DEVICE_INVALID:
2915                         case AST_DEVICE_UNAVAILABLE:
2916                                 break;
2917                         case AST_DEVICE_INUSE:
2918                         case AST_DEVICE_BUSY:
2919                         case AST_DEVICE_RINGING:
2920                         case AST_DEVICE_RINGINUSE:
2921                         case AST_DEVICE_ONHOLD:
2922                                 if ((!q->ringinuse) || (!mem->ignorebusy)) {
2923                                         break;
2924                                 }
2925                                 /* else fall through */
2926                         case AST_DEVICE_NOT_INUSE:
2927                         case AST_DEVICE_UNKNOWN:
2928                                 if (!mem->paused) {
2929                                         avl++;
2930                                 }
2931                                 break;
2932                 }
2933                 ao2_ref(mem, -1);
2934
2935                 /* If autofill is not enabled or if the queue's strategy is ringall, then
2936                  * we really don't care about the number of available members so much as we
2937                  * do that there is at least one available.
2938                  *
2939                  * In fact, we purposely will return from this function stating that only
2940                  * one member is available if either of those conditions hold. That way,
2941                  * functions which determine what action to take based on the number of available
2942                  * members will operate properly. The reasoning is that even if multiple
2943                  * members are available, only the head caller can actually be serviced.
2944                  */
2945                 if ((!q->autofill || q->strategy == QUEUE_STRATEGY_RINGALL) && avl) {
2946                         break;
2947                 }
2948         }
2949         ao2_iterator_destroy(&mem_iter);
2950
2951         return avl;
2952 }
2953
2954 /* traverse all defined queues which have calls waiting and contain this member
2955    return 0 if no other queue has precedence (higher weight) or 1 if found  */
2956 static int compare_weight(struct call_queue *rq, struct member *member)
2957 {
2958         struct call_queue *q;
2959         struct member *mem;
2960         int found = 0;
2961         struct ao2_iterator queue_iter;
2962         
2963         /* q's lock and rq's lock already set by try_calling()
2964          * to solve deadlock */
2965         queue_iter = ao2_iterator_init(queues, 0);
2966         while ((q = ao2_t_iterator_next(&queue_iter, "Iterate through queues"))) {
2967                 if (q == rq) { /* don't check myself, could deadlock */
2968                         queue_t_unref(q, "Done with iterator");
2969                         continue;
2970                 }
2971                 ao2_lock(q);
2972                 if (q->count && q->members) {
2973                         if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
2974                                 ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
2975                                 if (q->weight > rq->weight && q->count >= num_available_members(q)) {
2976                                         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);
2977                                         found = 1;
2978                                 }
2979                                 ao2_ref(mem, -1);
2980                         }
2981                 }
2982                 ao2_unlock(q);
2983                 queue_t_unref(q, "Done with iterator");
2984                 if (found) {
2985                         break;
2986                 }
2987         }
2988         ao2_iterator_destroy(&queue_iter);
2989         return found;
2990 }
2991
2992 /*! \brief common hangup actions */
2993 static void do_hang(struct callattempt *o)
2994 {
2995         o->stillgoing = 0;
2996         ast_hangup(o->chan);
2997         o->chan = NULL;
2998 }
2999
3000 /*! \brief convert "\n" to "\nVariable: " ready for manager to use */
3001 static char *vars2manager(struct ast_channel *chan, char *vars, size_t len)
3002 {
3003         struct ast_str *buf = ast_str_thread_get(&ast_str_thread_global_buf, len + 1);
3004         const char *tmp;
3005
3006         if (pbx_builtin_serialize_variables(chan, &buf)) {
3007                 int i, j;
3008
3009                 /* convert "\n" to "\nVariable: " */
3010                 strcpy(vars, "Variable: ");
3011                 tmp = ast_str_buffer(buf);
3012
3013                 for (i = 0, j = 10; (i < len - 1) && (j < len - 1); i++, j++) {
3014                         vars[j] = tmp[i];
3015
3016                         if (tmp[i + 1] == '\0')
3017                                 break;
3018                         if (tmp[i] == '\n') {
3019                                 vars[j++] = '\r';
3020                                 vars[j++] = '\n';
3021
3022                                 ast_copy_string(&(vars[j]), "Variable: ", len - j);
3023                                 j += 9;
3024                         }
3025                 }
3026                 if (j > len - 3)
3027                         j = len - 3;
3028                 vars[j++] = '\r';
3029                 vars[j++] = '\n';
3030                 vars[j] = '\0';
3031         } else {
3032                 /* there are no channel variables; leave it blank */
3033                 *vars = '\0';
3034         }
3035         return vars;
3036 }
3037
3038 /*! 
3039  * \brief Part 2 of ring_one
3040  *
3041  * Does error checking before attempting to request a channel and call a member. 
3042  * This function is only called from ring_one(). 
3043  * Failure can occur if:
3044  * - Agent on call
3045  * - Agent is paused
3046  * - Wrapup time not expired
3047  * - Priority by another queue
3048  *
3049  * \retval 1 on success to reach a free agent
3050  * \retval 0 on failure to get agent.
3051  */
3052 static int ring_entry(struct queue_ent *qe, struct callattempt *tmp, int *busies)
3053 {
3054         int res;
3055         int status;
3056         char tech[256];
3057         char *location;
3058         const char *macrocontext, *macroexten;
3059         enum ast_device_state newstate;
3060
3061         /* on entry here, we know that tmp->chan == NULL */
3062         if (tmp->member->paused) {
3063                 ast_debug(1, "%s paused, can't receive call\n", tmp->interface);
3064                 if (qe->chan->cdr) {
3065                         ast_cdr_busy(qe->chan->cdr);
3066                 }
3067                 tmp->stillgoing = 0;
3068                 return 0;
3069         }
3070
3071         if ((tmp->lastqueue && tmp->lastqueue->wrapuptime && (time(NULL) - tmp->lastcall < tmp->lastqueue->wrapuptime)) ||
3072                 (!tmp->lastqueue && qe->parent->wrapuptime && (time(NULL) - tmp->lastcall < qe->parent->wrapuptime))) {
3073                 ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n",
3074                                 (tmp->lastqueue ? tmp->lastqueue->name : qe->parent->name), tmp->interface);
3075                 if (qe->chan->cdr) {
3076                         ast_cdr_busy(qe->chan->cdr);
3077                 }
3078                 tmp->stillgoing = 0;
3079                 (*busies)++;
3080                 return 0;
3081         }
3082
3083         if (!qe->parent->ringinuse || !tmp->member->ignorebusy) {
3084                 if ((tmp->member->status == AST_DEVICE_UNKNOWN) || (tmp->member->status == AST_DEVICE_NOT_INUSE)) {
3085                         newstate = ast_parse_device_state(tmp->member->interface);
3086                         if (newstate != tmp->member->status) {
3087                                 ast_log(LOG_ERROR, "Found a channel matching iterface %s while status was %i changed to %i\n",
3088                                         tmp->member->interface, tmp->member->status, newstate);
3089                                 update_status(qe->parent, tmp->member, newstate);
3090                         }
3091                 }
3092                 if ((tmp->member->status != AST_DEVICE_NOT_INUSE) && (tmp->member->status != AST_DEVICE_UNKNOWN)) {
3093                         ast_debug(1, "%s in use, can't receive call\n", tmp->interface);
3094                         if (qe->chan->cdr) {
3095                                 ast_cdr_busy(qe->chan->cdr);
3096                         }
3097                         tmp->stillgoing = 0;
3098                         return 0;
3099                 }
3100         }
3101
3102         if (use_weight && compare_weight(qe->parent,tmp->member)) {
3103                 ast_debug(1, "Priority queue delaying call to %s:%s\n", qe->parent->name, tmp->interface);
3104                 if (qe->chan->cdr) {
3105                         ast_cdr_busy(qe->chan->cdr);
3106                 }
3107                 tmp->stillgoing = 0;
3108                 (*busies)++;
3109                 return 0;
3110         }
3111
3112         ast_copy_string(tech, tmp->interface, sizeof(tech));
3113         if ((location = strchr(tech, '/')))
3114                 *location++ = '\0';
3115         else
3116                 location = "";
3117
3118         /* Request the peer */
3119         tmp->chan = ast_request(tech, qe->chan->nativeformats, qe->chan, location, &status);
3120         if (!tmp->chan) {                       /* If we can't, just go on to the next call */
3121                 if (qe->chan->cdr) {
3122                         ast_cdr_busy(qe->chan->cdr);
3123                 }
3124                 tmp->stillgoing = 0;    
3125
3126                 ao2_lock(qe->parent);
3127                 update_status(qe->parent, tmp->member, get_queue_member_status(tmp->member));
3128                 qe->parent->rrpos++;
3129                 qe->linpos++;
3130                 ao2_unlock(qe->parent);
3131
3132                 (*busies)++;
3133                 return 0;
3134         }
3135
3136         ast_channel_lock(tmp->chan);
3137         while (ast_channel_trylock(qe->chan)) {
3138                 CHANNEL_DEADLOCK_AVOIDANCE(tmp->chan);
3139         }
3140
3141         if (qe->cancel_answered_elsewhere) {
3142                 ast_set_flag(tmp->chan, AST_FLAG_ANSWERED_ELSEWHERE);
3143         }
3144         tmp->chan->appl = "AppQueue";
3145         tmp->chan->data = "(Outgoing Line)";
3146         memset(&tmp->chan->whentohangup, 0, sizeof(tmp->chan->whentohangup));
3147
3148         /* If the new channel has no callerid, try to guess what it should be */
3149         if (!tmp->chan->caller.id.number.valid) {
3150                 if (qe->chan->connected.id.number.valid) {
3151                         struct ast_party_caller caller;
3152
3153                         ast_party_caller_set_init(&caller, &tmp->chan->caller);
3154                         caller.id = qe->chan->connected.id;
3155                         caller.ani = qe->chan->connected.ani;
3156                         ast_channel_set_caller_event(tmp->chan, &caller, NULL);
3157                 } else if (!ast_strlen_zero(qe->chan->dialed.number.str)) {
3158                         ast_set_callerid(tmp->chan, qe->chan->dialed.number.str, NULL, NULL);
3159                 } else if (!ast_strlen_zero(S_OR(qe->chan->macroexten, qe->chan->exten))) {
3160                         ast_set_callerid(tmp->chan, S_OR(qe->chan->macroexten, qe->chan->exten), NULL, NULL); 
3161                 }
3162                 tmp->dial_callerid_absent = 1;
3163         }
3164
3165         ast_party_redirecting_copy(&tmp->chan->redirecting, &qe->chan->redirecting);
3166
3167         tmp->chan->dialed.transit_network_select = qe->chan->dialed.transit_network_select;
3168
3169         ast_connected_line_copy_from_caller(&tmp->chan->connected, &qe->chan->caller);
3170
3171         /* Inherit specially named variables from parent channel */
3172         ast_channel_inherit_variables(qe->chan, tmp->chan);
3173         ast_channel_datastore_inherit(qe->chan, tmp->chan);
3174
3175         /* Presense of ADSI CPE on outgoing channel follows ours */
3176         tmp->chan->adsicpe = qe->chan->adsicpe;
3177
3178         /* Inherit context and extension */
3179         macrocontext = pbx_builtin_getvar_helper(qe->chan, "MACRO_CONTEXT");
3180         ast_string_field_set(tmp->chan, dialcontext, ast_strlen_zero(macrocontext) ? qe->chan->context : macrocontext);
3181         macroexten = pbx_builtin_getvar_helper(qe->chan, "MACRO_EXTEN");
3182         if (!ast_strlen_zero(macroexten))
3183                 ast_copy_string(tmp->chan->exten, macroexten, sizeof(tmp->chan->exten));
3184         else
3185                 ast_copy_string(tmp->chan->exten, qe->chan->exten, sizeof(tmp->chan->exten));
3186         if (ast_cdr_isset_unanswered()) {
3187                 /* they want to see the unanswered dial attempts! */
3188                 /* set up the CDR fields on all the CDRs to give sensical information */
3189                 ast_cdr_setdestchan(tmp->chan->cdr, tmp->chan->name);
3190                 strcpy(tmp->chan->cdr->clid, qe->chan->cdr->clid);
3191                 strcpy(tmp->chan->cdr->channel, qe->chan->cdr->channel);
3192                 strcpy(tmp->chan->cdr->src, qe->chan->cdr->src);
3193                 strcpy(tmp->chan->cdr->dst, qe->chan->exten);
3194                 strcpy(tmp->chan->cdr->dcontext, qe->chan->context);
3195                 strcpy(tmp->chan->cdr->lastapp, qe->chan->cdr->lastapp);
3196                 strcpy(tmp->chan->cdr->lastdata, qe->chan->cdr->lastdata);
3197                 tmp->chan->cdr->amaflags = qe->chan->cdr->amaflags;
3198                 strcpy(tmp->chan->cdr->accountcode, qe->chan->cdr->accountcode);
3199                 strcpy(tmp->chan->cdr->userfield, qe->chan->cdr->userfield);
3200         }
3201
3202         /* Place the call, but don't wait on the answer */
3203         if ((res = ast_call(tmp->chan, location, 0))) {
3204                 /* Again, keep going even if there's an error */
3205                 ast_debug(1, "ast call on peer returned %d\n", res);
3206                 ast_verb(3, "Couldn't call %s\n", tmp->interface);
3207                 ast_channel_unlock(tmp->chan);
3208                 ast_channel_unlock(qe->chan);
3209                 do_hang(tmp);
3210                 (*busies)++;
3211                 update_status(qe->parent, tmp->member, get_queue_member_status(tmp->member));
3212                 return 0;
3213         } else if (qe->parent->eventwhencalled) {
3214                 char vars[2048];
3215
3216                 manager_event(EVENT_FLAG_AGENT, "AgentCalled",
3217                         "Queue: %s\r\n"
3218                         "AgentCalled: %s\r\n"
3219                         "AgentName: %s\r\n"
3220                         "ChannelCalling: %s\r\n"
3221                         "DestinationChannel: %s\r\n"
3222                         "CallerIDNum: %s\r\n"
3223                         "CallerIDName: %s\r\n"
3224                         "ConnectedLineNum: %s\r\n"
3225                         "ConnectedLineName: %s\r\n"
3226                         "Context: %s\r\n"
3227                         "Extension: %s\r\n"
3228                         "Priority: %d\r\n"
3229                         "Uniqueid: %s\r\n"
3230                         "%s",
3231                         qe->parent->name, tmp->interface, tmp->member->membername, qe->chan->name, tmp->chan->name,
3232                         S_COR(tmp->chan->caller.id.number.valid, tmp->chan->caller.id.number.str, "unknown"),
3233                         S_COR(tmp->chan->caller.id.name.valid, tmp->chan->caller.id.name.str, "unknown"),
3234                         S_COR(tmp->chan->connected.id.number.valid, tmp->chan->connected.id.number.str, "unknown"),
3235                         S_COR(tmp->chan->connected.id.name.valid, tmp->chan->connected.id.name.str, "unknown"),
3236                         qe->chan->context, qe->chan->exten, qe->chan->priority, qe->chan->uniqueid,
3237                         qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
3238                 ast_verb(3, "Called %s\n", tmp->interface);
3239         }
3240         ast_channel_unlock(tmp->chan);
3241         ast_channel_unlock(qe->chan);
3242
3243         update_status(qe->parent, tmp->member, get_queue_member_status(tmp->member));
3244         return 1;
3245 }
3246
3247 /*! \brief find the entry with the best metric, or NULL */
3248 static struct callattempt *find_best(struct callattempt *outgoing)
3249 {
3250         struct callattempt *best = NULL, *cur;
3251
3252         for (cur = outgoing; cur; cur = cur->q_next) {
3253                 if (cur->stillgoing &&                                  /* Not already done */
3254                         !cur->chan &&                                   /* Isn't already going */
3255                         (!best || cur->metric < best->metric)) {                /* We haven't found one yet, or it's better */
3256                         best = cur;
3257                 }
3258         }
3259
3260         return best;
3261 }
3262
3263 /*! 
3264  * \brief Place a call to a queue member.
3265  *
3266  * Once metrics have been calculated for each member, this function is used
3267  * to place a call to the appropriate member (or members). The low-level
3268  * channel-handling and error detection is handled in ring_entry
3269  *
3270  * \retval 1 if a member was called successfully
3271  * \retval 0 otherwise
3272  */
3273 static int ring_one(struct queue_ent *qe, struct callattempt *outgoing, int *busies)
3274 {
3275         int ret = 0;
3276
3277         while (ret == 0) {
3278                 struct callattempt *best = find_best(outgoing);
3279                 if (!best) {
3280                         ast_debug(1, "Nobody left to try ringing in queue\n");
3281                         break;
3282                 }
3283                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
3284                         struct callattempt *cur;
3285                         /* Ring everyone who shares this best metric (for ringall) */
3286                         for (cur = outgoing; cur; cur = cur->q_next) {
3287                                 if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
3288                                         ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
3289                                         ret |= ring_entry(qe, cur, busies);
3290                                 }
3291                         }
3292                 } else {
3293                         /* Ring just the best channel */
3294                         ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
3295                         ret = ring_entry(qe, best, busies);
3296                 }
3297                 
3298                 /* If we have timed out, break out */
3299                 if (qe->expire && (time(NULL) >= qe->expire)) {
3300                         ast_debug(1, "Queue timed out while ringing members.\n");
3301                         ret = 0;
3302                         break;
3303                 }
3304         }
3305
3306         return ret;
3307 }
3308
3309 /*! \brief Search for best metric and add to Round Robbin queue */
3310 static int store_next_rr(struct queue_ent *qe, struct callattempt *outgoing)
3311 {
3312         struct callattempt *best = find_best(outgoing);
3313
3314         if (best) {
3315                 /* Ring just the best channel */
3316                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
3317                 qe->parent->rrpos = best->metric % 1000;
3318         } else {
3319                 /* Just increment rrpos */
3320                 if (qe->parent->wrapped) {
3321                         /* No more channels, start over */
3322                         qe->parent->rrpos = 0;
3323                 } else {
3324                         /* Prioritize next entry */
3325                         qe->parent->rrpos++;
3326                 }
3327         }
3328         qe->parent->wrapped = 0;
3329
3330         return 0;
3331 }
3332
3333 /*! \brief Search for best metric and add to Linear queue */
3334 static int store_next_lin(struct queue_ent *qe, struct ca