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