444f0fc52df6393db0f94f32d0e41db9e6d7af69
[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 = DEFAULT_TIMEOUT;
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                 /* If someone else answered the call we should indicate this in the CANCEL */
2232                 /* Hangup any existing lines we have open */
2233                 if (outgoing->chan && (outgoing->chan != exception)) {
2234                         if (exception)
2235                                 ast_set_flag(outgoing->chan, AST_FLAG_ANSWERED_ELSEWHERE);
2236                         ast_hangup(outgoing->chan);
2237                 }
2238                 oo = outgoing;
2239                 outgoing = outgoing->q_next;
2240                 if (oo->member)
2241                         ao2_ref(oo->member, -1);
2242                 ast_free(oo);
2243         }
2244 }
2245
2246 /*! 
2247  * \brief traverse all defined queues which have calls waiting and contain this member
2248  * \retval 0 if no other queue has precedence (higher weight) 
2249  * \retval 1 if found  
2250 */
2251 static int compare_weight(struct call_queue *rq, struct member *member)
2252 {
2253         struct call_queue *q;
2254         struct member *mem;
2255         int found = 0;
2256         struct ao2_iterator queue_iter;
2257         
2258         /* q's lock and rq's lock already set by try_calling()
2259          * to solve deadlock */
2260         queue_iter = ao2_iterator_init(queues, 0);
2261         while ((q = ao2_iterator_next(&queue_iter))) {
2262                 if (q == rq) { /* don't check myself, could deadlock */
2263                         queue_unref(q);
2264                         continue;
2265                 }
2266                 ao2_lock(q);
2267                 if (q->count && q->members) {
2268                         if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
2269                                 ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
2270                                 if (q->weight > rq->weight) {
2271                                         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);
2272                                         found = 1;
2273                                 }
2274                                 ao2_ref(mem, -1);
2275                         }
2276                 }
2277                 ao2_unlock(q);
2278                 queue_unref(q);
2279                 if (found) {
2280                         break;
2281                 }
2282         }
2283         return found;
2284 }
2285
2286 /*! \brief common hangup actions */
2287 static void do_hang(struct callattempt *o)
2288 {
2289         o->stillgoing = 0;
2290         ast_hangup(o->chan);
2291         o->chan = NULL;
2292 }
2293
2294 /*! \brief convert "\n" to "\nVariable: " ready for manager to use */
2295 static char *vars2manager(struct ast_channel *chan, char *vars, size_t len)
2296 {
2297         struct ast_str *buf = ast_str_thread_get(&global_app_buf, len + 1);
2298         char *tmp;
2299
2300         if (pbx_builtin_serialize_variables(chan, &buf)) {
2301                 int i, j;
2302
2303                 /* convert "\n" to "\nVariable: " */
2304                 strcpy(vars, "Variable: ");
2305                 tmp = ast_str_buffer(buf);
2306
2307                 for (i = 0, j = 10; (i < len - 1) && (j < len - 1); i++, j++) {
2308                         vars[j] = tmp[i];
2309
2310                         if (tmp[i + 1] == '\0')
2311                                 break;
2312                         if (tmp[i] == '\n') {
2313                                 vars[j++] = '\r';
2314                                 vars[j++] = '\n';
2315
2316                                 ast_copy_string(&(vars[j]), "Variable: ", len - j);
2317                                 j += 9;
2318                         }
2319                 }
2320                 if (j > len - 3)
2321                         j = len - 3;
2322                 vars[j++] = '\r';
2323                 vars[j++] = '\n';
2324                 vars[j] = '\0';
2325         } else {
2326                 /* there are no channel variables; leave it blank */
2327                 *vars = '\0';
2328         }
2329         return vars;
2330 }
2331
2332 /*! 
2333  * \brief Part 2 of ring_one
2334  *
2335  * Does error checking before attempting to request a channel and call a member. 
2336  * This function is only called from ring_one(). 
2337  * Failure can occur if:
2338  * - Agent on call
2339  * - Agent is paused
2340  * - Wrapup time not expired
2341  * - Priority by another queue
2342  *
2343  * \retval 1 on success to reach a free agent
2344  * \retval 0 on failure to get agent.
2345  */
2346 static int ring_entry(struct queue_ent *qe, struct callattempt *tmp, int *busies)
2347 {
2348         int res;
2349         int status;
2350         char tech[256];
2351         char *location;
2352         const char *macrocontext, *macroexten;
2353
2354         /* on entry here, we know that tmp->chan == NULL */
2355         if ((tmp->lastqueue && tmp->lastqueue->wrapuptime && (time(NULL) - tmp->lastcall < tmp->lastqueue->wrapuptime)) ||
2356                 (!tmp->lastqueue && qe->parent->wrapuptime && (time(NULL) - tmp->lastcall < qe->parent->wrapuptime))) {
2357                 ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n", 
2358                                 (tmp->lastqueue ? tmp->lastqueue->name : qe->parent->name), tmp->interface);
2359                 if (qe->chan->cdr)
2360                         ast_cdr_busy(qe->chan->cdr);
2361                 tmp->stillgoing = 0;
2362                 (*busies)++;
2363                 return 0;
2364         }
2365
2366         if (!qe->parent->ringinuse && (tmp->member->status != AST_DEVICE_NOT_INUSE) && (tmp->member->status != AST_DEVICE_UNKNOWN)) {
2367                 ast_debug(1, "%s in use, can't receive call\n", tmp->interface);
2368                 if (qe->chan->cdr)
2369                         ast_cdr_busy(qe->chan->cdr);
2370                 tmp->stillgoing = 0;
2371                 return 0;
2372         }
2373
2374         if (tmp->member->paused) {
2375                 ast_debug(1, "%s paused, can't receive call\n", tmp->interface);
2376                 if (qe->chan->cdr)
2377                         ast_cdr_busy(qe->chan->cdr);
2378                 tmp->stillgoing = 0;
2379                 return 0;
2380         }
2381         if (use_weight && compare_weight(qe->parent,tmp->member)) {
2382                 ast_debug(1, "Priority queue delaying call to %s:%s\n", qe->parent->name, tmp->interface);
2383                 if (qe->chan->cdr)
2384                         ast_cdr_busy(qe->chan->cdr);
2385                 tmp->stillgoing = 0;
2386                 (*busies)++;
2387                 return 0;
2388         }
2389
2390         ast_copy_string(tech, tmp->interface, sizeof(tech));
2391         if ((location = strchr(tech, '/')))
2392                 *location++ = '\0';
2393         else
2394                 location = "";
2395
2396         /* Request the peer */
2397         tmp->chan = ast_request(tech, qe->chan->nativeformats, location, &status);
2398         if (!tmp->chan) {                       /* If we can't, just go on to the next call */
2399                 if (qe->chan->cdr)
2400                         ast_cdr_busy(qe->chan->cdr);
2401                 tmp->stillgoing = 0;    
2402
2403                 ao2_lock(qe->parent);
2404                 update_status(qe->parent, tmp->member, ast_device_state(tmp->member->state_interface));
2405                 qe->parent->rrpos++;
2406                 qe->linpos++;
2407                 ao2_unlock(qe->parent);
2408
2409                 (*busies)++;
2410                 return 0;
2411         }
2412         
2413         tmp->chan->appl = "AppQueue";
2414         tmp->chan->data = "(Outgoing Line)";
2415         memset(&tmp->chan->whentohangup, 0, sizeof(tmp->chan->whentohangup));
2416         if (tmp->chan->cid.cid_num)
2417                 ast_free(tmp->chan->cid.cid_num);
2418         tmp->chan->cid.cid_num = ast_strdup(qe->chan->cid.cid_num);
2419         if (tmp->chan->cid.cid_name)
2420                 ast_free(tmp->chan->cid.cid_name);
2421         tmp->chan->cid.cid_name = ast_strdup(qe->chan->cid.cid_name);
2422         if (tmp->chan->cid.cid_ani)
2423                 ast_free(tmp->chan->cid.cid_ani);
2424         tmp->chan->cid.cid_ani = ast_strdup(qe->chan->cid.cid_ani);
2425
2426         /* Inherit specially named variables from parent channel */
2427         ast_channel_inherit_variables(qe->chan, tmp->chan);
2428
2429         /* Presense of ADSI CPE on outgoing channel follows ours */
2430         tmp->chan->adsicpe = qe->chan->adsicpe;
2431
2432         /* Inherit context and extension */
2433         ast_channel_lock(qe->chan);
2434         macrocontext = pbx_builtin_getvar_helper(qe->chan, "MACRO_CONTEXT");
2435         ast_string_field_set(tmp->chan, dialcontext, ast_strlen_zero(macrocontext) ? qe->chan->context : macrocontext);
2436         macroexten = pbx_builtin_getvar_helper(qe->chan, "MACRO_EXTEN");
2437         if (!ast_strlen_zero(macroexten))
2438                 ast_copy_string(tmp->chan->exten, macroexten, sizeof(tmp->chan->exten));
2439         else
2440                 ast_copy_string(tmp->chan->exten, qe->chan->exten, sizeof(tmp->chan->exten));
2441         ast_channel_unlock(qe->chan);
2442
2443         /* Place the call, but don't wait on the answer */
2444         if ((res = ast_call(tmp->chan, location, 0))) {
2445                 /* Again, keep going even if there's an error */
2446                 ast_debug(1, "ast call on peer returned %d\n", res);
2447                 ast_verb(3, "Couldn't call %s\n", tmp->interface);
2448                 do_hang(tmp);
2449                 (*busies)++;
2450                 update_status(qe->parent, tmp->member, ast_device_state(tmp->member->interface));
2451                 return 0;
2452         } else if (qe->parent->eventwhencalled) {
2453                 char vars[2048];
2454
2455                 manager_event(EVENT_FLAG_AGENT, "AgentCalled",
2456                                         "Queue: %s\r\n"
2457                                         "AgentCalled: %s\r\n"
2458                                         "AgentName: %s\r\n"
2459                                         "ChannelCalling: %s\r\n"
2460                                         "DestinationChannel: %s\r\n"
2461                                         "CallerIDNum: %s\r\n"
2462                                         "CallerIDName: %s\r\n"
2463                                         "Context: %s\r\n"
2464                                         "Extension: %s\r\n"
2465                                         "Priority: %d\r\n"
2466                                         "Uniqueid: %s\r\n"
2467                                         "%s",
2468                                         qe->parent->name, tmp->interface, tmp->member->membername, qe->chan->name, tmp->chan->name,
2469                                         tmp->chan->cid.cid_num ? tmp->chan->cid.cid_num : "unknown",
2470                                         tmp->chan->cid.cid_name ? tmp->chan->cid.cid_name : "unknown",
2471                                         qe->chan->context, qe->chan->exten, qe->chan->priority, qe->chan->uniqueid,
2472                                         qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2473                 ast_verb(3, "Called %s\n", tmp->interface);
2474         }
2475
2476         update_status(qe->parent, tmp->member, ast_device_state(tmp->member->interface));
2477         return 1;
2478 }
2479
2480 /*! \brief find the entry with the best metric, or NULL */
2481 static struct callattempt *find_best(struct callattempt *outgoing)
2482 {
2483         struct callattempt *best = NULL, *cur;
2484
2485         for (cur = outgoing; cur; cur = cur->q_next) {
2486                 if (cur->stillgoing &&                                  /* Not already done */
2487                         !cur->chan &&                                   /* Isn't already going */
2488                         (!best || cur->metric < best->metric)) {                /* We haven't found one yet, or it's better */
2489                         best = cur;
2490                 }
2491         }
2492
2493         return best;
2494 }
2495
2496 /*! 
2497  * \brief Place a call to a queue member.
2498  *
2499  * Once metrics have been calculated for each member, this function is used
2500  * to place a call to the appropriate member (or members). The low-level
2501  * channel-handling and error detection is handled in ring_entry
2502  *
2503  * \retval 1 if a member was called successfully
2504  * \retval 0 otherwise
2505  */
2506 static int ring_one(struct queue_ent *qe, struct callattempt *outgoing, int *busies)
2507 {
2508         int ret = 0;
2509
2510         while (ret == 0) {
2511                 struct callattempt *best = find_best(outgoing);
2512                 if (!best) {
2513                         ast_debug(1, "Nobody left to try ringing in queue\n");
2514                         break;
2515                 }
2516                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
2517                         struct callattempt *cur;
2518                         /* Ring everyone who shares this best metric (for ringall) */
2519                         for (cur = outgoing; cur; cur = cur->q_next) {
2520                                 if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
2521                                         ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
2522                                         ret |= ring_entry(qe, cur, busies);
2523                                 }
2524                         }
2525                 } else {
2526                         /* Ring just the best channel */
2527                         ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
2528                         ret = ring_entry(qe, best, busies);
2529                 }
2530                 
2531                 /* If we have timed out, break out */
2532                 if (qe->expire && (time(NULL) >= qe->expire)) {
2533                         ast_debug(1, "Queue timed out while ringing members.\n");
2534                         ret = 0;
2535                         break;
2536                 }
2537         }
2538
2539         return ret;
2540 }
2541
2542 /*! \brief Search for best metric and add to Round Robbin queue */
2543 static int store_next_rr(struct queue_ent *qe, struct callattempt *outgoing)
2544 {
2545         struct callattempt *best = find_best(outgoing);
2546
2547         if (best) {
2548                 /* Ring just the best channel */
2549                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2550                 qe->parent->rrpos = best->metric % 1000;
2551         } else {
2552                 /* Just increment rrpos */
2553                 if (qe->parent->wrapped) {
2554                         /* No more channels, start over */
2555                         qe->parent->rrpos = 0;
2556                 } else {
2557                         /* Prioritize next entry */
2558                         qe->parent->rrpos++;
2559                 }
2560         }
2561         qe->parent->wrapped = 0;
2562
2563         return 0;
2564 }
2565
2566 /*! \brief Search for best metric and add to Linear queue */
2567 static int store_next_lin(struct queue_ent *qe, struct callattempt *outgoing)
2568 {
2569         struct callattempt *best = find_best(outgoing);
2570
2571         if (best) {
2572                 /* Ring just the best channel */
2573                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2574                 qe->linpos = best->metric % 1000;
2575         } else {
2576                 /* Just increment rrpos */
2577                 if (qe->linwrapped) {
2578                         /* No more channels, start over */
2579                         qe->linpos = 0;
2580                 } else {
2581                         /* Prioritize next entry */
2582                         qe->linpos++;
2583                 }
2584         }
2585         qe->linwrapped = 0;
2586
2587         return 0;
2588 }
2589
2590 /*! \brief Playback announcement to queued members if peroid has elapsed */
2591 static int say_periodic_announcement(struct queue_ent *qe, int ringing)
2592 {
2593         int res = 0;
2594         time_t now;
2595
2596         /* Get the current time */
2597         time(&now);
2598
2599         /* Check to see if it is time to announce */
2600         if ((now - qe->last_periodic_announce_time) < qe->parent->periodicannouncefrequency)
2601                 return 0;
2602
2603         /* Stop the music on hold so we can play our own file */
2604         if (ringing)
2605                 ast_indicate(qe->chan,-1);
2606         else
2607                 ast_moh_stop(qe->chan);
2608
2609         ast_verb(3, "Playing periodic announcement\n");
2610         
2611         if (qe->parent->randomperiodicannounce) {
2612                 qe->last_periodic_announce_sound = ((unsigned long) ast_random()) % qe->parent->numperiodicannounce;
2613         } else if (qe->last_periodic_announce_sound >= qe->parent->numperiodicannounce || 
2614                 ast_str_strlen(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]) == 0) {
2615                 qe->last_periodic_announce_sound = 0;
2616         }
2617         
2618         /* play the announcement */
2619         res = play_file(qe->chan, ast_str_buffer(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]));
2620
2621         if ((res > 0 && !valid_exit(qe, res)) || res < 0)
2622                 res = 0;
2623
2624         /* Resume Music on Hold if the caller is going to stay in the queue */
2625         if (!res) {
2626                 if (ringing)
2627                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
2628                 else
2629                         ast_moh_start(qe->chan, qe->moh, NULL);
2630         }
2631
2632         /* update last_periodic_announce_time */
2633         qe->last_periodic_announce_time = now;
2634
2635         /* Update the current periodic announcement to the next announcement */
2636         if (!qe->parent->randomperiodicannounce) {
2637                 qe->last_periodic_announce_sound++;
2638         }
2639         
2640         return res;
2641 }
2642
2643 /*! \brief Record that a caller gave up on waiting in queue */
2644 static void record_abandoned(struct queue_ent *qe)
2645 {
2646         ao2_lock(qe->parent);
2647         set_queue_variables(qe);
2648         manager_event(EVENT_FLAG_AGENT, "QueueCallerAbandon",
2649                 "Queue: %s\r\n"
2650                 "Uniqueid: %s\r\n"
2651                 "Position: %d\r\n"
2652                 "OriginalPosition: %d\r\n"
2653                 "HoldTime: %d\r\n",
2654                 qe->parent->name, qe->chan->uniqueid, qe->pos, qe->opos, (int)(time(NULL) - qe->start));
2655
2656         qe->parent->callsabandoned++;
2657         ao2_unlock(qe->parent);
2658 }
2659
2660 /*! \brief RNA == Ring No Answer. Common code that is executed when we try a queue member and they don't answer. */
2661 static void rna(int rnatime, struct queue_ent *qe, char *interface, char *membername)
2662 {
2663         ast_verb(3, "Nobody picked up in %d ms\n", rnatime);
2664         if (qe->parent->eventwhencalled) {
2665                 char vars[2048];
2666
2667                 manager_event(EVENT_FLAG_AGENT, "AgentRingNoAnswer",
2668                                                 "Queue: %s\r\n"
2669                                                 "Uniqueid: %s\r\n"
2670                                                 "Channel: %s\r\n"
2671                                                 "Member: %s\r\n"
2672                                                 "MemberName: %s\r\n"
2673                                                 "Ringtime: %d\r\n"
2674                                                 "%s",
2675                                                 qe->parent->name,
2676                                                 qe->chan->uniqueid,
2677                                                 qe->chan->name,
2678                                                 interface,
2679                                                 membername,
2680                                                 rnatime,
2681                                                 qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2682         }
2683         ast_queue_log(qe->parent->name, qe->chan->uniqueid, membername, "RINGNOANSWER", "%d", rnatime);
2684         if (qe->parent->autopause) {
2685                 if (!set_member_paused(qe->parent->name, interface, "Auto-Pause", 1)) {
2686                         ast_verb(3, "Auto-Pausing Queue Member %s in queue %s since they failed to answer.\n", interface, qe->parent->name);
2687                 } else {
2688                         ast_verb(3, "Failed to pause Queue Member %s in queue %s!\n", interface, qe->parent->name);
2689                 }
2690         }
2691         return;
2692 }
2693
2694 #define AST_MAX_WATCHERS 256
2695 /*! \brief Wait for a member to answer the call
2696  *
2697  * \param[in] qe the queue_ent corresponding to the caller in the queue
2698  * \param[in] outgoing the list of callattempts. Relevant ones will have their chan and stillgoing parameters non-zero
2699  * \param[in] to the amount of time (in milliseconds) to wait for a response
2700  * \param[out] digit if a user presses a digit to exit the queue, this is the digit the caller pressed
2701  * \param[in] prebusies number of busy members calculated prior to calling wait_for_answer
2702  * \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
2703  * \param[in] forwardsallowed used to detect if we should allow call forwarding, based on the 'i' option to Queue()
2704  */
2705 static struct callattempt *wait_for_answer(struct queue_ent *qe, struct callattempt *outgoing, int *to, char *digit, int prebusies, int caller_disconnect, int forwardsallowed)
2706 {
2707         const char *queue = qe->parent->name;
2708         struct callattempt *o, *start = NULL, *prev = NULL;
2709         int status;
2710         int numbusies = prebusies;
2711         int numnochan = 0;
2712         int stillgoing = 0;
2713         int orig = *to;
2714         struct ast_frame *f;
2715         struct callattempt *peer = NULL;
2716         struct ast_channel *winner;
2717         struct ast_channel *in = qe->chan;
2718         char on[80] = "";
2719         char membername[80] = "";
2720         long starttime = 0;
2721         long endtime = 0;
2722 #ifdef HAVE_EPOLL
2723         struct callattempt *epollo;
2724 #endif
2725
2726         starttime = (long) time(NULL);
2727 #ifdef HAVE_EPOLL
2728         for (epollo = outgoing; epollo; epollo = epollo->q_next) {
2729                 if (epollo->chan)
2730                         ast_poll_channel_add(in, epollo->chan);
2731         }
2732 #endif
2733         
2734         while (*to && !peer) {
2735                 int numlines, retry, pos = 1;
2736                 struct ast_channel *watchers[AST_MAX_WATCHERS];
2737                 watchers[0] = in;
2738                 start = NULL;
2739
2740                 for (retry = 0; retry < 2; retry++) {
2741                         numlines = 0;
2742                         for (o = outgoing; o; o = o->q_next) { /* Keep track of important channels */
2743                                 if (o->stillgoing) {    /* Keep track of important channels */
2744                                         stillgoing = 1;
2745                                         if (o->chan) {
2746                                                 watchers[pos++] = o->chan;
2747                                                 if (!start)
2748                                                         start = o;
2749                                                 else
2750                                                         prev->call_next = o;
2751                                                 prev = o;
2752                                         }
2753                                 }
2754                                 numlines++;
2755                         }
2756                         if (pos > 1 /* found */ || !stillgoing /* nobody listening */ ||
2757                                 (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) /* ring would not be delivered */)
2758                                 break;
2759                         /* On "ringall" strategy we only move to the next penalty level
2760                            when *all* ringing phones are done in the current penalty level */
2761                         ring_one(qe, outgoing, &numbusies);
2762                         /* and retry... */
2763                 }
2764                 if (pos == 1 /* not found */) {
2765                         if (numlines == (numbusies + numnochan)) {
2766                                 ast_debug(1, "Everyone is busy at this time\n");
2767                         } else {
2768                                 ast_debug(3, "No one is answering queue '%s' (%d numlines / %d busies / %d failed channels)\n", queue, numlines, numbusies, numnochan);
2769                         }
2770                         *to = 0;
2771                         return NULL;
2772                 }
2773                 winner = ast_waitfor_n(watchers, pos, to);
2774                 for (o = start; o; o = o->call_next) {
2775                         if (o->stillgoing && (o->chan) &&  (o->chan->_state == AST_STATE_UP)) {
2776                                 if (!peer) {
2777                                         ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2778                                         peer = o;
2779                                 }
2780                         } else if (o->chan && (o->chan == winner)) {
2781
2782                                 ast_copy_string(on, o->member->interface, sizeof(on));
2783                                 ast_copy_string(membername, o->member->membername, sizeof(membername));
2784
2785                                 if (!ast_strlen_zero(o->chan->call_forward) && !forwardsallowed) {
2786                                         ast_verb(3, "Forwarding %s to '%s' prevented.\n", in->name, o->chan->call_forward);
2787                                         numnochan++;
2788                                         do_hang(o);
2789                                         winner = NULL;
2790                                         continue;
2791                                 } else if (!ast_strlen_zero(o->chan->call_forward)) {
2792                                         char tmpchan[256];
2793                                         char *stuff;
2794                                         char *tech;
2795
2796                                         ast_copy_string(tmpchan, o->chan->call_forward, sizeof(tmpchan));
2797                                         if ((stuff = strchr(tmpchan, '/'))) {
2798                                                 *stuff++ = '\0';
2799                                                 tech = tmpchan;
2800                                         } else {
2801                                                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", o->chan->call_forward, o->chan->context);
2802                                                 stuff = tmpchan;
2803                                                 tech = "Local";
2804                                         }
2805                                         /* Before processing channel, go ahead and check for forwarding */
2806                                         ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, o->chan->name);
2807                                         /* Setup parameters */
2808                                         o->chan = ast_request(tech, in->nativeformats, stuff, &status);
2809                                         if (!o->chan) {
2810                                                 ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s'\n", tech, stuff);
2811                                                 o->stillgoing = 0;
2812                                                 numnochan++;
2813                                         } else {
2814                                                 ast_channel_inherit_variables(in, o->chan);
2815                                                 ast_channel_datastore_inherit(in, o->chan);
2816                                                 if (o->chan->cid.cid_num)
2817                                                         ast_free(o->chan->cid.cid_num);
2818                                                 o->chan->cid.cid_num = ast_strdup(in->cid.cid_num);
2819
2820                                                 if (o->chan->cid.cid_name)
2821                                                         ast_free(o->chan->cid.cid_name);
2822                                                 o->chan->cid.cid_name = ast_strdup(in->cid.cid_name);
2823
2824                                                 ast_string_field_set(o->chan, accountcode, in->accountcode);
2825                                                 o->chan->cdrflags = in->cdrflags;
2826
2827                                                 if (in->cid.cid_ani) {
2828                                                         if (o->chan->cid.cid_ani)
2829                                                                 ast_free(o->chan->cid.cid_ani);
2830                                                         o->chan->cid.cid_ani = ast_strdup(in->cid.cid_ani);
2831                                                 }
2832                                                 if (o->chan->cid.cid_rdnis)
2833                                                         ast_free(o->chan->cid.cid_rdnis);
2834                                                 o->chan->cid.cid_rdnis = ast_strdup(S_OR(in->macroexten, in->exten));
2835                                                 if (ast_call(o->chan, tmpchan, 0)) {
2836                                                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
2837                                                         do_hang(o);
2838                                                         numnochan++;
2839                                                 }
2840                                         }
2841                                         /* Hangup the original channel now, in case we needed it */
2842                                         ast_hangup(winner);
2843                                         continue;
2844                                 }
2845                                 f = ast_read(winner);
2846                                 if (f) {
2847                                         if (f->frametype == AST_FRAME_CONTROL) {
2848                                                 switch (f->subclass) {
2849                                                 case AST_CONTROL_ANSWER:
2850                                                         /* This is our guy if someone answered. */
2851                                                         if (!peer) {
2852                                                                 ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2853                                                                 peer = o;
2854                                                         }
2855                                                         break;
2856                                                 case AST_CONTROL_BUSY:
2857                                                         ast_verb(3, "%s is busy\n", o->chan->name);
2858                                                         if (in->cdr)
2859                                                                 ast_cdr_busy(in->cdr);
2860                                                         do_hang(o);
2861                                                         endtime = (long) time(NULL);
2862                                                         endtime -= starttime;
2863                                                         rna(endtime*1000, qe, on, membername);
2864                                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2865                                                                 if (qe->parent->timeoutrestart)
2866                                                                         *to = orig;
2867                                                                 ring_one(qe, outgoing, &numbusies);
2868                                                         }
2869                                                         numbusies++;
2870                                                         break;
2871                                                 case AST_CONTROL_CONGESTION:
2872                                                         ast_verb(3, "%s is circuit-busy\n", o->chan->name);
2873                                                         if (in->cdr)
2874                                                                 ast_cdr_busy(in->cdr);
2875                                                         endtime = (long) time(NULL);
2876                                                         endtime -= starttime;
2877                                                         rna(endtime*1000, qe, on, membername);
2878                                                         do_hang(o);
2879                                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2880                                                                 if (qe->parent->timeoutrestart)
2881                                                                         *to = orig;
2882                                                                 ring_one(qe, outgoing, &numbusies);
2883                                                         }
2884                                                         numbusies++;
2885                                                         break;
2886                                                 case AST_CONTROL_RINGING:
2887                                                         ast_verb(3, "%s is ringing\n", o->chan->name);
2888                                                         break;
2889                                                 case AST_CONTROL_OFFHOOK:
2890                                                         /* Ignore going off hook */
2891                                                         break;
2892                                                 default:
2893                                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
2894                                                 }
2895                                         }
2896                                         ast_frfree(f);
2897                                 } else {
2898                                         endtime = (long) time(NULL) - starttime;
2899                                         rna(endtime * 1000, qe, on, membername);
2900                                         do_hang(o);
2901                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2902                                                 if (qe->parent->timeoutrestart)
2903                                                         *to = orig;
2904                                                 ring_one(qe, outgoing, &numbusies);
2905                                         }
2906                                 }
2907                         }
2908                 }
2909                 if (winner == in) {
2910                         f = ast_read(in);
2911                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
2912                                 /* Got hung up */
2913                                 *to = -1;
2914                                 if (f) {
2915                                         if (f->data.uint32) {
2916                                                 in->hangupcause = f->data.uint32;
2917                                         }
2918                                         ast_frfree(f);
2919                                 }
2920                                 return NULL;
2921                         }
2922                         if ((f->frametype == AST_FRAME_DTMF) && caller_disconnect && (f->subclass == '*')) {
2923                                 ast_verb(3, "User hit %c to disconnect call.\n", f->subclass);
2924                                 *to = 0;
2925                                 ast_frfree(f);
2926                                 return NULL;
2927                         }
2928                         if ((f->frametype == AST_FRAME_DTMF) && valid_exit(qe, f->subclass)) {
2929                                 ast_verb(3, "User pressed digit: %c\n", f->subclass);
2930                                 *to = 0;
2931                                 *digit = f->subclass;
2932                                 ast_frfree(f);
2933                                 return NULL;
2934                         }
2935                         ast_frfree(f);
2936                 }
2937                 if (!*to) {
2938                         for (o = start; o; o = o->call_next)
2939                                 rna(orig, qe, o->interface, o->member->membername);
2940                 }
2941         }
2942
2943 #ifdef HAVE_EPOLL
2944         for (epollo = outgoing; epollo; epollo = epollo->q_next) {
2945                 if (epollo->chan)
2946                         ast_poll_channel_del(in, epollo->chan);
2947         }
2948 #endif
2949
2950         return peer;
2951 }
2952
2953 /*! 
2954  * \brief Check if we should start attempting to call queue members.
2955  *
2956  * The behavior of this function is dependent first on whether autofill is enabled
2957  * and second on whether the ring strategy is ringall. If autofill is not enabled,
2958  * then return true if we're the head of the queue. If autofill is enabled, then
2959  * we count the available members and see if the number of available members is enough
2960  * that given our position in the queue, we would theoretically be able to connect to
2961  * one of those available members
2962  */
2963 static int is_our_turn(struct queue_ent *qe)
2964 {
2965         struct queue_ent *ch;
2966         struct member *cur;
2967         int avl = 0;
2968         int idx = 0;
2969         int res;
2970
2971         if (!qe->parent->autofill) {
2972                 /* Atomically read the parent head -- does not need a lock */
2973                 ch = qe->parent->head;
2974                 /* If we are now at the top of the head, break out */
2975                 if (ch == qe) {
2976                         ast_debug(1, "It's our turn (%s).\n", qe->chan->name);
2977                         res = 1;
2978                 } else {
2979                         ast_debug(1, "It's not our turn (%s).\n", qe->chan->name);
2980                         res = 0;
2981                 }       
2982
2983         } else {
2984                 /* This needs a lock. How many members are available to be served? */
2985                 ao2_lock(qe->parent);
2986                         
2987                 ch = qe->parent->head;
2988         
2989                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
2990                         ast_debug(1, "Even though there may be multiple members available, the strategy is ringall so only the head call is allowed in\n");
2991                         avl = 1;
2992                 } else {
2993                         struct ao2_iterator mem_iter = ao2_iterator_init(qe->parent->members, 0);
2994                         while ((cur = ao2_iterator_next(&mem_iter))) {
2995                                 switch (cur->status) {
2996                                 case AST_DEVICE_INUSE:
2997                                         if (!qe->parent->ringinuse)
2998                                                 break;
2999                                         /* else fall through */
3000                                 case AST_DEVICE_NOT_INUSE:
3001                                 case AST_DEVICE_UNKNOWN:
3002                                         if (!cur->paused)
3003                                                 avl++;
3004                                         break;
3005                                 }
3006                                 ao2_ref(cur, -1);
3007                         }
3008                 }
3009
3010                 ast_debug(1, "There are %d available members.\n", avl);
3011         
3012                 while ((idx < avl) && (ch) && (ch != qe)) {
3013                         if (!ch->pending)
3014                                 idx++;
3015                         ch = ch->next;                  
3016                 }
3017         
3018                 /* If the queue entry is within avl [the number of available members] calls from the top ... */
3019                 if (ch && idx < avl) {
3020                         ast_debug(1, "It's our turn (%s).\n", qe->chan->name);
3021                         res = 1;
3022                 } else {
3023                         ast_debug(1, "It's not our turn (%s).\n", qe->chan->name);
3024                         res = 0;
3025                 }
3026                 
3027                 ao2_unlock(qe->parent);
3028         }
3029
3030         return res;
3031 }
3032
3033 /*!
3034  * \brief update rules for queues
3035  *
3036  * Calculate min/max penalties making sure if relative they stay within bounds.
3037  * Update queues penalty and set dialplan vars, goto next list entry.
3038 */
3039 static void update_qe_rule(struct queue_ent *qe)
3040 {
3041         int max_penalty = qe->pr->max_relative ? qe->max_penalty + qe->pr->max_value : qe->pr->max_value;
3042         int min_penalty = qe->pr->min_relative ? qe->min_penalty + qe->pr->min_value : qe->pr->min_value;
3043         char max_penalty_str[20], min_penalty_str[20]; 
3044         /* a relative change to the penalty could put it below 0 */
3045         if (max_penalty < 0)
3046                 max_penalty = 0;
3047         if (min_penalty < 0)
3048                 min_penalty = 0;
3049         if (min_penalty > max_penalty)
3050                 min_penalty = max_penalty;
3051         snprintf(max_penalty_str, sizeof(max_penalty_str), "%d", max_penalty);
3052         snprintf(min_penalty_str, sizeof(min_penalty_str), "%d", min_penalty);
3053         pbx_builtin_setvar_helper(qe->chan, "QUEUE_MAX_PENALTY", max_penalty_str);
3054         pbx_builtin_setvar_helper(qe->chan, "QUEUE_MIN_PENALTY", min_penalty_str);
3055         qe->max_penalty = max_penalty;
3056         qe->min_penalty = min_penalty;
3057         ast_debug(3, "Setting max penalty to %d and min penalty to %d for caller %s since %d seconds have elapsed\n", qe->max_penalty, qe->min_penalty, qe->chan->name, qe->pr->time);
3058         qe->pr = AST_LIST_NEXT(qe->pr, list);
3059 }
3060
3061 /*! \brief The waiting areas for callers who are not actively calling members
3062  *
3063  * This function is one large loop. This function will return if a caller
3064  * either exits the queue or it becomes that caller's turn to attempt calling
3065  * queue members. Inside the loop, we service the caller with periodic announcements,
3066  * holdtime announcements, etc. as configured in queues.conf
3067  *
3068  * \retval  0 if the caller's turn has arrived
3069  * \retval -1 if the caller should exit the queue.
3070  */
3071 static int wait_our_turn(struct queue_ent *qe, int ringing, enum queue_result *reason)
3072 {
3073         int res = 0;
3074
3075         /* This is the holding pen for callers 2 through maxlen */
3076         for (;;) {
3077
3078                 if (is_our_turn(qe))
3079                         break;
3080
3081                 /* If we have timed out, break out */
3082                 if (qe->expire && (time(NULL) >= qe->expire)) {
3083                         *reason = QUEUE_TIMEOUT;
3084                         break;
3085                 }
3086
3087                 if (qe->parent->leavewhenempty) {
3088                         int status = 0;
3089
3090                         if ((status = get_member_status(qe->parent, qe->max_penalty, qe->min_penalty, qe->parent->leavewhenempty))) {
3091                                 *reason = QUEUE_LEAVEEMPTY;
3092                                 ast_queue_log(qe->parent->name, qe->chan->uniqueid, "NONE", "EXITEMPTY", "%d|%d|%ld", qe->pos, qe->opos, (long) time(NULL) - qe->start);
3093                                 leave_queue(qe);
3094                                 break;
3095                         }
3096                 }
3097
3098                 /* Make a position announcement, if enabled */
3099                 if (qe->parent->announcefrequency &&
3100                         (res = say_position(qe,ringing)))
3101                         break;
3102
3103                 /* If we have timed out, break out */
3104                 if (qe->expire && (time(NULL) >= qe->expire)) {
3105                         *reason = QUEUE_TIMEOUT;
3106                         break;
3107                 }
3108
3109                 /* Make a periodic announcement, if enabled */
3110                 if (qe->parent->periodicannouncefrequency &&
3111                         (res = say_periodic_announcement(qe,ringing)))
3112                         break;
3113                 
3114                 /* see if we need to move to the next penalty level for this queue */
3115                 while (qe->pr && ((time(NULL) - qe->start) >= qe->pr->time)) {
3116                         update_qe_rule(qe);
3117                 }
3118
3119                 /* If we have timed out, break out */
3120                 if (qe->expire && (time(NULL) >= qe->expire)) {
3121                         *reason = QUEUE_TIMEOUT;
3122                         break;
3123                 }
3124                 
3125                 /* Wait a second before checking again */
3126                 if ((res = ast_waitfordigit(qe->chan, RECHECK * 1000))) {
3127                         if (res > 0 && !valid_exit(qe, res))
3128                                 res = 0;
3129                         else
3130                                 break;
3131                 }
3132                 
3133                 /* If we have timed out, break out */
3134                 if (qe->expire && (time(NULL) >= qe->expire)) {
3135                         *reason = QUEUE_TIMEOUT;
3136                         break;
3137                 }
3138         }
3139
3140         return res;
3141 }
3142
3143 /*!
3144  * \brief update the queue status
3145  * \retval Always 0
3146 */
3147 static int update_queue(struct call_queue *q, struct member *member, int callcompletedinsl, int newtalktime)
3148 {
3149         int oldtalktime;
3150
3151         struct member *mem;
3152         struct call_queue *qtmp;
3153         struct ao2_iterator queue_iter; 
3154         
3155         if (shared_lastcall) {
3156                 queue_iter = ao2_iterator_init(queues, 0);
3157                 while ((qtmp = ao2_iterator_next(&queue_iter))) {
3158                         ao2_lock(qtmp);
3159                         if ((mem = ao2_find(qtmp->members, member, OBJ_POINTER))) {
3160                                 time(&mem->lastcall);
3161                                 mem->calls++;
3162                                 mem->lastqueue = q;
3163                                 ao2_ref(mem, -1);
3164                         }
3165                         ao2_unlock(qtmp);
3166                         ao2_ref(qtmp, -1);
3167                 }
3168         } else {
3169                 ao2_lock(q);
3170                 time(&member->lastcall);
3171                 member->calls++;
3172                 member->lastqueue = q;
3173                 ao2_unlock(q);
3174         }       
3175         ao2_lock(q);
3176         q->callscompleted++;
3177         if (callcompletedinsl)
3178                 q->callscompletedinsl++;
3179         /* Calculate talktime using the same exponential average as holdtime code*/
3180         oldtalktime = q->talktime;
3181         q->talktime = (((oldtalktime << 2) - oldtalktime) + newtalktime) >> 2;
3182         ao2_unlock(q);
3183         return 0;
3184 }
3185
3186 /*! \brief Calculate the metric of each member in the outgoing callattempts
3187  *
3188  * A numeric metric is given to each member depending on the ring strategy used
3189  * by the queue. Members with lower metrics will be called before members with
3190  * higher metrics
3191  * \retval -1 if penalties are exceeded
3192  * \retval 0 otherwise
3193  */
3194 static int calc_metric(struct call_queue *q, struct member *mem, int pos, struct queue_ent *qe, struct callattempt *tmp)
3195 {
3196         if ((qe->max_penalty && (mem->penalty > qe->max_penalty)) || (qe->min_penalty && (mem->penalty < qe->min_penalty)))
3197                 return -1;
3198
3199         switch (q->strategy) {
3200         case QUEUE_STRATEGY_RINGALL:
3201                 /* Everyone equal, except for penalty */
3202                 tmp->metric = mem->penalty * 1000000;
3203                 break;
3204         case QUEUE_STRATEGY_LINEAR:
3205                 if (pos < qe->linpos) {
3206                         tmp->metric = 1000 + pos;
3207                 } else {
3208                         if (pos > qe->linpos)
3209                                 /* Indicate there is another priority */
3210                                 qe->linwrapped = 1;
3211                         tmp->metric = pos;
3212                 }
3213                 tmp->metric += mem->penalty * 1000000;
3214                 break;
3215         case QUEUE_STRATEGY_RRMEMORY:
3216                 if (pos < q->rrpos) {
3217                         tmp->metric = 1000 + pos;
3218                 } else {
3219                         if (pos > q->rrpos)
3220                                 /* Indicate there is another priority */
3221                                 q->wrapped = 1;
3222                         tmp->metric = pos;
3223                 }
3224                 tmp->metric += mem->penalty * 1000000;
3225                 break;
3226         case QUEUE_STRATEGY_RANDOM:
3227                 tmp->metric = ast_random() % 1000;
3228                 tmp->metric += mem->penalty * 1000000;
3229                 break;
3230         case QUEUE_STRATEGY_WRANDOM:
3231                 tmp->metric = ast_random() % ((1 + mem->penalty) * 1000);
3232                 break;
3233         case QUEUE_STRATEGY_FEWESTCALLS:
3234                 tmp->metric = mem->calls;
3235                 tmp->metric += mem->penalty * 1000000;
3236                 break;
3237         case QUEUE_STRATEGY_LEASTRECENT:
3238                 if (!mem->lastcall)
3239                         tmp->metric = 0;
3240                 else
3241                         tmp->metric = 1000000 - (time(NULL) - mem->lastcall);
3242                 tmp->metric += mem->penalty * 1000000;
3243                 break;
3244         default:
3245                 ast_log(LOG_WARNING, "Can't calculate metric for unknown strategy %d\n", q->strategy);
3246                 break;
3247         }
3248         return 0;
3249 }
3250
3251 enum agent_complete_reason {
3252         CALLER,
3253         AGENT,
3254         TRANSFER
3255 };
3256
3257 /*! \brief Send out AMI message with member call completion status information */
3258 static void send_agent_complete(const struct queue_ent *qe, const char *queuename,
3259         const struct ast_channel *peer, const struct member *member, time_t callstart,
3260         char *vars, size_t vars_len, enum agent_complete_reason rsn)
3261 {
3262         const char *reason = NULL;      /* silence dumb compilers */
3263
3264         if (!qe->parent->eventwhencalled)
3265                 return;
3266
3267         switch (rsn) {
3268         case CALLER:
3269                 reason = "caller";
3270                 break;
3271         case AGENT:
3272                 reason = "agent";
3273                 break;
3274         case TRANSFER:
3275                 reason = "transfer";
3276                 break;
3277         }
3278
3279         manager_event(EVENT_FLAG_AGENT, "AgentComplete",
3280                 "Queue: %s\r\n"
3281                 "Uniqueid: %s\r\n"
3282                 "Channel: %s\r\n"
3283                 "Member: %s\r\n"
3284                 "MemberName: %s\r\n"
3285                 "HoldTime: %ld\r\n"
3286                 "TalkTime: %ld\r\n"
3287                 "Reason: %s\r\n"
3288                 "%s",
3289                 queuename, qe->chan->uniqueid, peer->name, member->interface, member->membername,
3290                 (long)(callstart - qe->start), (long)(time(NULL) - callstart), reason,
3291                 qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, vars_len) : "");
3292 }
3293
3294 struct queue_transfer_ds {
3295         struct queue_ent *qe;
3296         struct member *member;
3297         time_t starttime;
3298         int callcompletedinsl;
3299 };
3300
3301 static void queue_transfer_destroy(void *data)
3302 {
3303         struct queue_transfer_ds *qtds = data;
3304         ast_free(qtds);
3305 }
3306
3307 /*! \brief a datastore used to help correctly log attended transfers of queue callers
3308  */
3309 static const struct ast_datastore_info queue_transfer_info = {
3310         .type = "queue_transfer",
3311         .chan_fixup = queue_transfer_fixup,
3312         .destroy = queue_transfer_destroy,
3313 };
3314
3315 /*! \brief Log an attended transfer when a queue caller channel is masqueraded
3316  *
3317  * When a caller is masqueraded, we want to log a transfer. Fixup time is the closest we can come to when