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