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