Merged revisions 168628 via svnmerge from
[asterisk/asterisk.git] / apps / app_queue.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief True call queues with optional send URL on answer
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \arg Config in \ref Config_qu queues.conf
26  *
27  * \par Development notes
28  * \note 2004-11-25: Persistent Dynamic Members added by:
29  *             NetNation Communications (www.netnation.com)
30  *             Kevin Lindsay <kevinl@netnation.com>
31  *
32  *             Each dynamic agent in each queue is now stored in the astdb.
33  *             When asterisk is restarted, each agent will be automatically
34  *             readded into their recorded queues. This feature can be
35  *             configured with the 'persistent_members=<1|0>' setting in the
36  *             '[general]' category in queues.conf. The default is on.
37  *
38  * \note 2004-06-04: Priorities in queues added by inAccess Networks (work funded by Hellas On Line (HOL) www.hol.gr).
39  *
40  * \note These features added by David C. Troy <dave@toad.net>:
41  *    - Per-queue holdtime calculation
42  *    - Estimated holdtime announcement
43  *    - Position announcement
44  *    - Abandoned/completed call counters
45  *    - Failout timer passed as optional app parameter
46  *    - Optional monitoring of calls, started when call is answered
47  *
48  * Patch Version 1.07 2003-12-24 01
49  *
50  * Added servicelevel statistic by Michiel Betel <michiel@betel.nl>
51  * Added Priority jumping code for adding and removing queue members by Jonathan Stanton <asterisk@doilooklikeicare.com>
52  *
53  * Fixed to work with CVS as of 2004-02-25 and released as 1.07a
54  * by Matthew Enger <m.enger@xi.com.au>
55  *
56  * \ingroup applications
57  */
58
59 /*** MODULEINFO
60         <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 queue_ent *qe)
879 {
880         char interfacevar[256]="";
881         float sl = 0;
882
883         if (qe->parent->setqueuevar) {
884                 sl = 0;
885                 if (qe->parent->callscompleted > 0) 
886                         sl = 100 * ((float) qe->parent->callscompletedinsl / (float) qe->parent->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                         qe->parent->name, qe->parent->maxlen, int2strat(qe->parent->strategy), qe->parent->count, qe->parent->holdtime, qe->parent->talktime, qe->parent->callscompleted,
891                         qe->parent->callsabandoned,  qe->parent->servicelevel, sl);
892         
893                 pbx_builtin_setvar_multiple(qe->chan, interfacevar); 
894         }
895 }
896
897 /*! \brief Insert the 'new' entry after the 'prev' entry of queue 'q' */
898 static inline void insert_entry(struct call_queue *q, struct queue_ent *prev, struct queue_ent *new, int *pos)
899 {
900         struct queue_ent *cur;
901
902         if (!q || !new)
903                 return;
904         if (prev) {
905                 cur = prev->next;
906                 prev->next = new;
907         } else {
908                 cur = q->head;
909                 q->head = new;
910         }
911         new->next = cur;
912         new->parent = q;
913         new->pos = ++(*pos);
914         new->opos = *pos;
915 }
916
917 /*! \brief Check if members are available
918  *
919  * This function checks to see if members are available to be called. If any member
920  * is available, the function immediately returns 0. If no members are available,
921  * then -1 is returned.
922  */
923 static int get_member_status(struct call_queue *q, int max_penalty, int min_penalty, enum empty_conditions conditions)
924 {
925         struct member *member;
926         struct ao2_iterator mem_iter;
927
928         ao2_lock(q);
929         mem_iter = ao2_iterator_init(q->members, 0);
930         for (; (member = ao2_iterator_next(&mem_iter)); ao2_ref(member, -1)) {
931                 if ((max_penalty && (member->penalty > max_penalty)) || (min_penalty && (member->penalty < min_penalty))) {
932                         if (conditions & QUEUE_EMPTY_PENALTY) {
933                                 ast_debug(4, "%s is unavailable because his penalty is not between %d and %d\n", member->membername, min_penalty, max_penalty);
934                                 continue;
935                         }
936                 }
937
938                 switch (member->status) {
939                 case AST_DEVICE_INVALID:
940                         if (conditions & QUEUE_EMPTY_INVALID) {
941                                 ast_debug(4, "%s is unavailable because his device state is 'invalid'\n", member->membername);
942                                 break;
943                         }
944                 case AST_DEVICE_UNAVAILABLE:
945                         if (conditions & QUEUE_EMPTY_UNAVAILABLE) {
946                                 ast_debug(4, "%s is unavailable because his device state is 'unavailable'\n", member->membername);
947                                 break;
948                         }
949                 case AST_DEVICE_INUSE:
950                         if (conditions & QUEUE_EMPTY_INUSE) {
951                                 ast_debug(4, "%s is unavailable because his device state is 'inuse'\n", member->membername);
952                                 break;
953                         }
954                 case AST_DEVICE_UNKNOWN:
955                         if (conditions & QUEUE_EMPTY_UNKNOWN) {
956                                 ast_debug(4, "%s is unavailable because his device state is 'unknown'\n", member->membername);
957                                 break;
958                         }
959                 default:
960                         if (member->paused && (conditions & QUEUE_EMPTY_PAUSED)) {
961                                 ast_debug(4, "%s is unavailable because he is paused'\n", member->membername);
962                                 break;
963                         } else if ((conditions & QUEUE_EMPTY_WRAPUP) && member->lastcall && q->wrapuptime && (time(NULL) - q->wrapuptime < member->lastcall)) {
964                                 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);
965                                 break;
966                         } else {
967                                 ao2_unlock(q);
968                                 ao2_ref(member, -1);
969                                 ast_debug(4, "%s is available.\n", member->membername);
970                                 return 0;
971                         }
972                         break;
973                 }
974         }
975
976         ao2_unlock(q);
977         return -1;
978 }
979
980 struct statechange {
981         AST_LIST_ENTRY(statechange) entry;
982         int state;
983         char dev[0];
984 };
985
986 /*! \brief set a member's status based on device state of that member's state_interface.
987  *  
988  * Lock interface list find sc, iterate through each queues queue_member list for member to
989  * update state inside queues
990 */
991 static int update_status(struct call_queue *q, struct member *m, const int status)
992 {
993         m->status = status;
994
995         if (q->maskmemberstatus)
996                 return 0;
997
998         manager_event(EVENT_FLAG_AGENT, "QueueMemberStatus",
999                 "Queue: %s\r\n"
1000                 "Location: %s\r\n"
1001                 "MemberName: %s\r\n"
1002                 "Membership: %s\r\n"
1003                 "Penalty: %d\r\n"
1004                 "CallsTaken: %d\r\n"
1005                 "LastCall: %d\r\n"
1006                 "Status: %d\r\n"
1007                 "Paused: %d\r\n",
1008                 q->name, m->interface, m->membername, m->dynamic ? "dynamic" : m->realtime ? "realtime" : "static",
1009                 m->penalty, m->calls, (int)m->lastcall, m->status, m->paused
1010         );
1011
1012         return 0;
1013 }
1014
1015 /*! \brief set a member's status based on device state of that member's interface*/
1016 static int handle_statechange(void *datap)
1017 {
1018         struct statechange *sc = datap;
1019         struct ao2_iterator miter, qiter;
1020         struct member *m;
1021         struct call_queue *q;
1022         char interface[80], *slash_pos;
1023         int found = 0;
1024
1025         qiter = ao2_iterator_init(queues, 0);
1026
1027         while ((q = ao2_iterator_next(&qiter))) {
1028                 ao2_lock(q);
1029
1030                 miter = ao2_iterator_init(q->members, 0);
1031                 for (; (m = ao2_iterator_next(&miter)); ao2_ref(m, -1)) {
1032                         ast_copy_string(interface, m->state_interface, sizeof(interface));
1033
1034                         if ((slash_pos = strchr(interface, '/')))
1035                                 if ((slash_pos = strchr(slash_pos + 1, '/')))
1036                                         *slash_pos = '\0';
1037
1038                         if (!strcasecmp(interface, sc->dev)) {
1039                                 found = 1;
1040                                 update_status(q, m, sc->state);
1041                                 ao2_ref(m, -1);
1042                                 break;
1043                         }
1044                 }
1045
1046                 ao2_unlock(q);
1047         }
1048
1049         if (found)
1050                 ast_debug(1, "Device '%s' changed to state '%d' (%s)\n", sc->dev, sc->state, ast_devstate2str(sc->state));
1051         else
1052                 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));
1053
1054         ast_free(sc);
1055         return 0;
1056 }
1057
1058 static void device_state_cb(const struct ast_event *event, void *unused)
1059 {
1060         enum ast_device_state state;
1061         const char *device;
1062         struct statechange *sc;
1063         size_t datapsize;
1064
1065         state = ast_event_get_ie_uint(event, AST_EVENT_IE_STATE);
1066         device = ast_event_get_ie_str(event, AST_EVENT_IE_DEVICE);
1067
1068         if (ast_strlen_zero(device)) {
1069                 ast_log(LOG_ERROR, "Received invalid event that had no device IE\n");
1070                 return;
1071         }
1072         datapsize = sizeof(*sc) + strlen(device) + 1;
1073         if (!(sc = ast_calloc(1, datapsize))) {
1074                 ast_log(LOG_ERROR, "failed to calloc a state change struct\n");
1075                 return;
1076         }
1077         sc->state = state;
1078         strcpy(sc->dev, device);
1079         if (ast_taskprocessor_push(devicestate_tps, handle_statechange, sc) < 0) {
1080                 ast_free(sc);
1081         }
1082 }
1083
1084 /*! \brief allocate space for new queue member and set fields based on parameters passed */
1085 static struct member *create_queue_member(const char *interface, const char *membername, int penalty, int paused, const char *state_interface)
1086 {
1087         struct member *cur;
1088         
1089         if ((cur = ao2_alloc(sizeof(*cur), NULL))) {
1090                 cur->penalty = penalty;
1091                 cur->paused = paused;
1092                 ast_copy_string(cur->interface, interface, sizeof(cur->interface));
1093                 if (!ast_strlen_zero(state_interface))
1094                         ast_copy_string(cur->state_interface, state_interface, sizeof(cur->state_interface));
1095                 else
1096                         ast_copy_string(cur->state_interface, interface, sizeof(cur->state_interface));
1097                 if (!ast_strlen_zero(membername))
1098                         ast_copy_string(cur->membername, membername, sizeof(cur->membername));
1099                 else
1100                         ast_copy_string(cur->membername, interface, sizeof(cur->membername));
1101                 if (!strchr(cur->interface, '/'))
1102                         ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
1103                 cur->status = ast_device_state(cur->state_interface);
1104         }
1105
1106         return cur;
1107 }
1108
1109
1110 static int compress_char(const char c)
1111 {
1112         if (c < 32)
1113                 return 0;
1114         else if (c > 96)
1115                 return c - 64;
1116         else
1117                 return c - 32;
1118 }
1119
1120 static int member_hash_fn(const void *obj, const int flags)
1121 {
1122         const struct member *mem = obj;
1123         const char *chname = strchr(mem->interface, '/');
1124         int ret = 0, i;
1125         if (!chname)
1126                 chname = mem->interface;
1127         for (i = 0; i < 5 && chname[i]; i++)
1128                 ret += compress_char(chname[i]) << (i * 6);
1129         return ret;
1130 }
1131
1132 static int member_cmp_fn(void *obj1, void *obj2, int flags)
1133 {
1134         struct member *mem1 = obj1, *mem2 = obj2;
1135         return strcasecmp(mem1->interface, mem2->interface) ? 0 : CMP_MATCH | CMP_STOP;
1136 }
1137
1138 /*! 
1139  * \brief Initialize Queue default values.
1140  * \note the queue's lock  must be held before executing this function
1141 */
1142 static void init_queue(struct call_queue *q)
1143 {
1144         int i;
1145         struct penalty_rule *pr_iter;
1146
1147         q->dead = 0;
1148         q->retry = DEFAULT_RETRY;
1149         q->timeout = -1;
1150         q->maxlen = 0;
1151         q->announcefrequency = 0;
1152         q->minannouncefrequency = DEFAULT_MIN_ANNOUNCE_FREQUENCY;
1153         q->announceholdtime = 1;
1154         q->announcepositionlimit = 10; /* Default 10 positions */
1155         q->announceposition = ANNOUNCEPOSITION_YES; /* Default yes */
1156         q->roundingseconds = 0; /* Default - don't announce seconds */
1157         q->servicelevel = 0;
1158         q->ringinuse = 1;
1159         q->setinterfacevar = 0;
1160         q->setqueuevar = 0;
1161         q->setqueueentryvar = 0;
1162         q->autofill = autofill_default;
1163         q->montype = montype_default;
1164         q->monfmt[0] = '\0';
1165         q->reportholdtime = 0;
1166         q->wrapuptime = 0;
1167         q->joinempty = 0;
1168         q->leavewhenempty = 0;
1169         q->memberdelay = 0;
1170         q->maskmemberstatus = 0;
1171         q->eventwhencalled = 0;
1172         q->weight = 0;
1173         q->timeoutrestart = 0;
1174         q->periodicannouncefrequency = 0;
1175         q->randomperiodicannounce = 0;
1176         q->numperiodicannounce = 0;
1177         q->timeoutpriority = TIMEOUT_PRIORITY_APP;
1178         if (!q->members) {
1179                 if (q->strategy == QUEUE_STRATEGY_LINEAR)
1180                         /* linear strategy depends on order, so we have to place all members in a single bucket */
1181                         q->members = ao2_container_alloc(1, member_hash_fn, member_cmp_fn);
1182                 else
1183                         q->members = ao2_container_alloc(37, member_hash_fn, member_cmp_fn);
1184         }
1185         q->membercount = 0;
1186         q->found = 1;
1187
1188         ast_string_field_set(q, sound_next, "queue-youarenext");
1189         ast_string_field_set(q, sound_thereare, "queue-thereare");
1190         ast_string_field_set(q, sound_calls, "queue-callswaiting");
1191         ast_string_field_set(q, queue_quantity1, "queue-quantity1");
1192         ast_string_field_set(q, queue_quantity2, "queue-quantity2");
1193         ast_string_field_set(q, sound_holdtime, "queue-holdtime");
1194         ast_string_field_set(q, sound_minutes, "queue-minutes");
1195         ast_string_field_set(q, sound_minute, "queue-minute");
1196         ast_string_field_set(q, sound_seconds, "queue-seconds");
1197         ast_string_field_set(q, sound_thanks, "queue-thankyou");
1198         ast_string_field_set(q, sound_reporthold, "queue-reporthold");
1199
1200         if ((q->sound_periodicannounce[0] = ast_str_create(32)))
1201                 ast_str_set(&q->sound_periodicannounce[0], 0, "queue-periodic-announce");
1202
1203         for (i = 1; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
1204                 if (q->sound_periodicannounce[i])
1205                         ast_str_set(&q->sound_periodicannounce[i], 0, "%s", "");
1206         }
1207
1208         while ((pr_iter = AST_LIST_REMOVE_HEAD(&q->rules,list)))
1209                 ast_free(pr_iter);
1210 }
1211
1212 static void clear_queue(struct call_queue *q)
1213 {
1214         q->holdtime = 0;
1215         q->callscompleted = 0;
1216         q->callsabandoned = 0;
1217         q->callscompletedinsl = 0;
1218         q->wrapuptime = 0;
1219 }
1220
1221 /*! 
1222  * \brief Change queue penalty by adding rule.
1223  *
1224  * Check rule for errors with time or fomatting, see if rule is relative to rest 
1225  * of queue, iterate list of rules to find correct insertion point, insert and return.
1226  * \retval -1 on failure
1227  * \retval 0 on success 
1228  * \note Call this with the rule_lists locked 
1229 */
1230 static int insert_penaltychange (const char *list_name, const char *content, const int linenum)
1231 {
1232         char *timestr, *maxstr, *minstr, *contentdup;
1233         struct penalty_rule *rule = NULL, *rule_iter;
1234         struct rule_list *rl_iter;
1235         int penaltychangetime, inserted = 0;
1236
1237         if (!(rule = ast_calloc(1, sizeof(*rule)))) {
1238                 ast_log(LOG_ERROR, "Cannot allocate memory for penaltychange rule at line %d!\n", linenum);
1239                 return -1;
1240         }
1241
1242         contentdup = ast_strdupa(content);
1243         
1244         if (!(maxstr = strchr(contentdup, ','))) {
1245                 ast_log(LOG_WARNING, "Improperly formatted penaltychange rule at line %d. Ignoring.\n", linenum);
1246                 ast_free(rule);
1247                 return -1;
1248         }
1249
1250         *maxstr++ = '\0';
1251         timestr = contentdup;
1252
1253         if ((penaltychangetime = atoi(timestr)) < 0) {
1254                 ast_log(LOG_WARNING, "Improper time parameter specified for penaltychange rule at line %d. Ignoring.\n", linenum);
1255                 ast_free(rule);
1256                 return -1;
1257         }
1258
1259         rule->time = penaltychangetime;
1260
1261         if ((minstr = strchr(maxstr,',')))
1262                 *minstr++ = '\0';
1263         
1264         /* The last check will evaluate true if either no penalty change is indicated for a given rule
1265          * OR if a min penalty change is indicated but no max penalty change is */
1266         if (*maxstr == '+' || *maxstr == '-' || *maxstr == '\0') {
1267                 rule->max_relative = 1;
1268         }
1269
1270         rule->max_value = atoi(maxstr);
1271
1272         if (!ast_strlen_zero(minstr)) {
1273                 if (*minstr == '+' || *minstr == '-')
1274                         rule->min_relative = 1;
1275                 rule->min_value = atoi(minstr);
1276         } else /*there was no minimum specified, so assume this means no change*/
1277                 rule->min_relative = 1;
1278
1279         /*We have the rule made, now we need to insert it where it belongs*/
1280         AST_LIST_TRAVERSE(&rule_lists, rl_iter, list){
1281                 if (strcasecmp(rl_iter->name, list_name))
1282                         continue;
1283
1284                 AST_LIST_TRAVERSE_SAFE_BEGIN(&rl_iter->rules, rule_iter, list) {
1285                         if (rule->time < rule_iter->time) {
1286                                 AST_LIST_INSERT_BEFORE_CURRENT(rule, list);
1287                                 inserted = 1;
1288                                 break;
1289                         }
1290                 }
1291                 AST_LIST_TRAVERSE_SAFE_END;
1292         
1293                 if (!inserted) {
1294                         AST_LIST_INSERT_TAIL(&rl_iter->rules, rule, list);
1295                 }
1296         }
1297
1298         return 0;
1299 }
1300
1301 static void parse_empty_options(const char *value, enum empty_conditions *empty)
1302 {
1303         char *value_copy = ast_strdupa(value);
1304         char *option = NULL;
1305         while ((option = strsep(&value_copy, ","))) {
1306                 if (!strcasecmp(option, "paused")) {
1307                         *empty |= QUEUE_EMPTY_PAUSED;
1308                 } else if (!strcasecmp(option, "penalty")) {
1309                         *empty |= QUEUE_EMPTY_PENALTY;
1310                 } else if (!strcasecmp(option, "inuse")) {
1311                         *empty |= QUEUE_EMPTY_INUSE;
1312                 } else if (!strcasecmp(option, "ringing")) {
1313                         *empty |= QUEUE_EMPTY_RINGING;
1314                 } else if (!strcasecmp(option, "invalid")) {
1315                         *empty |= QUEUE_EMPTY_INVALID;
1316                 } else if (!strcasecmp(option, "wrapup")) {
1317                         *empty |= QUEUE_EMPTY_WRAPUP;
1318                 } else if (!strcasecmp(option, "unavailable")) {
1319                         *empty |= QUEUE_EMPTY_UNAVAILABLE;
1320                 } else if (!strcasecmp(option, "unknown")) {
1321                         *empty |= QUEUE_EMPTY_UNKNOWN;
1322                 } else if (!strcasecmp(option, "loose")) {
1323                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID);
1324                 } else if (!strcasecmp(option, "strict")) {
1325                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED | QUEUE_EMPTY_UNAVAILABLE);
1326                 } else if (ast_false(option)) {
1327                         *empty = (QUEUE_EMPTY_PENALTY | QUEUE_EMPTY_INVALID | QUEUE_EMPTY_PAUSED);
1328                 } else if (ast_true(option)) {
1329                         *empty = 0;
1330                 }
1331         }
1332 }
1333
1334 /*! \brief Configure a queue parameter.
1335  * 
1336  * The failunknown flag is set for config files (and static realtime) to show
1337  * errors for unknown parameters. It is cleared for dynamic realtime to allow
1338  *  extra fields in the tables.
1339  * \note For error reporting, line number is passed for .conf static configuration,
1340  * for Realtime queues, linenum is -1.
1341 */
1342 static void queue_set_param(struct call_queue *q, const char *param, const char *val, int linenum, int failunknown)
1343 {
1344         if (!strcasecmp(param, "musicclass") || 
1345                 !strcasecmp(param, "music") || !strcasecmp(param, "musiconhold")) {
1346                 ast_string_field_set(q, moh, val);
1347         } else if (!strcasecmp(param, "announce")) {
1348                 ast_string_field_set(q, announce, val);
1349         } else if (!strcasecmp(param, "context")) {
1350                 ast_string_field_set(q, context, val);
1351         } else if (!strcasecmp(param, "timeout")) {
1352                 q->timeout = atoi(val);
1353                 if (q->timeout < 0)
1354                         q->timeout = DEFAULT_TIMEOUT;
1355         } else if (!strcasecmp(param, "ringinuse")) {
1356                 q->ringinuse = ast_true(val);
1357         } else if (!strcasecmp(param, "setinterfacevar")) {
1358                 q->setinterfacevar = ast_true(val);
1359         } else if (!strcasecmp(param, "setqueuevar")) {
1360                 q->setqueuevar = ast_true(val);
1361         } else if (!strcasecmp(param, "setqueueentryvar")) {
1362                 q->setqueueentryvar = ast_true(val);
1363         } else if (!strcasecmp(param, "monitor-format")) {
1364                 ast_copy_string(q->monfmt, val, sizeof(q->monfmt));
1365         } else if (!strcasecmp(param, "membermacro")) {
1366                 ast_string_field_set(q, membermacro, val);
1367         } else if (!strcasecmp(param, "membergosub")) {
1368                 ast_string_field_set(q, membergosub, val);
1369         } else if (!strcasecmp(param, "queue-youarenext")) {
1370                 ast_string_field_set(q, sound_next, val);
1371         } else if (!strcasecmp(param, "queue-thereare")) {
1372                 ast_string_field_set(q, sound_thereare, val);
1373         } else if (!strcasecmp(param, "queue-callswaiting")) {
1374                 ast_string_field_set(q, sound_calls, val);
1375         } else if (!strcasecmp(param, "queue-quantity1")) {
1376                 ast_string_field_set(q, queue_quantity1, val);
1377         } else if (!strcasecmp(param, "queue-quantity2")) {
1378                 ast_string_field_set(q, queue_quantity2, val);
1379         } else if (!strcasecmp(param, "queue-holdtime")) {
1380                 ast_string_field_set(q, sound_holdtime, val);
1381         } else if (!strcasecmp(param, "queue-minutes")) {
1382                 ast_string_field_set(q, sound_minutes, val);
1383         } else if (!strcasecmp(param, "queue-minute")) {
1384                 ast_string_field_set(q, sound_minute, val);
1385         } else if (!strcasecmp(param, "queue-seconds")) {
1386                 ast_string_field_set(q, sound_seconds, val);
1387         } else if (!strcasecmp(param, "queue-thankyou")) {
1388                 ast_string_field_set(q, sound_thanks, val);
1389         } else if (!strcasecmp(param, "queue-callerannounce")) {
1390                 ast_string_field_set(q, sound_callerannounce, val);
1391         } else if (!strcasecmp(param, "queue-reporthold")) {
1392                 ast_string_field_set(q, sound_reporthold, val);
1393         } else if (!strcasecmp(param, "announce-frequency")) {
1394                 q->announcefrequency = atoi(val);
1395         } else if (!strcasecmp(param, "min-announce-frequency")) {
1396                 q->minannouncefrequency = atoi(val);
1397                 ast_debug(1, "%s=%s for queue '%s'\n", param, val, q->name);
1398         } else if (!strcasecmp(param, "announce-round-seconds")) {
1399                 q->roundingseconds = atoi(val);
1400                 /* Rounding to any other values just doesn't make sense... */
1401                 if (!(q->roundingseconds == 0 || q->roundingseconds == 5 || q->roundingseconds == 10
1402                         || q->roundingseconds == 15 || q->roundingseconds == 20 || q->roundingseconds == 30)) {
1403                         if (linenum >= 0) {
1404                                 ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
1405                                         "using 0 instead for queue '%s' at line %d of queues.conf\n",
1406                                         val, param, q->name, linenum);
1407                         } else {
1408                                 ast_log(LOG_WARNING, "'%s' isn't a valid value for %s "
1409                                         "using 0 instead for queue '%s'\n", val, param, q->name);
1410                         }
1411                         q->roundingseconds=0;
1412                 }
1413         } else if (!strcasecmp(param, "announce-holdtime")) {
1414                 if (!strcasecmp(val, "once"))
1415                         q->announceholdtime = ANNOUNCEHOLDTIME_ONCE;
1416                 else if (ast_true(val))
1417                         q->announceholdtime = ANNOUNCEHOLDTIME_ALWAYS;
1418                 else
1419                         q->announceholdtime = 0;
1420         } else if (!strcasecmp(param, "announce-position")) {
1421                 if (!strcasecmp(val, "limit"))
1422                         q->announceposition = ANNOUNCEPOSITION_LIMIT;
1423                 else if (!strcasecmp(val, "more"))
1424                         q->announceposition = ANNOUNCEPOSITION_MORE_THAN;
1425                 else if (ast_true(val))
1426                         q->announceposition = ANNOUNCEPOSITION_YES;
1427                 else
1428                         q->announceposition = ANNOUNCEPOSITION_NO;
1429         } else if (!strcasecmp(param, "announce-position-limit")) {
1430                 q->announcepositionlimit = atoi(val);
1431         } else if (!strcasecmp(param, "periodic-announce")) {
1432                 if (strchr(val, ',')) {
1433                         char *s, *buf = ast_strdupa(val);
1434                         unsigned int i = 0;
1435
1436                         while ((s = strsep(&buf, ",|"))) {
1437                                 if (!q->sound_periodicannounce[i])
1438                                         q->sound_periodicannounce[i] = ast_str_create(16);
1439                                 ast_str_set(&q->sound_periodicannounce[i], 0, "%s", s);
1440                                 i++;
1441                                 if (i == MAX_PERIODIC_ANNOUNCEMENTS)
1442                                         break;
1443                         }
1444                         q->numperiodicannounce = i;
1445                 } else {
1446                         ast_str_set(&q->sound_periodicannounce[0], 0, "%s", val);
1447                         q->numperiodicannounce = 1;
1448                 }
1449         } else if (!strcasecmp(param, "periodic-announce-frequency")) {
1450                 q->periodicannouncefrequency = atoi(val);
1451         } else if (!strcasecmp(param, "random-periodic-announce")) {
1452                 q->randomperiodicannounce = ast_true(val);
1453         } else if (!strcasecmp(param, "retry")) {
1454                 q->retry = atoi(val);
1455                 if (q->retry <= 0)
1456                         q->retry = DEFAULT_RETRY;
1457         } else if (!strcasecmp(param, "wrapuptime")) {
1458                 q->wrapuptime = atoi(val);
1459         } else if (!strcasecmp(param, "autofill")) {
1460                 q->autofill = ast_true(val);
1461         } else if (!strcasecmp(param, "monitor-type")) {
1462                 if (!strcasecmp(val, "mixmonitor"))
1463                         q->montype = 1;
1464         } else if (!strcasecmp(param, "autopause")) {
1465                 q->autopause = ast_true(val);
1466         } else if (!strcasecmp(param, "maxlen")) {
1467                 q->maxlen = atoi(val);
1468                 if (q->maxlen < 0)
1469                         q->maxlen = 0;
1470         } else if (!strcasecmp(param, "servicelevel")) {
1471                 q->servicelevel= atoi(val);
1472         } else if (!strcasecmp(param, "strategy")) {
1473                 int strategy;
1474
1475                 /* We are a static queue and already have set this, no need to do it again */
1476                 if (failunknown) {
1477                         return;
1478                 }
1479                 strategy = strat2int(val);
1480                 if (strategy < 0) {
1481                         ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
1482                                 val, q->name);
1483                         q->strategy = QUEUE_STRATEGY_RINGALL;
1484                 }
1485                 if (strategy == q->strategy) {
1486                         return;
1487                 }
1488                 if (strategy == QUEUE_STRATEGY_LINEAR) {
1489                         ast_log(LOG_WARNING, "Changing to the linear strategy currently requires asterisk to be restarted.\n");
1490                         return;
1491                 }
1492                 q->strategy = strategy;
1493         } else if (!strcasecmp(param, "joinempty")) {
1494                 parse_empty_options(val, &q->joinempty);
1495         } else if (!strcasecmp(param, "leavewhenempty")) {
1496                 parse_empty_options(val, &q->leavewhenempty);
1497         } else if (!strcasecmp(param, "eventmemberstatus")) {
1498                 q->maskmemberstatus = !ast_true(val);
1499         } else if (!strcasecmp(param, "eventwhencalled")) {
1500                 if (!strcasecmp(val, "vars")) {
1501                         q->eventwhencalled = QUEUE_EVENT_VARIABLES;
1502                 } else {
1503                         q->eventwhencalled = ast_true(val) ? 1 : 0;
1504                 }
1505         } else if (!strcasecmp(param, "reportholdtime")) {
1506                 q->reportholdtime = ast_true(val);
1507         } else if (!strcasecmp(param, "memberdelay")) {
1508                 q->memberdelay = atoi(val);
1509         } else if (!strcasecmp(param, "weight")) {
1510                 q->weight = atoi(val);
1511                 if (q->weight)
1512                         use_weight++;
1513                 /* With Realtime queues, if the last queue using weights is deleted in realtime,
1514                    we will not see any effect on use_weight until next reload. */
1515         } else if (!strcasecmp(param, "timeoutrestart")) {
1516                 q->timeoutrestart = ast_true(val);
1517         } else if (!strcasecmp(param, "defaultrule")) {
1518                 ast_string_field_set(q, defaultrule, val);
1519         } else if (!strcasecmp(param, "timeoutpriority")) {
1520                 if (!strcasecmp(val, "conf")) {
1521                         q->timeoutpriority = TIMEOUT_PRIORITY_CONF;
1522                 } else {
1523                         q->timeoutpriority = TIMEOUT_PRIORITY_APP;
1524                 }
1525         } else if (failunknown) {
1526                 if (linenum >= 0) {
1527                         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s at line %d of queues.conf\n",
1528                                 q->name, param, linenum);
1529                 } else {
1530                         ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s\n", q->name, param);
1531                 }
1532         }
1533 }
1534
1535 /*!
1536  * \brief Find rt member record to update otherwise create one.
1537  *
1538  * Search for member in queue, if found update penalty/paused state,
1539  * if no memeber exists create one flag it as a RT member and add to queue member list. 
1540 */
1541 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)
1542 {
1543         struct member *m;
1544         struct ao2_iterator mem_iter;
1545         int penalty = 0;
1546         int paused  = 0;
1547         int found = 0;
1548
1549         if (penalty_str) {
1550                 penalty = atoi(penalty_str);
1551                 if (penalty < 0)
1552                         penalty = 0;
1553         }
1554
1555         if (paused_str) {
1556                 paused = atoi(paused_str);
1557                 if (paused < 0)
1558                         paused = 0;
1559         }
1560
1561         /* Find member by realtime uniqueid and update */
1562         mem_iter = ao2_iterator_init(q->members, 0);
1563         while ((m = ao2_iterator_next(&mem_iter))) {
1564                 if (!strcasecmp(m->rt_uniqueid, rt_uniqueid)) {
1565                         m->dead = 0;    /* Do not delete this one. */
1566                         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
1567                         if (paused_str)
1568                                 m->paused = paused;
1569                         if (strcasecmp(state_interface, m->state_interface)) {
1570                                 ast_copy_string(m->state_interface, state_interface, sizeof(m->state_interface));
1571                         }          
1572                         m->penalty = penalty;
1573                         found = 1;
1574                         ao2_ref(m, -1);
1575                         break;
1576                 }
1577                 ao2_ref(m, -1);
1578         }
1579
1580         /* Create a new member */
1581         if (!found) {
1582                 if ((m = create_queue_member(interface, membername, penalty, paused, state_interface))) {
1583                         m->dead = 0;
1584                         m->realtime = 1;
1585                         ast_copy_string(m->rt_uniqueid, rt_uniqueid, sizeof(m->rt_uniqueid));
1586                         ast_queue_log(q->name, "REALTIME", m->interface, "ADDMEMBER", "%s", "");
1587                         ao2_link(q->members, m);
1588                         ao2_ref(m, -1);
1589                         m = NULL;
1590                         q->membercount++;
1591                 }
1592         }
1593 }
1594
1595 /*! \brief Iterate through queue's member list and delete them */
1596 static void free_members(struct call_queue *q, int all)
1597 {
1598         /* Free non-dynamic members */
1599         struct member *cur;
1600         struct ao2_iterator mem_iter = ao2_iterator_init(q->members, 0);
1601
1602         while ((cur = ao2_iterator_next(&mem_iter))) {
1603                 if (all || !cur->dynamic) {
1604                         ao2_unlink(q->members, cur);
1605                         q->membercount--;
1606                 }
1607                 ao2_ref(cur, -1);
1608         }
1609 }
1610
1611 /*! \brief Free queue's member list then its string fields */
1612 static void destroy_queue(void *obj)
1613 {
1614         struct call_queue *q = obj;
1615         int i;
1616
1617         free_members(q, 1);
1618         ast_string_field_free_memory(q);
1619         for (i = 0; i < MAX_PERIODIC_ANNOUNCEMENTS; i++) {
1620                 if (q->sound_periodicannounce[i])
1621                         free(q->sound_periodicannounce[i]);
1622         }
1623         ao2_ref(q->members, -1);
1624 }
1625
1626 static struct call_queue *alloc_queue(const char *queuename)
1627 {
1628         struct call_queue *q;
1629
1630         if ((q = ao2_alloc(sizeof(*q), destroy_queue))) {
1631                 if (ast_string_field_init(q, 64)) {
1632                         free(q);
1633                         return NULL;
1634                 }
1635                 ast_string_field_set(q, name, queuename);
1636         }
1637         return q;
1638 }
1639
1640 /*!
1641  * \brief Reload a single queue via realtime.
1642  *
1643  * Check for statically defined queue first, check if deleted RT queue,
1644  * check for new RT queue, if queue vars are not defined init them with defaults.
1645  * reload RT queue vars, set RT queue members dead and reload them, return finished queue.
1646  * \retval the queue, 
1647  * \retval NULL if it doesn't exist.
1648  * \note Should be called with the "queues" container locked. 
1649 */
1650 static struct call_queue *find_queue_by_name_rt(const char *queuename, struct ast_variable *queue_vars, struct ast_config *member_config)
1651 {
1652         struct ast_variable *v;
1653         struct call_queue *q, tmpq = {
1654                 .name = queuename,      
1655         };
1656         struct member *m;
1657         struct ao2_iterator mem_iter;
1658         char *interface = NULL;
1659         const char *tmp_name;
1660         char *tmp;
1661         char tmpbuf[64];        /* Must be longer than the longest queue param name. */
1662
1663         /* Static queues override realtime. */
1664         if ((q = ao2_find(queues, &tmpq, OBJ_POINTER))) {
1665                 ao2_lock(q);
1666                 if (!q->realtime) {
1667                         if (q->dead) {
1668                                 ao2_unlock(q);
1669                                 queue_unref(q);
1670                                 return NULL;
1671                         } else {
1672                                 ast_log(LOG_WARNING, "Static queue '%s' already exists. Not loading from realtime\n", q->name);
1673                                 ao2_unlock(q);
1674                                 return q;
1675                         }
1676                 }
1677                 queue_unref(q);
1678         } else if (!member_config)
1679                 /* Not found in the list, and it's not realtime ... */
1680                 return NULL;
1681
1682         /* Check if queue is defined in realtime. */
1683         if (!queue_vars) {
1684                 /* Delete queue from in-core list if it has been deleted in realtime. */
1685                 if (q) {
1686                         /*! \note Hmm, can't seem to distinguish a DB failure from a not
1687                            found condition... So we might delete an in-core queue
1688                            in case of DB failure. */
1689                         ast_debug(1, "Queue %s not found in realtime.\n", queuename);
1690
1691                         q->dead = 1;
1692                         /* Delete if unused (else will be deleted when last caller leaves). */
1693                         ao2_unlink(queues, q);
1694                         ao2_unlock(q);
1695                         queue_unref(q);
1696                 }
1697                 return NULL;
1698         }
1699
1700         /* Create a new queue if an in-core entry does not exist yet. */
1701         if (!q) {
1702                 struct ast_variable *tmpvar = NULL;
1703                 if (!(q = alloc_queue(queuename)))
1704                         return NULL;
1705                 ao2_lock(q);
1706                 clear_queue(q);
1707                 q->realtime = 1;
1708                 /*Before we initialize the queue, we need to set the strategy, so that linear strategy
1709                  * will allocate the members properly
1710                  */
1711                 for (tmpvar = queue_vars; tmpvar; tmpvar = tmpvar->next) {
1712                         if (!strcasecmp(tmpvar->name, "strategy")) {
1713                                 q->strategy = strat2int(tmpvar->value);
1714                                 if (q->strategy < 0) {
1715                                         ast_log(LOG_WARNING, "'%s' isn't a valid strategy for queue '%s', using ringall instead\n",
1716                                         tmpvar->value, q->name);
1717                                         q->strategy = QUEUE_STRATEGY_RINGALL;
1718                                 }
1719                                 break;
1720                         }
1721                 }
1722                 /* We traversed all variables and didn't find a strategy */
1723                 if (!tmpvar)
1724                         q->strategy = QUEUE_STRATEGY_RINGALL;
1725                 ao2_link(queues, q);
1726         }
1727         init_queue(q);          /* Ensure defaults for all parameters not set explicitly. */
1728
1729         memset(tmpbuf, 0, sizeof(tmpbuf));
1730         for (v = queue_vars; v; v = v->next) {
1731                 /* Convert to dashes `-' from underscores `_' as the latter are more SQL friendly. */
1732                 if ((tmp = strchr(v->name, '_'))) {
1733                         ast_copy_string(tmpbuf, v->name, sizeof(tmpbuf));
1734                         tmp_name = tmpbuf;
1735                         tmp = tmpbuf;
1736                         while ((tmp = strchr(tmp, '_')))
1737                                 *tmp++ = '-';
1738                 } else
1739                         tmp_name = v->name;
1740
1741                 if (!ast_strlen_zero(v->value)) {
1742                         /* Don't want to try to set the option if the value is empty */
1743                         queue_set_param(q, tmp_name, v->value, -1, 0);
1744                 }
1745         }
1746
1747         /* Temporarily set realtime members dead so we can detect deleted ones. 
1748          * Also set the membercount correctly for realtime*/
1749         mem_iter = ao2_iterator_init(q->members, 0);
1750         while ((m = ao2_iterator_next(&mem_iter))) {
1751                 q->membercount++;
1752                 if (m->realtime)
1753                         m->dead = 1;
1754                 ao2_ref(m, -1);
1755         }
1756
1757         while ((interface = ast_category_browse(member_config, interface))) {
1758                 rt_handle_member_record(q, interface,
1759                         ast_variable_retrieve(member_config, interface, "uniqueid"),
1760                         S_OR(ast_variable_retrieve(member_config, interface, "membername"),interface),
1761                         ast_variable_retrieve(member_config, interface, "penalty"),
1762                         ast_variable_retrieve(member_config, interface, "paused"),
1763                         S_OR(ast_variable_retrieve(member_config, interface, "state_interface"),interface));
1764         }
1765
1766         /* Delete all realtime members that have been deleted in DB. */
1767         mem_iter = ao2_iterator_init(q->members, 0);
1768         while ((m = ao2_iterator_next(&mem_iter))) {
1769                 if (m->dead) {
1770                         ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
1771                         ao2_unlink(q->members, m);
1772                         q->membercount--;
1773                 }
1774                 ao2_ref(m, -1);
1775         }
1776
1777         ao2_unlock(q);
1778
1779         return q;
1780 }
1781
1782 static struct call_queue *load_realtime_queue(const char *queuename)
1783 {
1784         struct ast_variable *queue_vars;
1785         struct ast_config *member_config = NULL;
1786         struct call_queue *q = NULL, tmpq = {
1787                 .name = queuename,      
1788         };
1789
1790         /* Find the queue in the in-core list first. */
1791         q = ao2_find(queues, &tmpq, OBJ_POINTER);
1792
1793         if (!q || q->realtime) {
1794                 /*! \note Load from realtime before taking the "queues" container lock, to avoid blocking all
1795                    queue operations while waiting for the DB.
1796
1797                    This will be two separate database transactions, so we might
1798                    see queue parameters as they were before another process
1799                    changed the queue and member list as it was after the change.
1800                    Thus we might see an empty member list when a queue is
1801                    deleted. In practise, this is unlikely to cause a problem. */
1802
1803                 queue_vars = ast_load_realtime("queues", "name", queuename, SENTINEL);
1804                 if (queue_vars) {
1805                         member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", queuename, SENTINEL);
1806                         if (!member_config) {
1807                                 ast_log(LOG_ERROR, "no queue_members defined in your config (extconfig.conf).\n");
1808                                 ast_variables_destroy(queue_vars);
1809                                 return NULL;
1810                         }
1811                 }
1812
1813                 ao2_lock(queues);
1814                 q = find_queue_by_name_rt(queuename, queue_vars, member_config);
1815                 if (member_config)
1816                         ast_config_destroy(member_config);
1817                 if (queue_vars)
1818                         ast_variables_destroy(queue_vars);
1819                 ao2_unlock(queues);
1820
1821         } else {
1822                 update_realtime_members(q);
1823         }
1824         return q;
1825 }
1826
1827 static int update_realtime_member_field(struct member *mem, const char *queue_name, const char *field, const char *value)
1828 {
1829         int ret = -1;
1830
1831         if (ast_strlen_zero(mem->rt_uniqueid))
1832                 return ret;
1833
1834         if ((ast_update_realtime("queue_members", "uniqueid", mem->rt_uniqueid, field, value, SENTINEL)) > 0)
1835                 ret = 0;
1836
1837         return ret;
1838 }
1839
1840
1841 static void update_realtime_members(struct call_queue *q)
1842 {
1843         struct ast_config *member_config = NULL;
1844         struct member *m;
1845         char *interface = NULL;
1846         struct ao2_iterator mem_iter;
1847
1848         if (!(member_config = ast_load_realtime_multientry("queue_members", "interface LIKE", "%", "queue_name", q->name , SENTINEL))) {
1849                 /*This queue doesn't have realtime members*/
1850                 ast_debug(3, "Queue %s has no realtime members defined. No need for update\n", q->name);
1851                 return;
1852         }
1853
1854         ao2_lock(queues);
1855         ao2_lock(q);
1856         
1857         /* Temporarily set realtime  members dead so we can detect deleted ones.*/ 
1858         mem_iter = ao2_iterator_init(q->members, 0);
1859         while ((m = ao2_iterator_next(&mem_iter))) {
1860                 if (m->realtime)
1861                         m->dead = 1;
1862                 ao2_ref(m, -1);
1863         }
1864
1865         while ((interface = ast_category_browse(member_config, interface))) {
1866                 rt_handle_member_record(q, interface,
1867                         ast_variable_retrieve(member_config, interface, "uniqueid"),
1868                         S_OR(ast_variable_retrieve(member_config, interface, "membername"), interface),
1869                         ast_variable_retrieve(member_config, interface, "penalty"),
1870                         ast_variable_retrieve(member_config, interface, "paused"),
1871                         S_OR(ast_variable_retrieve(member_config, interface, "state_interface"), interface));
1872         }
1873
1874         /* Delete all realtime members that have been deleted in DB. */
1875         mem_iter = ao2_iterator_init(q->members, 0);
1876         while ((m = ao2_iterator_next(&mem_iter))) {
1877                 if (m->dead) {
1878                         ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
1879                         ao2_unlink(q->members, m);
1880                         q->membercount--;
1881                 }
1882                 ao2_ref(m, -1);
1883         }
1884         ao2_unlock(q);
1885         ao2_unlock(queues);
1886         ast_config_destroy(member_config);
1887 }
1888
1889 static int join_queue(char *queuename, struct queue_ent *qe, enum queue_result *reason)
1890 {
1891         struct call_queue *q;
1892         struct queue_ent *cur, *prev = NULL;
1893         int res = -1;
1894         int pos = 0;
1895         int inserted = 0;
1896
1897         if (!(q = load_realtime_queue(queuename)))
1898                 return res;
1899
1900         ao2_lock(queues);
1901         ao2_lock(q);
1902
1903         /* This is our one */
1904         if (q->joinempty) {
1905                 int status = 0;
1906                 if ((status = get_member_status(q, qe->max_penalty, qe->min_penalty, q->joinempty))) {
1907                         *reason = QUEUE_JOINEMPTY;
1908                         ao2_unlock(q);
1909                         ao2_unlock(queues);
1910                         return res;
1911                 }
1912         }
1913         if (*reason == QUEUE_UNKNOWN && q->maxlen && (q->count >= q->maxlen))
1914                 *reason = QUEUE_FULL;
1915         else if (*reason == QUEUE_UNKNOWN) {
1916                 /* There's space for us, put us at the right position inside
1917                  * the queue.
1918                  * Take into account the priority of the calling user */
1919                 inserted = 0;
1920                 prev = NULL;
1921                 cur = q->head;
1922                 while (cur) {
1923                         /* We have higher priority than the current user, enter
1924                          * before him, after all the other users with priority
1925                          * higher or equal to our priority. */
1926                         if ((!inserted) && (qe->prio > cur->prio)) {
1927                                 insert_entry(q, prev, qe, &pos);
1928                                 inserted = 1;
1929                         }
1930                         cur->pos = ++pos;
1931                         prev = cur;
1932                         cur = cur->next;
1933                 }
1934                 /* No luck, join at the end of the queue */
1935                 if (!inserted)
1936                         insert_entry(q, prev, qe, &pos);
1937                 ast_copy_string(qe->moh, q->moh, sizeof(qe->moh));
1938                 ast_copy_string(qe->announce, q->announce, sizeof(qe->announce));
1939                 ast_copy_string(qe->context, q->context, sizeof(qe->context));
1940                 q->count++;
1941                 res = 0;
1942                 manager_event(EVENT_FLAG_CALL, "Join",
1943                         "Channel: %s\r\nCallerIDNum: %s\r\nCallerIDName: %s\r\nQueue: %s\r\nPosition: %d\r\nCount: %d\r\nUniqueid: %s\r\n",
1944                         qe->chan->name,
1945                         S_OR(qe->chan->cid.cid_num, "unknown"), /* XXX somewhere else it is <unknown> */
1946                         S_OR(qe->chan->cid.cid_name, "unknown"),
1947                         q->name, qe->pos, q->count, qe->chan->uniqueid );
1948                 ast_debug(1, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, qe->chan->name, qe->pos );
1949         }
1950         ao2_unlock(q);
1951         ao2_unlock(queues);
1952
1953         return res;
1954 }
1955
1956 static int play_file(struct ast_channel *chan, const char *filename)
1957 {
1958         int res;
1959
1960         ast_stopstream(chan);
1961
1962         res = ast_streamfile(chan, filename, chan->language);
1963         if (!res)
1964                 res = ast_waitstream(chan, AST_DIGIT_ANY);
1965
1966         ast_stopstream(chan);
1967
1968         return res;
1969 }
1970
1971 /*!
1972  * \brief Check for valid exit from queue via goto
1973  * \retval 0 if failure
1974  * \retval 1 if successful
1975 */
1976 static int valid_exit(struct queue_ent *qe, char digit)
1977 {
1978         int digitlen = strlen(qe->digits);
1979
1980         /* Prevent possible buffer overflow */
1981         if (digitlen < sizeof(qe->digits) - 2) {
1982                 qe->digits[digitlen] = digit;
1983                 qe->digits[digitlen + 1] = '\0';
1984         } else {
1985                 qe->digits[0] = '\0';
1986                 return 0;
1987         }
1988
1989         /* If there's no context to goto, short-circuit */
1990         if (ast_strlen_zero(qe->context))
1991                 return 0;
1992
1993         /* If the extension is bad, then reset the digits to blank */
1994         if (!ast_canmatch_extension(qe->chan, qe->context, qe->digits, 1, qe->chan->cid.cid_num)) {
1995                 qe->digits[0] = '\0';
1996                 return 0;
1997         }
1998
1999         /* We have an exact match */
2000         if (!ast_goto_if_exists(qe->chan, qe->context, qe->digits, 1)) {
2001                 qe->valid_digits = 1;
2002                 /* Return 1 on a successful goto */
2003                 return 1;
2004         }
2005
2006         return 0;
2007 }
2008
2009 static int say_position(struct queue_ent *qe, int ringing)
2010 {
2011         int res = 0, avgholdmins, avgholdsecs, announceposition = 0;
2012         time_t now;
2013
2014         /* Let minannouncefrequency seconds pass between the start of each position announcement */
2015         time(&now);
2016         if ((now - qe->last_pos) < qe->parent->minannouncefrequency)
2017                 return 0;
2018
2019         /* If either our position has changed, or we are over the freq timer, say position */
2020         if ((qe->last_pos_said == qe->pos) && ((now - qe->last_pos) < qe->parent->announcefrequency))
2021                 return 0;
2022
2023         if (ringing) {
2024                 ast_indicate(qe->chan,-1);
2025         } else {
2026                 ast_moh_stop(qe->chan);
2027         }
2028
2029         if (qe->parent->announceposition == ANNOUNCEPOSITION_YES ||
2030                 qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN ||
2031                 (qe->parent->announceposition == ANNOUNCEPOSITION_LIMIT &&
2032                 qe->pos <= qe->parent->announcepositionlimit))
2033                         announceposition = 1;
2034
2035
2036         if (announceposition == 1) {
2037                 /* Say we're next, if we are */
2038                 if (qe->pos == 1) {
2039                         res = play_file(qe->chan, qe->parent->sound_next);
2040                         if (res)
2041                                 goto playout;
2042                         else
2043                                 goto posout;
2044                 } else {
2045                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
2046                                 /* More than Case*/
2047                                 res = play_file(qe->chan, qe->parent->queue_quantity1);
2048                                 if (res)
2049                                         goto playout;
2050                                 res = ast_say_number(qe->chan, qe->parent->announcepositionlimit, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
2051                                 if (res)
2052                                         goto playout;
2053                         } else {
2054                                 /* Normal Case */
2055                                 res = play_file(qe->chan, qe->parent->sound_thereare);
2056                                 if (res)
2057                                         goto playout;
2058                                 res = ast_say_number(qe->chan, qe->pos, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
2059                                 if (res)
2060                                         goto playout;
2061                         }
2062                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
2063                                 /* More than Case*/
2064                                 res = play_file(qe->chan, qe->parent->queue_quantity2);
2065                                 if (res)
2066                                         goto playout;
2067                         } else {
2068                                 res = play_file(qe->chan, qe->parent->sound_calls);
2069                                 if (res)
2070                                         goto playout;
2071                         }
2072                 }
2073         }
2074         /* Round hold time to nearest minute */
2075         avgholdmins = abs(((qe->parent->holdtime + 30) - (now - qe->start)) / 60);
2076
2077         /* If they have specified a rounding then round the seconds as well */
2078         if (qe->parent->roundingseconds) {
2079                 avgholdsecs = (abs(((qe->parent->holdtime + 30) - (now - qe->start))) - 60 * avgholdmins) / qe->parent->roundingseconds;
2080                 avgholdsecs *= qe->parent->roundingseconds;
2081         } else {
2082                 avgholdsecs = 0;
2083         }
2084
2085         ast_verb(3, "Hold time for %s is %d minute(s) %d seconds\n", qe->parent->name, avgholdmins, avgholdsecs);
2086
2087         /* If the hold time is >1 min, if it's enabled, and if it's not
2088            supposed to be only once and we have already said it, say it */
2089     if ((avgholdmins+avgholdsecs) > 0 && qe->parent->announceholdtime &&
2090         ((qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE && !qe->last_pos) ||
2091         !(qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE))) {
2092                 res = play_file(qe->chan, qe->parent->sound_holdtime);
2093                 if (res)
2094                         goto playout;
2095
2096                 if (avgholdmins > 1) {
2097                         res = ast_say_number(qe->chan, avgholdmins, AST_DIGIT_ANY, qe->chan->language, NULL);
2098                         if (res)
2099                                 goto playout;
2100
2101                         if (avgholdmins == 1) {
2102                                 res = play_file(qe->chan, qe->parent->sound_minute);
2103                                 if (res)
2104                                         goto playout;
2105                         } else {
2106                                 res = play_file(qe->chan, qe->parent->sound_minutes);
2107                                 if (res)
2108                                         goto playout;
2109                         }
2110                 }
2111                 if (avgholdsecs > 1) {
2112                         res = ast_say_number(qe->chan, avgholdmins > 1 ? avgholdsecs : avgholdmins * 60 + avgholdsecs, AST_DIGIT_ANY, qe->chan->language, NULL);
2113                         if (res)
2114                                 goto playout;
2115
2116                         res = play_file(qe->chan, qe->parent->sound_seconds);
2117                         if (res)
2118                                 goto playout;
2119                 }
2120
2121         }
2122
2123 posout:
2124         if (announceposition == 1){
2125                 if (qe->parent->announceposition) {
2126                         ast_verb(3, "Told %s in %s their queue position (which was %d)\n",
2127                                 qe->chan->name, qe->parent->name, qe->pos);
2128                 }
2129                 res = play_file(qe->chan, qe->parent->sound_thanks);
2130         }
2131 playout:
2132         if ((res > 0 && !valid_exit(qe, res)) || res < 0)
2133                 res = 0;
2134
2135         /* Set our last_pos indicators */
2136         qe->last_pos = now;
2137         qe->last_pos_said = qe->pos;
2138
2139         /* Don't restart music on hold if we're about to exit the caller from the queue */
2140         if (!res) {
2141                 if (ringing) {
2142                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
2143                 } else {
2144                         ast_moh_start(qe->chan, qe->moh, NULL);
2145                 }
2146         }
2147         return res;
2148 }
2149
2150 static void recalc_holdtime(struct queue_ent *qe, int newholdtime)
2151 {
2152         int oldvalue;
2153
2154         /* Calculate holdtime using an exponential average */
2155         /* Thanks to SRT for this contribution */
2156         /* 2^2 (4) is the filter coefficient; a higher exponent would give old entries more weight */
2157
2158         ao2_lock(qe->parent);
2159         oldvalue = qe->parent->holdtime;
2160         qe->parent->holdtime = (((oldvalue << 2) - oldvalue) + newholdtime) >> 2;
2161         ao2_unlock(qe->parent);
2162 }
2163
2164 /*! \brief Caller leaving queue.
2165  * 
2166  * Search the queue to find the leaving client, if found remove from queue
2167  * create manager event, move others up the queue.
2168 */
2169 static void leave_queue(struct queue_ent *qe)
2170 {
2171         struct call_queue *q;
2172         struct queue_ent *current, *prev = NULL;
2173         struct penalty_rule *pr_iter;
2174         int pos = 0;
2175
2176         if (!(q = qe->parent))
2177                 return;
2178         queue_ref(q);
2179         ao2_lock(q);
2180
2181         prev = NULL;
2182         for (current = q->head; current; current = current->next) {
2183                 if (current == qe) {
2184                         q->count--;
2185
2186                         /* Take us out of the queue */
2187                         manager_event(EVENT_FLAG_CALL, "Leave",
2188                                 "Channel: %s\r\nQueue: %s\r\nCount: %d\r\nUniqueid: %s\r\n",
2189                                 qe->chan->name, q->name,  q->count, qe->chan->uniqueid);
2190                         ast_debug(1, "Queue '%s' Leave, Channel '%s'\n", q->name, qe->chan->name );
2191                         /* Take us out of the queue */
2192                         if (prev)
2193                                 prev->next = current->next;
2194                         else
2195                                 q->head = current->next;
2196                         /* Free penalty rules */
2197                         while ((pr_iter = AST_LIST_REMOVE_HEAD(&qe->qe_rules, list)))
2198                                 ast_free(pr_iter);
2199                 } else {
2200                         /* Renumber the people after us in the queue based on a new count */
2201                         current->pos = ++pos;
2202                         prev = current;
2203                 }
2204         }
2205         ao2_unlock(q);
2206
2207         /*If the queue is a realtime queue, check to see if it's still defined in real time*/
2208         if (q->realtime) {
2209                 struct ast_variable *var;
2210                 if (!(var = ast_load_realtime("queues", "name", q->name, SENTINEL))) {
2211                         q->dead = 1;
2212                 } else {
2213                         ast_variables_destroy(var);
2214                 }
2215         }
2216
2217         if (q->dead) {  
2218                 /* It's dead and nobody is in it, so kill it */
2219                 ao2_unlink(queues, q);
2220         }
2221         /* unref the explicit ref earlier in the function */
2222         queue_unref(q);
2223 }
2224
2225 /*! \brief Hang up a list of outgoing calls */
2226 static void hangupcalls(struct callattempt *outgoing, struct ast_channel *exception)
2227 {
2228         struct callattempt *oo;
2229
2230         while (outgoing) {
2231                 /* Hangup any existing lines we have open */
2232                 if (outgoing->chan && (outgoing->chan != exception))
2233                         ast_hangup(outgoing->chan);
2234                 oo = outgoing;
2235                 outgoing = outgoing->q_next;
2236                 if (oo->member)
2237                         ao2_ref(oo->member, -1);
2238                 ast_free(oo);
2239         }
2240 }
2241
2242 /*! 
2243  * \brief traverse all defined queues which have calls waiting and contain this member
2244  * \retval 0 if no other queue has precedence (higher weight) 
2245  * \retval 1 if found  
2246 */
2247 static int compare_weight(struct call_queue *rq, struct member *member)
2248 {
2249         struct call_queue *q;
2250         struct member *mem;
2251         int found = 0;
2252         struct ao2_iterator queue_iter;
2253         
2254         /* q's lock and rq's lock already set by try_calling()
2255          * to solve deadlock */
2256         queue_iter = ao2_iterator_init(queues, 0);
2257         while ((q = ao2_iterator_next(&queue_iter))) {
2258                 if (q == rq) { /* don't check myself, could deadlock */
2259                         queue_unref(q);
2260                         continue;
2261                 }
2262                 ao2_lock(q);
2263                 if (q->count && q->members) {
2264                         if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
2265                                 ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
2266                                 if (q->weight > rq->weight) {
2267                                         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);
2268                                         found = 1;
2269                                 }
2270                                 ao2_ref(mem, -1);
2271                         }
2272                 }
2273                 ao2_unlock(q);
2274                 queue_unref(q);
2275                 if (found) {
2276                         break;
2277                 }
2278         }
2279         return found;
2280 }
2281
2282 /*! \brief common hangup actions */
2283 static void do_hang(struct callattempt *o)
2284 {
2285         o->stillgoing = 0;
2286         ast_hangup(o->chan);
2287         o->chan = NULL;
2288 }
2289
2290 /*! \brief convert "\n" to "\nVariable: " ready for manager to use */
2291 static char *vars2manager(struct ast_channel *chan, char *vars, size_t len)
2292 {
2293         struct ast_str *buf = ast_str_thread_get(&global_app_buf, len + 1);
2294         char *tmp;
2295
2296         if (pbx_builtin_serialize_variables(chan, &buf)) {
2297                 int i, j;
2298
2299                 /* convert "\n" to "\nVariable: " */
2300                 strcpy(vars, "Variable: ");
2301                 tmp = ast_str_buffer(buf);
2302
2303                 for (i = 0, j = 10; (i < len - 1) && (j < len - 1); i++, j++) {
2304                         vars[j] = tmp[i];
2305
2306                         if (tmp[i + 1] == '\0')
2307                                 break;
2308                         if (tmp[i] == '\n') {
2309                                 vars[j++] = '\r';
2310                                 vars[j++] = '\n';
2311
2312                                 ast_copy_string(&(vars[j]), "Variable: ", len - j);
2313                                 j += 9;
2314                         }
2315                 }
2316                 if (j > len - 3)
2317                         j = len - 3;
2318                 vars[j++] = '\r';
2319                 vars[j++] = '\n';
2320                 vars[j] = '\0';
2321         } else {
2322                 /* there are no channel variables; leave it blank */
2323                 *vars = '\0';
2324         }
2325         return vars;
2326 }
2327
2328 /*! 
2329  * \brief Part 2 of ring_one
2330  *
2331  * Does error checking before attempting to request a channel and call a member. 
2332  * This function is only called from ring_one(). 
2333  * Failure can occur if:
2334  * - Agent on call
2335  * - Agent is paused
2336  * - Wrapup time not expired
2337  * - Priority by another queue
2338  *
2339  * \retval 1 on success to reach a free agent
2340  * \retval 0 on failure to get agent.
2341  */
2342 static int ring_entry(struct queue_ent *qe, struct callattempt *tmp, int *busies)
2343 {
2344         int res;
2345         int status;
2346         char tech[256];
2347         char *location;
2348         const char *macrocontext, *macroexten;
2349
2350         /* on entry here, we know that tmp->chan == NULL */
2351         if ((tmp->lastqueue && tmp->lastqueue->wrapuptime && (time(NULL) - tmp->lastcall < tmp->lastqueue->wrapuptime)) ||
2352                 (!tmp->lastqueue && qe->parent->wrapuptime && (time(NULL) - tmp->lastcall < qe->parent->wrapuptime))) {
2353                 ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n", 
2354                                 (tmp->lastqueue ? tmp->lastqueue->name : qe->parent->name), tmp->interface);
2355                 if (qe->chan->cdr)
2356                         ast_cdr_busy(qe->chan->cdr);
2357                 tmp->stillgoing = 0;
2358                 (*busies)++;
2359                 return 0;
2360         }
2361
2362         if (!qe->parent->ringinuse && (tmp->member->status != AST_DEVICE_NOT_INUSE) && (tmp->member->status != AST_DEVICE_UNKNOWN)) {
2363                 ast_debug(1, "%s in use, can't receive call\n", tmp->interface);
2364                 if (qe->chan->cdr)
2365                         ast_cdr_busy(qe->chan->cdr);
2366                 tmp->stillgoing = 0;
2367                 return 0;
2368         }
2369
2370         if (tmp->member->paused) {
2371                 ast_debug(1, "%s paused, can't receive call\n", tmp->interface);
2372                 if (qe->chan->cdr)
2373                         ast_cdr_busy(qe->chan->cdr);
2374                 tmp->stillgoing = 0;
2375                 return 0;
2376         }
2377         if (use_weight && compare_weight(qe->parent,tmp->member)) {
2378                 ast_debug(1, "Priority queue delaying call to %s:%s\n", qe->parent->name, tmp->interface);
2379                 if (qe->chan->cdr)
2380                         ast_cdr_busy(qe->chan->cdr);
2381                 tmp->stillgoing = 0;
2382                 (*busies)++;
2383                 return 0;
2384         }
2385
2386         ast_copy_string(tech, tmp->interface, sizeof(tech));
2387         if ((location = strchr(tech, '/')))
2388                 *location++ = '\0';
2389         else
2390                 location = "";
2391
2392         /* Request the peer */
2393         tmp->chan = ast_request(tech, qe->chan->nativeformats, location, &status);
2394         if (!tmp->chan) {                       /* If we can't, just go on to the next call */
2395                 if (qe->chan->cdr)
2396                         ast_cdr_busy(qe->chan->cdr);
2397                 tmp->stillgoing = 0;    
2398
2399                 ao2_lock(qe->parent);
2400                 update_status(qe->parent, tmp->member, ast_device_state(tmp->member->state_interface));
2401                 qe->parent->rrpos++;
2402                 qe->linpos++;
2403                 ao2_unlock(qe->parent);
2404
2405                 (*busies)++;
2406                 return 0;
2407         }
2408         
2409         tmp->chan->appl = "AppQueue";
2410         tmp->chan->data = "(Outgoing Line)";
2411         memset(&tmp->chan->whentohangup, 0, sizeof(tmp->chan->whentohangup));
2412         if (tmp->chan->cid.cid_num)
2413                 ast_free(tmp->chan->cid.cid_num);
2414         tmp->chan->cid.cid_num = ast_strdup(qe->chan->cid.cid_num);
2415         if (tmp->chan->cid.cid_name)
2416                 ast_free(tmp->chan->cid.cid_name);
2417         tmp->chan->cid.cid_name = ast_strdup(qe->chan->cid.cid_name);
2418         if (tmp->chan->cid.cid_ani)
2419                 ast_free(tmp->chan->cid.cid_ani);
2420         tmp->chan->cid.cid_ani = ast_strdup(qe->chan->cid.cid_ani);
2421
2422         /* Inherit specially named variables from parent channel */
2423         ast_channel_inherit_variables(qe->chan, tmp->chan);
2424
2425         /* Presense of ADSI CPE on outgoing channel follows ours */
2426         tmp->chan->adsicpe = qe->chan->adsicpe;
2427
2428         /* Inherit context and extension */
2429         ast_channel_lock(qe->chan);
2430         macrocontext = pbx_builtin_getvar_helper(qe->chan, "MACRO_CONTEXT");
2431         ast_string_field_set(tmp->chan, dialcontext, ast_strlen_zero(macrocontext) ? qe->chan->context : macrocontext);
2432         macroexten = pbx_builtin_getvar_helper(qe->chan, "MACRO_EXTEN");
2433         if (!ast_strlen_zero(macroexten))
2434                 ast_copy_string(tmp->chan->exten, macroexten, sizeof(tmp->chan->exten));
2435         else
2436                 ast_copy_string(tmp->chan->exten, qe->chan->exten, sizeof(tmp->chan->exten));
2437         ast_channel_unlock(qe->chan);
2438
2439         /* Place the call, but don't wait on the answer */
2440         if ((res = ast_call(tmp->chan, location, 0))) {
2441                 /* Again, keep going even if there's an error */
2442                 ast_debug(1, "ast call on peer returned %d\n", res);
2443                 ast_verb(3, "Couldn't call %s\n", tmp->interface);
2444                 do_hang(tmp);
2445                 (*busies)++;
2446                 update_status(qe->parent, tmp->member, ast_device_state(tmp->member->interface));
2447                 return 0;
2448         } else if (qe->parent->eventwhencalled) {
2449                 char vars[2048];
2450
2451                 manager_event(EVENT_FLAG_AGENT, "AgentCalled",
2452                                         "Queue: %s\r\n"
2453                                         "AgentCalled: %s\r\n"
2454                                         "AgentName: %s\r\n"
2455                                         "ChannelCalling: %s\r\n"
2456                                         "DestinationChannel: %s\r\n"
2457                                         "CallerIDNum: %s\r\n"
2458                                         "CallerIDName: %s\r\n"
2459                                         "Context: %s\r\n"
2460                                         "Extension: %s\r\n"
2461                                         "Priority: %d\r\n"
2462                                         "Uniqueid: %s\r\n"
2463                                         "%s",
2464                                         qe->parent->name, tmp->interface, tmp->member->membername, qe->chan->name, tmp->chan->name,
2465                                         tmp->chan->cid.cid_num ? tmp->chan->cid.cid_num : "unknown",
2466                                         tmp->chan->cid.cid_name ? tmp->chan->cid.cid_name : "unknown",
2467                                         qe->chan->context, qe->chan->exten, qe->chan->priority, qe->chan->uniqueid,
2468                                         qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2469                 ast_verb(3, "Called %s\n", tmp->interface);
2470         }
2471
2472         update_status(qe->parent, tmp->member, ast_device_state(tmp->member->interface));
2473         return 1;
2474 }
2475
2476 /*! \brief find the entry with the best metric, or NULL */
2477 static struct callattempt *find_best(struct callattempt *outgoing)
2478 {
2479         struct callattempt *best = NULL, *cur;
2480
2481         for (cur = outgoing; cur; cur = cur->q_next) {
2482                 if (cur->stillgoing &&                                  /* Not already done */
2483                         !cur->chan &&                                   /* Isn't already going */
2484                         (!best || cur->metric < best->metric)) {                /* We haven't found one yet, or it's better */
2485                         best = cur;
2486                 }
2487         }
2488
2489         return best;
2490 }
2491
2492 /*! 
2493  * \brief Place a call to a queue member.
2494  *
2495  * Once metrics have been calculated for each member, this function is used
2496  * to place a call to the appropriate member (or members). The low-level
2497  * channel-handling and error detection is handled in ring_entry
2498  *
2499  * \retval 1 if a member was called successfully
2500  * \retval 0 otherwise
2501  */
2502 static int ring_one(struct queue_ent *qe, struct callattempt *outgoing, int *busies)
2503 {
2504         int ret = 0;
2505
2506         while (ret == 0) {
2507                 struct callattempt *best = find_best(outgoing);
2508                 if (!best) {
2509                         ast_debug(1, "Nobody left to try ringing in queue\n");
2510                         break;
2511                 }
2512                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
2513                         struct callattempt *cur;
2514                         /* Ring everyone who shares this best metric (for ringall) */
2515                         for (cur = outgoing; cur; cur = cur->q_next) {
2516                                 if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
2517                                         ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
2518                                         ret |= ring_entry(qe, cur, busies);
2519                                 }
2520                         }
2521                 } else {
2522                         /* Ring just the best channel */
2523                         ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
2524                         ret = ring_entry(qe, best, busies);
2525                 }
2526                 
2527                 /* If we have timed out, break out */
2528                 if (qe->expire && (time(NULL) >= qe->expire)) {
2529                         ast_debug(1, "Queue timed out while ringing members.\n");
2530                         ret = 0;
2531                         break;
2532                 }
2533         }
2534
2535         return ret;
2536 }
2537
2538 /*! \brief Search for best metric and add to Round Robbin queue */
2539 static int store_next_rr(struct queue_ent *qe, struct callattempt *outgoing)
2540 {
2541         struct callattempt *best = find_best(outgoing);
2542
2543         if (best) {
2544                 /* Ring just the best channel */
2545                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2546                 qe->parent->rrpos = best->metric % 1000;
2547         } else {
2548                 /* Just increment rrpos */
2549                 if (qe->parent->wrapped) {
2550                         /* No more channels, start over */
2551                         qe->parent->rrpos = 0;
2552                 } else {
2553                         /* Prioritize next entry */
2554                         qe->parent->rrpos++;
2555                 }
2556         }
2557         qe->parent->wrapped = 0;
2558
2559         return 0;
2560 }
2561
2562 /*! \brief Search for best metric and add to Linear queue */
2563 static int store_next_lin(struct queue_ent *qe, struct callattempt *outgoing)
2564 {
2565         struct callattempt *best = find_best(outgoing);
2566
2567         if (best) {
2568                 /* Ring just the best channel */
2569                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2570                 qe->linpos = best->metric % 1000;
2571         } else {
2572                 /* Just increment rrpos */
2573                 if (qe->linwrapped) {
2574                         /* No more channels, start over */
2575                         qe->linpos = 0;
2576                 } else {
2577                         /* Prioritize next entry */
2578                         qe->linpos++;
2579                 }
2580         }
2581         qe->linwrapped = 0;
2582
2583         return 0;
2584 }
2585
2586 /*! \brief Playback announcement to queued members if peroid has elapsed */
2587 static int say_periodic_announcement(struct queue_ent *qe, int ringing)
2588 {
2589         int res = 0;
2590         time_t now;
2591
2592         /* Get the current time */
2593         time(&now);
2594
2595         /* Check to see if it is time to announce */
2596         if ((now - qe->last_periodic_announce_time) < qe->parent->periodicannouncefrequency)
2597                 return 0;
2598
2599         /* Stop the music on hold so we can play our own file */
2600         if (ringing)
2601                 ast_indicate(qe->chan,-1);
2602         else
2603                 ast_moh_stop(qe->chan);
2604
2605         ast_verb(3, "Playing periodic announcement\n");
2606         
2607         if (qe->parent->randomperiodicannounce) {
2608                 qe->last_periodic_announce_sound = ((unsigned long) ast_random()) % qe->parent->numperiodicannounce;
2609         } else if (qe->last_periodic_announce_sound >= qe->parent->numperiodicannounce || 
2610                 ast_str_strlen(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]) == 0) {
2611                 qe->last_periodic_announce_sound = 0;
2612         }
2613         
2614         /* play the announcement */
2615         res = play_file(qe->chan, ast_str_buffer(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]));
2616
2617         if ((res > 0 && !valid_exit(qe, res)) || res < 0)
2618                 res = 0;
2619
2620         /* Resume Music on Hold if the caller is going to stay in the queue */
2621         if (!res) {
2622                 if (ringing)
2623                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
2624                 else
2625                         ast_moh_start(qe->chan, qe->moh, NULL);
2626         }
2627
2628         /* update last_periodic_announce_time */
2629         qe->last_periodic_announce_time = now;
2630
2631         /* Update the current periodic announcement to the next announcement */
2632         if (!qe->parent->randomperiodicannounce) {
2633                 qe->last_periodic_announce_sound++;
2634         }
2635         
2636         return res;
2637 }
2638
2639 /*! \brief Record that a caller gave up on waiting in queue */
2640 static void record_abandoned(struct queue_ent *qe)
2641 {
2642         ao2_lock(qe->parent);
2643         set_queue_variables(qe);
2644         manager_event(EVENT_FLAG_AGENT, "QueueCallerAbandon",
2645                 "Queue: %s\r\n"
2646                 "Uniqueid: %s\r\n"
2647                 "Position: %d\r\n"
2648                 "OriginalPosition: %d\r\n"
2649                 "HoldTime: %d\r\n",
2650                 qe->parent->name, qe->chan->uniqueid, qe->pos, qe->opos, (int)(time(NULL) - qe->start));
2651
2652         qe->parent->callsabandoned++;
2653         ao2_unlock(qe->parent);
2654 }
2655
2656 /*! \brief RNA == Ring No Answer. Common code that is executed when we try a queue member and they don't answer. */
2657 static void rna(int rnatime, struct queue_ent *qe, char *interface, char *membername)
2658 {
2659         ast_verb(3, "Nobody picked up in %d ms\n", rnatime);
2660         if (qe->parent->eventwhencalled) {
2661                 char vars[2048];
2662
2663                 manager_event(EVENT_FLAG_AGENT, "AgentRingNoAnswer",
2664                                                 "Queue: %s\r\n"
2665                                                 "Uniqueid: %s\r\n"
2666                                                 "Channel: %s\r\n"
2667                                                 "Member: %s\r\n"
2668                                                 "MemberName: %s\r\n"
2669                                                 "Ringtime: %d\r\n"
2670                                                 "%s",
2671                                                 qe->parent->name,
2672                                                 qe->chan->uniqueid,
2673                                                 qe->chan->name,
2674                                                 interface,
2675                                                 membername,
2676                                                 rnatime,
2677                                                 qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2678         }
2679         ast_queue_log(qe->parent->name, qe->chan->uniqueid, membername, "RINGNOANSWER", "%d", rnatime);
2680         if (qe->parent->autopause) {
2681                 if (!set_member_paused(qe->parent->name, interface, "Auto-Pause", 1)) {
2682                         ast_verb(3, "Auto-Pausing Queue Member %s in queue %s since they failed to answer.\n", interface, qe->parent->name);
2683                 } else {
2684                         ast_verb(3, "Failed to pause Queue Member %s in queue %s!\n", interface, qe->parent->name);
2685                 }
2686         }
2687         return;
2688 }
2689
2690 #define AST_MAX_WATCHERS 256
2691 /*! \brief Wait for a member to answer the call
2692  *
2693  * \param[in] qe the queue_ent corresponding to the caller in the queue
2694  * \param[in] outgoing the list of callattempts. Relevant ones will have their chan and stillgoing parameters non-zero
2695  * \param[in] to the amount of time (in milliseconds) to wait for a response
2696  * \param[out] digit if a user presses a digit to exit the queue, this is the digit the caller pressed
2697  * \param[in] prebusies number of busy members calculated prior to calling wait_for_answer
2698  * \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
2699  * \param[in] forwardsallowed used to detect if we should allow call forwarding, based on the 'i' option to Queue()
2700  */
2701 static struct callattempt *wait_for_answer(struct queue_ent *qe, struct callattempt *outgoing, int *to, char *digit, int prebusies, int caller_disconnect, int forwardsallowed)
2702 {
2703         const char *queue = qe->parent->name;
2704         struct callattempt *o, *start = NULL, *prev = NULL;
2705         int status;
2706         int numbusies = prebusies;
2707         int numnochan = 0;
2708         int stillgoing = 0;
2709         int orig = *to;
2710         struct ast_frame *f;
2711         struct callattempt *peer = NULL;
2712         struct ast_channel *winner;
2713         struct ast_channel *in = qe->chan;
2714         char on[80] = "";
2715         char membername[80] = "";
2716         long starttime = 0;
2717         long endtime = 0;
2718 #ifdef HAVE_EPOLL
2719         struct callattempt *epollo;
2720 #endif
2721
2722         starttime = (long) time(NULL);
2723 #ifdef HAVE_EPOLL
2724         for (epollo = outgoing; epollo; epollo = epollo->q_next) {
2725                 if (epollo->chan)
2726                         ast_poll_channel_add(in, epollo->chan);
2727         }
2728 #endif
2729         
2730         while (*to && !peer) {
2731                 int numlines, retry, pos = 1;
2732                 struct ast_channel *watchers[AST_MAX_WATCHERS];
2733                 watchers[0] = in;
2734                 start = NULL;
2735
2736                 for (retry = 0; retry < 2; retry++) {
2737                         numlines = 0;
2738                         for (o = outgoing; o; o = o->q_next) { /* Keep track of important channels */
2739                                 if (o->stillgoing) {    /* Keep track of important channels */
2740                                         stillgoing = 1;
2741                                         if (o->chan) {
2742                                                 watchers[pos++] = o->chan;
2743                                                 if (!start)
2744                                                         start = o;
2745                                                 else
2746                                                         prev->call_next = o;
2747                                                 prev = o;
2748                                         }
2749                                 }
2750                                 numlines++;
2751                         }
2752                         if (pos > 1 /* found */ || !stillgoing /* nobody listening */ ||
2753                                 (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) /* ring would not be delivered */)
2754                                 break;
2755                         /* On "ringall" strategy we only move to the next penalty level
2756                            when *all* ringing phones are done in the current penalty level */
2757                         ring_one(qe, outgoing, &numbusies);
2758                         /* and retry... */
2759                 }
2760                 if (pos == 1 /* not found */) {
2761                         if (numlines == (numbusies + numnochan)) {
2762                                 ast_debug(1, "Everyone is busy at this time\n");
2763                         } else {
2764                                 ast_debug(3, "No one is answering queue '%s' (%d numlines / %d busies / %d failed channels)\n", queue, numlines, numbusies, numnochan);
2765                         }
2766                         *to = 0;
2767                         return NULL;
2768                 }
2769                 winner = ast_waitfor_n(watchers, pos, to);
2770                 for (o = start; o; o = o->call_next) {
2771                         if (o->stillgoing && (o->chan) &&  (o->chan->_state == AST_STATE_UP)) {
2772                                 if (!peer) {
2773                                         ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2774                                         peer = o;
2775                                 }
2776                         } else if (o->chan && (o->chan == winner)) {
2777
2778                                 ast_copy_string(on, o->member->interface, sizeof(on));
2779                                 ast_copy_string(membername, o->member->membername, sizeof(membername));
2780
2781                                 if (!ast_strlen_zero(o->chan->call_forward) && !forwardsallowed) {
2782                                         ast_verb(3, "Forwarding %s to '%s' prevented.\n", in->name, o->chan->call_forward);
2783                                         numnochan++;
2784                                         do_hang(o);
2785                                         winner = NULL;
2786                                         continue;
2787                                 } else if (!ast_strlen_zero(o->chan->call_forward)) {
2788                                         char tmpchan[256];
2789                                         char *stuff;
2790                                         char *tech;
2791
2792                                         ast_copy_string(tmpchan, o->chan->call_forward, sizeof(tmpchan));
2793                                         if ((stuff = strchr(tmpchan, '/'))) {
2794                                                 *stuff++ = '\0';
2795                                                 tech = tmpchan;
2796                                         } else {
2797                                                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", o->chan->call_forward, o->chan->context);
2798                                                 stuff = tmpchan;
2799                                                 tech = "Local";
2800                                         }
2801                                         /* Before processing channel, go ahead and check for forwarding */
2802                                         ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, o->chan->name);
2803                                         /* Setup parameters */
2804                                         o->chan = ast_request(tech, in->nativeformats, stuff, &status);
2805                                         if (!o->chan) {
2806                                                 ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s'\n", tech, stuff);
2807                                                 o->stillgoing = 0;
2808                                                 numnochan++;
2809                                         } else {
2810                                                 ast_channel_inherit_variables(in, o->chan);
2811                                                 ast_channel_datastore_inherit(in, o->chan);
2812                                                 if (o->chan->cid.cid_num)
2813                                                         ast_free(o->chan->cid.cid_num);
2814                                                 o->chan->cid.cid_num = ast_strdup(in->cid.cid_num);
2815
2816                                                 if (o->chan->cid.cid_name)
2817                                                         ast_free(o->chan->cid.cid_name);
2818                                                 o->chan->cid.cid_name = ast_strdup(in->cid.cid_name);
2819
2820                                                 ast_string_field_set(o->chan, accountcode, in->accountcode);
2821                                                 o->chan->cdrflags = in->cdrflags;
2822
2823                                                 if (in->cid.cid_ani) {
2824                                                         if (o->chan->cid.cid_ani)
2825                                                                 ast_free(o->chan->cid.cid_ani);
2826                                                         o->chan->cid.cid_ani = ast_strdup(in->cid.cid_ani);
2827                                                 }
2828                                                 if (o->chan->cid.cid_rdnis)
2829                                                         ast_free(o->chan->cid.cid_rdnis);
2830                                                 o->chan->cid.cid_rdnis = ast_strdup(S_OR(in->macroexten, in->exten));
2831                                                 if (ast_call(o->chan, tmpchan, 0)) {
2832                                                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
2833                                                         do_hang(o);
2834                                                         numnochan++;
2835                                                 }
2836                                         }
2837                                         /* Hangup the original channel now, in case we needed it */
2838                                         ast_hangup(winner);
2839                                         continue;
2840                                 }
2841                                 f = ast_read(winner);
2842                                 if (f) {
2843                                         if (f->frametype == AST_FRAME_CONTROL) {
2844                                                 switch (f->subclass) {
2845                                                 case AST_CONTROL_ANSWER:
2846                                                         /* This is our guy if someone answered. */
2847                                                         if (!peer) {
2848                                                                 ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2849                                                                 peer = o;
2850                                                         }
2851                                                         break;
2852                                                 case AST_CONTROL_BUSY:
2853                                                         ast_verb(3, "%s is busy\n", o->chan->name);
2854                                                         if (in->cdr)
2855                                                                 ast_cdr_busy(in->cdr);
2856                                                         do_hang(o);
2857                                                         endtime = (long) time(NULL);
2858                                                         endtime -= starttime;
2859                                                         rna(endtime*1000, qe, on, membername);
2860                                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2861                                                                 if (qe->parent->timeoutrestart)
2862                                                                         *to = orig;
2863                                                                 ring_one(qe, outgoing, &numbusies);
2864                                                         }
2865                                                         numbusies++;
2866                                                         break;
2867                                                 case AST_CONTROL_CONGESTION:
2868                                                         ast_verb(3, "%s is circuit-busy\n", o->chan->name);
2869                                                         if (in->cdr)
2870                                                                 ast_cdr_busy(in->cdr);
2871                                                         endtime = (long) time(NULL);
2872                                                         endtime -= starttime;
2873                                                         rna(endtime*1000, qe, on, membername);
2874                                                         do_hang(o);
2875                                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2876                                                                 if (qe->parent->timeoutrestart)
2877                                                                         *to = orig;
2878                                                                 ring_one(qe, outgoing, &numbusies);
2879                                                         }
2880                                                         numbusies++;
2881                                                         break;
2882                                                 case AST_CONTROL_RINGING:
2883                                                         ast_verb(3, "%s is ringing\n", o->chan->name);
2884                                                         break;
2885                                                 case AST_CONTROL_OFFHOOK:
2886                                                         /* Ignore going off hook */
2887                                                         break;
2888                                                 default:
2889                                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
2890                                                 }
2891                                         }
2892                                         ast_frfree(f);
2893                                 } else {
2894                                         endtime = (long) time(NULL) - starttime;
2895