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