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