5bd89013369979c9330142b863bcb080951e9573
[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 | CMP_STOP : 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 | CMP_STOP;
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, int lock_queue_container)
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, lock_queue_container ? 0 : F_AO2I_DONTLOCK);
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, int lock_queue_container)
1014 {
1015         struct member_interface *curint;
1016
1017         if (interface_exists_global(interface, lock_queue_container))
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, 0);
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, 1);
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, 0);
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(queues);
1647         ao2_lock(q);
1648         
1649         /* Temporarily set realtime  members dead so we can detect deleted ones.*/ 
1650         mem_iter = ao2_iterator_init(q->members, 0);
1651         while ((m = ao2_iterator_next(&mem_iter))) {
1652                 if (m->realtime)
1653                         m->dead = 1;
1654                 ao2_ref(m, -1);
1655         }
1656
1657         while ((interface = ast_category_browse(member_config, interface))) {
1658                 rt_handle_member_record(q, interface,
1659                         ast_variable_retrieve(member_config, interface, "uniqueid"),
1660                         S_OR(ast_variable_retrieve(member_config, interface, "membername"), interface),
1661                         ast_variable_retrieve(member_config, interface, "penalty"),
1662                         ast_variable_retrieve(member_config, interface, "paused"),
1663                         S_OR(ast_variable_retrieve(member_config, interface, "state_interface"), interface));
1664         }
1665
1666         /* Delete all realtime members that have been deleted in DB. */
1667         mem_iter = ao2_iterator_init(q->members, 0);
1668         while ((m = ao2_iterator_next(&mem_iter))) {
1669                 if (m->dead) {
1670                         ast_queue_log(q->name, "REALTIME", m->interface, "REMOVEMEMBER", "%s", "");
1671                         ao2_unlink(q->members, m);
1672                         remove_from_interfaces(m->state_interface, 0);
1673                         q->membercount--;
1674                 }
1675                 ao2_ref(m, -1);
1676         }
1677         ao2_unlock(q);
1678         ao2_unlock(queues);
1679         ast_config_destroy(member_config);
1680 }
1681
1682 static int join_queue(char *queuename, struct queue_ent *qe, enum queue_result *reason)
1683 {
1684         struct call_queue *q;
1685         struct queue_ent *cur, *prev = NULL;
1686         int res = -1;
1687         int pos = 0;
1688         int inserted = 0;
1689         enum queue_member_status status;
1690
1691         if (!(q = load_realtime_queue(queuename)))
1692                 return res;
1693
1694         ao2_lock(queues);
1695         ao2_lock(q);
1696
1697         /* This is our one */
1698         status = get_member_status(q, qe->max_penalty, qe->min_penalty);
1699         if (!q->joinempty && (status == QUEUE_NO_MEMBERS))
1700                 *reason = QUEUE_JOINEMPTY;
1701         else if ((q->joinempty == QUEUE_EMPTY_STRICT) && (status == QUEUE_NO_REACHABLE_MEMBERS || status == QUEUE_NO_UNPAUSED_REACHABLE_MEMBERS || status == QUEUE_NO_MEMBERS))
1702                 *reason = QUEUE_JOINUNAVAIL;
1703         else if ((q->joinempty == QUEUE_EMPTY_LOOSE) && (status == QUEUE_NO_REACHABLE_MEMBERS || status == QUEUE_NO_MEMBERS))
1704                 *reason = QUEUE_JOINUNAVAIL;
1705         else if (q->maxlen && (q->count >= q->maxlen))
1706                 *reason = QUEUE_FULL;
1707         else {
1708                 /* There's space for us, put us at the right position inside
1709                  * the queue.
1710                  * Take into account the priority of the calling user */
1711                 inserted = 0;
1712                 prev = NULL;
1713                 cur = q->head;
1714                 while (cur) {
1715                         /* We have higher priority than the current user, enter
1716                          * before him, after all the other users with priority
1717                          * higher or equal to our priority. */
1718                         if ((!inserted) && (qe->prio > cur->prio)) {
1719                                 insert_entry(q, prev, qe, &pos);
1720                                 inserted = 1;
1721                         }
1722                         cur->pos = ++pos;
1723                         prev = cur;
1724                         cur = cur->next;
1725                 }
1726                 /* No luck, join at the end of the queue */
1727                 if (!inserted)
1728                         insert_entry(q, prev, qe, &pos);
1729                 ast_copy_string(qe->moh, q->moh, sizeof(qe->moh));
1730                 ast_copy_string(qe->announce, q->announce, sizeof(qe->announce));
1731                 ast_copy_string(qe->context, q->context, sizeof(qe->context));
1732                 q->count++;
1733                 res = 0;
1734                 manager_event(EVENT_FLAG_CALL, "Join",
1735                         "Channel: %s\r\nCallerID: %s\r\nCallerIDName: %s\r\nQueue: %s\r\nPosition: %d\r\nCount: %d\r\nUniqueid: %s\r\n",
1736                         qe->chan->name,
1737                         S_OR(qe->chan->cid.cid_num, "unknown"), /* XXX somewhere else it is <unknown> */
1738                         S_OR(qe->chan->cid.cid_name, "unknown"),
1739                         q->name, qe->pos, q->count, qe->chan->uniqueid );
1740                 ast_debug(1, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, qe->chan->name, qe->pos );
1741         }
1742         ao2_unlock(q);
1743         ao2_unlock(queues);
1744
1745         return res;
1746 }
1747
1748 static int play_file(struct ast_channel *chan, const char *filename)
1749 {
1750         int res;
1751
1752         ast_stopstream(chan);
1753
1754         res = ast_streamfile(chan, filename, chan->language);
1755         if (!res)
1756                 res = ast_waitstream(chan, AST_DIGIT_ANY);
1757
1758         ast_stopstream(chan);
1759
1760         return res;
1761 }
1762
1763 /*!
1764  * \brief Check for valid exit from queue via goto
1765  * \retval 0 if failure
1766  * \retval 1 if successful
1767 */
1768 static int valid_exit(struct queue_ent *qe, char digit)
1769 {
1770         int digitlen = strlen(qe->digits);
1771
1772         /* Prevent possible buffer overflow */
1773         if (digitlen < sizeof(qe->digits) - 2) {
1774                 qe->digits[digitlen] = digit;
1775                 qe->digits[digitlen + 1] = '\0';
1776         } else {
1777                 qe->digits[0] = '\0';
1778                 return 0;
1779         }
1780
1781         /* If there's no context to goto, short-circuit */
1782         if (ast_strlen_zero(qe->context))
1783                 return 0;
1784
1785         /* If the extension is bad, then reset the digits to blank */
1786         if (!ast_canmatch_extension(qe->chan, qe->context, qe->digits, 1, qe->chan->cid.cid_num)) {
1787                 qe->digits[0] = '\0';
1788                 return 0;
1789         }
1790
1791         /* We have an exact match */
1792         if (!ast_goto_if_exists(qe->chan, qe->context, qe->digits, 1)) {
1793                 qe->valid_digits = 1;
1794                 /* Return 1 on a successful goto */
1795                 return 1;
1796         }
1797
1798         return 0;
1799 }
1800
1801 static int say_position(struct queue_ent *qe, int ringing)
1802 {
1803         int res = 0, avgholdmins, avgholdsecs, announceposition = 0;
1804         time_t now;
1805
1806         /* Let minannouncefrequency seconds pass between the start of each position announcement */
1807         time(&now);
1808         if ((now - qe->last_pos) < qe->parent->minannouncefrequency)
1809                 return 0;
1810
1811         /* If either our position has changed, or we are over the freq timer, say position */
1812         if ((qe->last_pos_said == qe->pos) && ((now - qe->last_pos) < qe->parent->announcefrequency))
1813                 return 0;
1814
1815         if (ringing) {
1816                 ast_indicate(qe->chan,-1);
1817         } else {
1818                 ast_moh_stop(qe->chan);
1819         }
1820
1821         if (qe->parent->announceposition == ANNOUNCEPOSITION_YES ||
1822                 qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN ||
1823                 (qe->parent->announceposition == ANNOUNCEPOSITION_LIMIT &&
1824                 qe->pos <= qe->parent->announcepositionlimit))
1825                         announceposition = 1;
1826
1827
1828         if (announceposition == 1) {
1829                 /* Say we're next, if we are */
1830                 if (qe->pos == 1) {
1831                         res = play_file(qe->chan, qe->parent->sound_next);
1832                         if (res)
1833                                 goto playout;
1834                         else
1835                                 goto posout;
1836                 } else {
1837                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
1838                                 /* More than Case*/
1839                                 res = play_file(qe->chan, qe->parent->queue_quantity1);
1840                                 if (res)
1841                                         goto playout;
1842                                 res = ast_say_number(qe->chan, qe->parent->announcepositionlimit, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
1843                                 if (res)
1844                                         goto playout;
1845                         } else {
1846                                 /* Normal Case */
1847                                 res = play_file(qe->chan, qe->parent->sound_thereare);
1848                                 if (res)
1849                                         goto playout;
1850                                 res = ast_say_number(qe->chan, qe->pos, AST_DIGIT_ANY, qe->chan->language, NULL); /* Needs gender */
1851                                 if (res)
1852                                         goto playout;
1853                         }
1854                         if (qe->parent->announceposition == ANNOUNCEPOSITION_MORE_THAN && qe->pos > qe->parent->announcepositionlimit){
1855                                 /* More than Case*/
1856                                 res = play_file(qe->chan, qe->parent->queue_quantity2);
1857                                 if (res)
1858                                         goto playout;
1859                         } else {
1860                                 res = play_file(qe->chan, qe->parent->sound_calls);
1861                                 if (res)
1862                                         goto playout;
1863                         }
1864                 }
1865         }
1866         /* Round hold time to nearest minute */
1867         avgholdmins = abs(((qe->parent->holdtime + 30) - (now - qe->start)) / 60);
1868
1869         /* If they have specified a rounding then round the seconds as well */
1870         if (qe->parent->roundingseconds) {
1871                 avgholdsecs = (abs(((qe->parent->holdtime + 30) - (now - qe->start))) - 60 * avgholdmins) / qe->parent->roundingseconds;
1872                 avgholdsecs *= qe->parent->roundingseconds;
1873         } else {
1874                 avgholdsecs = 0;
1875         }
1876
1877         ast_verb(3, "Hold time for %s is %d minute(s) %d seconds\n", qe->parent->name, avgholdmins, avgholdsecs);
1878
1879         /* If the hold time is >1 min, if it's enabled, and if it's not
1880            supposed to be only once and we have already said it, say it */
1881     if ((avgholdmins+avgholdsecs) > 0 && qe->parent->announceholdtime &&
1882         ((qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE && !qe->last_pos) ||
1883         !(qe->parent->announceholdtime == ANNOUNCEHOLDTIME_ONCE))) {
1884                 res = play_file(qe->chan, qe->parent->sound_holdtime);
1885                 if (res)
1886                         goto playout;
1887
1888                 if (avgholdmins > 1) {
1889                         res = ast_say_number(qe->chan, avgholdmins, AST_DIGIT_ANY, qe->chan->language, NULL);
1890                         if (res)
1891                                 goto playout;
1892
1893                         if (avgholdmins == 1) {
1894                                 res = play_file(qe->chan, qe->parent->sound_minute);
1895                                 if (res)
1896                                         goto playout;
1897                         } else {
1898                                 res = play_file(qe->chan, qe->parent->sound_minutes);
1899                                 if (res)
1900                                         goto playout;
1901                         }
1902                 }
1903                 if (avgholdsecs > 1) {
1904                         res = ast_say_number(qe->chan, avgholdmins > 1 ? avgholdsecs : avgholdmins * 60 + avgholdsecs, AST_DIGIT_ANY, qe->chan->language, NULL);
1905                         if (res)
1906                                 goto playout;
1907
1908                         res = play_file(qe->chan, qe->parent->sound_seconds);
1909                         if (res)
1910                                 goto playout;
1911                 }
1912
1913         }
1914
1915 posout:
1916         if (announceposition == 1){
1917                 if (qe->parent->announceposition) {
1918                         ast_verb(3, "Told %s in %s their queue position (which was %d)\n",
1919                                 qe->chan->name, qe->parent->name, qe->pos);
1920                 }
1921                 res = play_file(qe->chan, qe->parent->sound_thanks);
1922         }
1923 playout:
1924         if ((res > 0 && !valid_exit(qe, res)) || res < 0)
1925                 res = 0;
1926
1927         /* Set our last_pos indicators */
1928         qe->last_pos = now;
1929         qe->last_pos_said = qe->pos;
1930
1931         /* Don't restart music on hold if we're about to exit the caller from the queue */
1932         if (!res) {
1933                 if (ringing) {
1934                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
1935                 } else {
1936                         ast_moh_start(qe->chan, qe->moh, NULL);
1937                 }
1938         }
1939         return res;
1940 }
1941
1942 static void recalc_holdtime(struct queue_ent *qe, int newholdtime)
1943 {
1944         int oldvalue;
1945
1946         /* Calculate holdtime using an exponential average */
1947         /* Thanks to SRT for this contribution */
1948         /* 2^2 (4) is the filter coefficient; a higher exponent would give old entries more weight */
1949
1950         ao2_lock(qe->parent);
1951         oldvalue = qe->parent->holdtime;
1952         qe->parent->holdtime = (((oldvalue << 2) - oldvalue) + newholdtime) >> 2;
1953         ao2_unlock(qe->parent);
1954 }
1955
1956 /*! \brief Caller leaving queue.
1957  * 
1958  * Search the queue to find the leaving client, if found remove from queue
1959  * create manager event, move others up the queue.
1960 */
1961 static void leave_queue(struct queue_ent *qe)
1962 {
1963         struct call_queue *q;
1964         struct queue_ent *current, *prev = NULL;
1965         struct penalty_rule *pr_iter;
1966         int pos = 0;
1967
1968         if (!(q = qe->parent))
1969                 return;
1970         queue_ref(q);
1971         ao2_lock(q);
1972
1973         prev = NULL;
1974         for (current = q->head; current; current = current->next) {
1975                 if (current == qe) {
1976                         q->count--;
1977
1978                         /* Take us out of the queue */
1979                         manager_event(EVENT_FLAG_CALL, "Leave",
1980                                 "Channel: %s\r\nQueue: %s\r\nCount: %d\r\nUniqueid: %s\r\n",
1981                                 qe->chan->name, q->name,  q->count, qe->chan->uniqueid);
1982                         ast_debug(1, "Queue '%s' Leave, Channel '%s'\n", q->name, qe->chan->name );
1983                         /* Take us out of the queue */
1984                         if (prev)
1985                                 prev->next = current->next;
1986                         else
1987                                 q->head = current->next;
1988                         /* Free penalty rules */
1989                         while ((pr_iter = AST_LIST_REMOVE_HEAD(&qe->qe_rules, list)))
1990                                 ast_free(pr_iter);
1991                 } else {
1992                         /* Renumber the people after us in the queue based on a new count */
1993                         current->pos = ++pos;
1994                         prev = current;
1995                 }
1996         }
1997         ao2_unlock(q);
1998
1999         /*If the queue is a realtime queue, check to see if it's still defined in real time*/
2000         if (q->realtime) {
2001                 if (!ast_load_realtime("queues", "name", q->name, SENTINEL))
2002                         q->dead = 1;
2003         }
2004
2005         if (q->dead) {  
2006                 /* It's dead and nobody is in it, so kill it */
2007                 ao2_unlink(queues, q);
2008                 /* unref the container's reference to the queue */
2009                 queue_unref(q);
2010         }
2011         /* unref the explicit ref earlier in the function */
2012         queue_unref(q);
2013 }
2014
2015 /*! \brief Hang up a list of outgoing calls */
2016 static void hangupcalls(struct callattempt *outgoing, struct ast_channel *exception)
2017 {
2018         struct callattempt *oo;
2019
2020         while (outgoing) {
2021                 /* Hangup any existing lines we have open */
2022                 if (outgoing->chan && (outgoing->chan != exception))
2023                         ast_hangup(outgoing->chan);
2024                 oo = outgoing;
2025                 outgoing = outgoing->q_next;
2026                 if (oo->member)
2027                         ao2_ref(oo->member, -1);
2028                 ast_free(oo);
2029         }
2030 }
2031
2032 /*! 
2033  * \brief traverse all defined queues which have calls waiting and contain this member
2034  * \retval 0 if no other queue has precedence (higher weight) 
2035  * \retval 1 if found  
2036 */
2037 static int compare_weight(struct call_queue *rq, struct member *member)
2038 {
2039         struct call_queue *q;
2040         struct member *mem;
2041         int found = 0;
2042         struct ao2_iterator queue_iter;
2043         
2044         /* q's lock and rq's lock already set by try_calling()
2045          * to solve deadlock */
2046         queue_iter = ao2_iterator_init(queues, 0);
2047         while ((q = ao2_iterator_next(&queue_iter))) {
2048                 if (q == rq) { /* don't check myself, could deadlock */
2049                         queue_unref(q);
2050                         continue;
2051                 }
2052                 ao2_lock(q);
2053                 if (q->count && q->members) {
2054                         if ((mem = ao2_find(q->members, member, OBJ_POINTER))) {
2055                                 ast_debug(1, "Found matching member %s in queue '%s'\n", mem->interface, q->name);
2056                                 if (q->weight > rq->weight) {
2057                                         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);
2058                                         found = 1;
2059                                 }
2060                                 ao2_ref(mem, -1);
2061                         }
2062                 }
2063                 ao2_unlock(q);
2064                 if (found) {
2065                         queue_unref(q);
2066                         break;
2067                 }
2068                 queue_unref(q);
2069         }
2070         return found;
2071 }
2072
2073 /*! \brief common hangup actions */
2074 static void do_hang(struct callattempt *o)
2075 {
2076         o->stillgoing = 0;
2077         ast_hangup(o->chan);
2078         o->chan = NULL;
2079 }
2080
2081 /*! \brief convert "\n" to "\nVariable: " ready for manager to use */
2082 static char *vars2manager(struct ast_channel *chan, char *vars, size_t len)
2083 {
2084         struct ast_str *buf = ast_str_alloca(len + 1);
2085         char *tmp;
2086
2087         if (pbx_builtin_serialize_variables(chan, &buf)) {
2088                 int i, j;
2089
2090                 /* convert "\n" to "\nVariable: " */
2091                 strcpy(vars, "Variable: ");
2092                 tmp = buf->str;
2093
2094                 for (i = 0, j = 10; (i < len - 1) && (j < len - 1); i++, j++) {
2095                         vars[j] = tmp[i];
2096
2097                         if (tmp[i + 1] == '\0')
2098                                 break;
2099                         if (tmp[i] == '\n') {
2100                                 vars[j++] = '\r';
2101                                 vars[j++] = '\n';
2102
2103                                 ast_copy_string(&(vars[j]), "Variable: ", len - j);
2104                                 j += 9;
2105                         }
2106                 }
2107                 if (j > len - 3)
2108                         j = len - 3;
2109                 vars[j++] = '\r';
2110                 vars[j++] = '\n';
2111                 vars[j] = '\0';
2112         } else {
2113                 /* there are no channel variables; leave it blank */
2114                 *vars = '\0';
2115         }
2116         return vars;
2117 }
2118
2119 /*! 
2120  * \brief Part 2 of ring_one
2121  *
2122  * Does error checking before attempting to request a channel and call a member. 
2123  * This function is only called from ring_one(). 
2124  * Failure can occur if:
2125  * - Agent on call
2126  * - Agent is paused
2127  * - Wrapup time not expired
2128  * - Priority by another queue
2129  *
2130  * \retval 1 on success to reach a free agent
2131  * \retval 0 on failure to get agent.
2132  */
2133 static int ring_entry(struct queue_ent *qe, struct callattempt *tmp, int *busies)
2134 {
2135         int res;
2136         int status;
2137         char tech[256];
2138         char *location;
2139         const char *macrocontext, *macroexten;
2140
2141         /* on entry here, we know that tmp->chan == NULL */
2142         if ((tmp->lastqueue && tmp->lastqueue->wrapuptime && (time(NULL) - tmp->lastcall < tmp->lastqueue->wrapuptime)) ||
2143                 (!tmp->lastqueue && qe->parent->wrapuptime && (time(NULL) - tmp->lastcall < qe->parent->wrapuptime))) {
2144                 ast_debug(1, "Wrapuptime not yet expired on queue %s for %s\n", 
2145                                 (tmp->lastqueue ? tmp->lastqueue->name : qe->parent->name), tmp->interface);
2146                 if (qe->chan->cdr)
2147                         ast_cdr_busy(qe->chan->cdr);
2148                 tmp->stillgoing = 0;
2149                 (*busies)++;
2150                 return 0;
2151         }
2152
2153         if (!qe->parent->ringinuse && (tmp->member->status != AST_DEVICE_NOT_INUSE) && (tmp->member->status != AST_DEVICE_UNKNOWN)) {
2154                 ast_debug(1, "%s in use, can't receive call\n", tmp->interface);
2155                 if (qe->chan->cdr)
2156                         ast_cdr_busy(qe->chan->cdr);
2157                 tmp->stillgoing = 0;
2158                 return 0;
2159         }
2160
2161         if (tmp->member->paused) {
2162                 ast_debug(1, "%s paused, can't receive call\n", tmp->interface);
2163                 if (qe->chan->cdr)
2164                         ast_cdr_busy(qe->chan->cdr);
2165                 tmp->stillgoing = 0;
2166                 return 0;
2167         }
2168         if (use_weight && compare_weight(qe->parent,tmp->member)) {
2169                 ast_debug(1, "Priority queue delaying call to %s:%s\n", qe->parent->name, tmp->interface);
2170                 if (qe->chan->cdr)
2171                         ast_cdr_busy(qe->chan->cdr);
2172                 tmp->stillgoing = 0;
2173                 (*busies)++;
2174                 return 0;
2175         }
2176
2177         ast_copy_string(tech, tmp->interface, sizeof(tech));
2178         if ((location = strchr(tech, '/')))
2179                 *location++ = '\0';
2180         else
2181                 location = "";
2182
2183         /* Request the peer */
2184         tmp->chan = ast_request(tech, qe->chan->nativeformats, location, &status);
2185         if (!tmp->chan) {                       /* If we can't, just go on to the next call */
2186                 if (qe->chan->cdr)
2187                         ast_cdr_busy(qe->chan->cdr);
2188                 tmp->stillgoing = 0;
2189
2190                 update_status(tmp->member->state_interface, ast_device_state(tmp->member->state_interface));
2191
2192                 ao2_lock(qe->parent);
2193                 qe->parent->rrpos++;
2194                 qe->linpos++;
2195                 ao2_unlock(qe->parent);
2196
2197
2198                 (*busies)++;
2199                 return 0;
2200         }
2201         
2202         tmp->chan->appl = "AppQueue";
2203         tmp->chan->data = "(Outgoing Line)";
2204         memset(&tmp->chan->whentohangup, 0, sizeof(tmp->chan->whentohangup));
2205         if (tmp->chan->cid.cid_num)
2206                 ast_free(tmp->chan->cid.cid_num);
2207         tmp->chan->cid.cid_num = ast_strdup(qe->chan->cid.cid_num);
2208         if (tmp->chan->cid.cid_name)
2209                 ast_free(tmp->chan->cid.cid_name);
2210         tmp->chan->cid.cid_name = ast_strdup(qe->chan->cid.cid_name);
2211         if (tmp->chan->cid.cid_ani)
2212                 ast_free(tmp->chan->cid.cid_ani);
2213         tmp->chan->cid.cid_ani = ast_strdup(qe->chan->cid.cid_ani);
2214
2215         /* Inherit specially named variables from parent channel */
2216         ast_channel_inherit_variables(qe->chan, tmp->chan);
2217
2218         /* Presense of ADSI CPE on outgoing channel follows ours */
2219         tmp->chan->adsicpe = qe->chan->adsicpe;
2220
2221         /* Inherit context and extension */
2222         ast_channel_lock(qe->chan);
2223         macrocontext = pbx_builtin_getvar_helper(qe->chan, "MACRO_CONTEXT");
2224         ast_string_field_set(tmp->chan, dialcontext, ast_strlen_zero(macrocontext) ? qe->chan->context : macrocontext);
2225         macroexten = pbx_builtin_getvar_helper(qe->chan, "MACRO_EXTEN");
2226         if (!ast_strlen_zero(macroexten))
2227                 ast_copy_string(tmp->chan->exten, macroexten, sizeof(tmp->chan->exten));
2228         else
2229                 ast_copy_string(tmp->chan->exten, qe->chan->exten, sizeof(tmp->chan->exten));
2230         ast_channel_unlock(qe->chan);
2231
2232         /* Place the call, but don't wait on the answer */
2233         if ((res = ast_call(tmp->chan, location, 0))) {
2234                 /* Again, keep going even if there's an error */
2235                 ast_debug(1, "ast call on peer returned %d\n", res);
2236                 ast_verb(3, "Couldn't call %s\n", tmp->interface);
2237                 do_hang(tmp);
2238                 (*busies)++;
2239                 update_status(tmp->member->interface, ast_device_state(tmp->member->interface));
2240                 return 0;
2241         } else if (qe->parent->eventwhencalled) {
2242                 char vars[2048];
2243
2244                 manager_event(EVENT_FLAG_AGENT, "AgentCalled",
2245                                         "Queue: %s\r\n"
2246                                         "AgentCalled: %s\r\n"
2247                                         "AgentName: %s\r\n"
2248                                         "ChannelCalling: %s\r\n"
2249                                         "DestinationChannel: %s\r\n"
2250                                         "CallerIDNum: %s\r\n"
2251                                         "CallerIDName: %s\r\n"
2252                                         "Context: %s\r\n"
2253                                         "Extension: %s\r\n"
2254                                         "Priority: %d\r\n"
2255                                         "Uniqueid: %s\r\n"
2256                                         "%s",
2257                                         qe->parent->name, tmp->interface, tmp->member->membername, qe->chan->name, tmp->chan->name,
2258                                         tmp->chan->cid.cid_num ? tmp->chan->cid.cid_num : "unknown",
2259                                         tmp->chan->cid.cid_name ? tmp->chan->cid.cid_name : "unknown",
2260                                         qe->chan->context, qe->chan->exten, qe->chan->priority, qe->chan->uniqueid,
2261                                         qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2262                 ast_verb(3, "Called %s\n", tmp->interface);
2263         }
2264
2265         update_status(tmp->member->interface, ast_device_state(tmp->member->interface));
2266         return 1;
2267 }
2268
2269 /*! \brief find the entry with the best metric, or NULL */
2270 static struct callattempt *find_best(struct callattempt *outgoing)
2271 {
2272         struct callattempt *best = NULL, *cur;
2273
2274         for (cur = outgoing; cur; cur = cur->q_next) {
2275                 if (cur->stillgoing &&                                  /* Not already done */
2276                         !cur->chan &&                                   /* Isn't already going */
2277                         (!best || cur->metric < best->metric)) {                /* We haven't found one yet, or it's better */
2278                         best = cur;
2279                 }
2280         }
2281
2282         return best;
2283 }
2284
2285 /*! 
2286  * \brief Place a call to a queue member.
2287  *
2288  * Once metrics have been calculated for each member, this function is used
2289  * to place a call to the appropriate member (or members). The low-level
2290  * channel-handling and error detection is handled in ring_entry
2291  *
2292  * \retval 1 if a member was called successfully
2293  * \retval 0 otherwise
2294  */
2295 static int ring_one(struct queue_ent *qe, struct callattempt *outgoing, int *busies)
2296 {
2297         int ret = 0;
2298
2299         while (ret == 0) {
2300                 struct callattempt *best = find_best(outgoing);
2301                 if (!best) {
2302                         ast_debug(1, "Nobody left to try ringing in queue\n");
2303                         break;
2304                 }
2305                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
2306                         struct callattempt *cur;
2307                         /* Ring everyone who shares this best metric (for ringall) */
2308                         for (cur = outgoing; cur; cur = cur->q_next) {
2309                                 if (cur->stillgoing && !cur->chan && cur->metric <= best->metric) {
2310                                         ast_debug(1, "(Parallel) Trying '%s' with metric %d\n", cur->interface, cur->metric);
2311                                         ret |= ring_entry(qe, cur, busies);
2312                                 }
2313                         }
2314                 } else {
2315                         /* Ring just the best channel */
2316                         ast_debug(1, "Trying '%s' with metric %d\n", best->interface, best->metric);
2317                         ret = ring_entry(qe, best, busies);
2318                 }
2319                 
2320                 /* If we have timed out, break out */
2321                 if (qe->expire && (time(NULL) >= qe->expire)) {
2322                         if (option_debug)
2323                                 ast_log(LOG_DEBUG, "Queue timed out while ringing members.\n");
2324                         ret = 0;
2325                         break;
2326                 }
2327         }
2328
2329         return ret;
2330 }
2331
2332 /*! \brief Search for best metric and add to Round Robbin queue */
2333 static int store_next_rr(struct queue_ent *qe, struct callattempt *outgoing)
2334 {
2335         struct callattempt *best = find_best(outgoing);
2336
2337         if (best) {
2338                 /* Ring just the best channel */
2339                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2340                 qe->parent->rrpos = best->metric % 1000;
2341         } else {
2342                 /* Just increment rrpos */
2343                 if (qe->parent->wrapped) {
2344                         /* No more channels, start over */
2345                         qe->parent->rrpos = 0;
2346                 } else {
2347                         /* Prioritize next entry */
2348                         qe->parent->rrpos++;
2349                 }
2350         }
2351         qe->parent->wrapped = 0;
2352
2353         return 0;
2354 }
2355
2356 /*! \brief Search for best metric and add to Linear queue */
2357 static int store_next_lin(struct queue_ent *qe, struct callattempt *outgoing)
2358 {
2359         struct callattempt *best = find_best(outgoing);
2360
2361         if (best) {
2362                 /* Ring just the best channel */
2363                 ast_debug(1, "Next is '%s' with metric %d\n", best->interface, best->metric);
2364                 qe->linpos = best->metric % 1000;
2365         } else {
2366                 /* Just increment rrpos */
2367                 if (qe->linwrapped) {
2368                         /* No more channels, start over */
2369                         qe->linpos = 0;
2370                 } else {
2371                         /* Prioritize next entry */
2372                         qe->linpos++;
2373                 }
2374         }
2375         qe->linwrapped = 0;
2376
2377         return 0;
2378 }
2379
2380 /*! \brief Playback announcement to queued members if peroid has elapsed */
2381 static int say_periodic_announcement(struct queue_ent *qe, int ringing)
2382 {
2383         int res = 0;
2384         time_t now;
2385
2386         /* Get the current time */
2387         time(&now);
2388
2389         /* Check to see if it is time to announce */
2390         if ((now - qe->last_periodic_announce_time) < qe->parent->periodicannouncefrequency)
2391                 return 0;
2392
2393         /* Stop the music on hold so we can play our own file */
2394         if (ringing)
2395                 ast_indicate(qe->chan,-1);
2396         else
2397                 ast_moh_stop(qe->chan);
2398
2399         ast_verb(3, "Playing periodic announcement\n");
2400         
2401         if (qe->parent->randomperiodicannounce) {
2402                 qe->last_periodic_announce_sound = ((unsigned long) ast_random()) % qe->parent->numperiodicannounce;
2403         } else if (qe->last_periodic_announce_sound >= qe->parent->numperiodicannounce || 
2404                 ast_strlen_zero(qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]->str)) {
2405                 qe->last_periodic_announce_sound = 0;
2406         }
2407         
2408         /* play the announcement */
2409         res = play_file(qe->chan, qe->parent->sound_periodicannounce[qe->last_periodic_announce_sound]->str);
2410
2411         if ((res > 0 && !valid_exit(qe, res)) || res < 0)
2412                 res = 0;
2413
2414         /* Resume Music on Hold if the caller is going to stay in the queue */
2415         if (!res) {
2416                 if (ringing)
2417                         ast_indicate(qe->chan, AST_CONTROL_RINGING);
2418                 else
2419                         ast_moh_start(qe->chan, qe->moh, NULL);
2420         }
2421
2422         /* update last_periodic_announce_time */
2423         qe->last_periodic_announce_time = now;
2424
2425         /* Update the current periodic announcement to the next announcement */
2426         if (!qe->parent->randomperiodicannounce) {
2427                 qe->last_periodic_announce_sound++;
2428         }
2429         
2430         return res;
2431 }
2432
2433 /*! \brief Record that a caller gave up on waiting in queue */
2434 static void record_abandoned(struct queue_ent *qe)
2435 {
2436         ao2_lock(qe->parent);
2437         set_queue_variables(qe);
2438         manager_event(EVENT_FLAG_AGENT, "QueueCallerAbandon",
2439                 "Queue: %s\r\n"
2440                 "Uniqueid: %s\r\n"
2441                 "Position: %d\r\n"
2442                 "OriginalPosition: %d\r\n"
2443                 "HoldTime: %d\r\n",
2444                 qe->parent->name, qe->chan->uniqueid, qe->pos, qe->opos, (int)(time(NULL) - qe->start));
2445
2446         qe->parent->callsabandoned++;
2447         ao2_unlock(qe->parent);
2448 }
2449
2450 /*! \brief RNA == Ring No Answer. Common code that is executed when we try a queue member and they don't answer. */
2451 static void rna(int rnatime, struct queue_ent *qe, char *interface, char *membername)
2452 {
2453         ast_verb(3, "Nobody picked up in %d ms\n", rnatime);
2454         if (qe->parent->eventwhencalled) {
2455                 char vars[2048];
2456
2457                 manager_event(EVENT_FLAG_AGENT, "AgentRingNoAnswer",
2458                                                 "Queue: %s\r\n"
2459                                                 "Uniqueid: %s\r\n"
2460                                                 "Channel: %s\r\n"
2461                                                 "Member: %s\r\n"
2462                                                 "MemberName: %s\r\n"
2463                                                 "Ringtime: %d\r\n"
2464                                                 "%s",
2465                                                 qe->parent->name,
2466                                                 qe->chan->uniqueid,
2467                                                 qe->chan->name,
2468                                                 interface,
2469                                                 membername,
2470                                                 rnatime,
2471                                                 qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, sizeof(vars)) : "");
2472         }
2473         ast_queue_log(qe->parent->name, qe->chan->uniqueid, membername, "RINGNOANSWER", "%d", rnatime);
2474         if (qe->parent->autopause) {
2475                 if (!set_member_paused(qe->parent->name, interface, "Auto-Pause", 1)) {
2476                         ast_verb(3, "Auto-Pausing Queue Member %s in queue %s since they failed to answer.\n", interface, qe->parent->name);
2477                 } else {
2478                         ast_verb(3, "Failed to pause Queue Member %s in queue %s!\n", interface, qe->parent->name);
2479                 }
2480         }
2481         return;
2482 }
2483
2484 #define AST_MAX_WATCHERS 256
2485 /*! \brief Wait for a member to answer the call
2486  *
2487  * \param[in] qe the queue_ent corresponding to the caller in the queue
2488  * \param[in] outgoing the list of callattempts. Relevant ones will have their chan and stillgoing parameters non-zero
2489  * \param[in] to the amount of time (in milliseconds) to wait for a response
2490  * \param[out] digit if a user presses a digit to exit the queue, this is the digit the caller pressed
2491  * \param[in] prebusies number of busy members calculated prior to calling wait_for_answer
2492  * \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
2493  * \param[in] forwardsallowed used to detect if we should allow call forwarding, based on the 'i' option to Queue()
2494  */
2495 static struct callattempt *wait_for_answer(struct queue_ent *qe, struct callattempt *outgoing, int *to, char *digit, int prebusies, int caller_disconnect, int forwardsallowed)
2496 {
2497         const char *queue = qe->parent->name;
2498         struct callattempt *o, *start = NULL, *prev = NULL;
2499         int status;
2500         int numbusies = prebusies;
2501         int numnochan = 0;
2502         int stillgoing = 0;
2503         int orig = *to;
2504         struct ast_frame *f;
2505         struct callattempt *peer = NULL;
2506         struct ast_channel *winner;
2507         struct ast_channel *in = qe->chan;
2508         char on[80] = "";
2509         char membername[80] = "";
2510         long starttime = 0;
2511         long endtime = 0;
2512 #ifdef HAVE_EPOLL
2513         struct callattempt *epollo;
2514 #endif
2515
2516         starttime = (long) time(NULL);
2517 #ifdef HAVE_EPOLL
2518         for (epollo = outgoing; epollo; epollo = epollo->q_next) {
2519                 if (epollo->chan)
2520                         ast_poll_channel_add(in, epollo->chan);
2521         }
2522 #endif
2523         
2524         while (*to && !peer) {
2525                 int numlines, retry, pos = 1;
2526                 struct ast_channel *watchers[AST_MAX_WATCHERS];
2527                 watchers[0] = in;
2528                 start = NULL;
2529
2530                 for (retry = 0; retry < 2; retry++) {
2531                         numlines = 0;
2532                         for (o = outgoing; o; o = o->q_next) { /* Keep track of important channels */
2533                                 if (o->stillgoing) {    /* Keep track of important channels */
2534                                         stillgoing = 1;
2535                                         if (o->chan) {
2536                                                 watchers[pos++] = o->chan;
2537                                                 if (!start)
2538                                                         start = o;
2539                                                 else
2540                                                         prev->call_next = o;
2541                                                 prev = o;
2542                                         }
2543                                 }
2544                                 numlines++;
2545                         }
2546                         if (pos > 1 /* found */ || !stillgoing /* nobody listening */ ||
2547                                 (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) /* ring would not be delivered */)
2548                                 break;
2549                         /* On "ringall" strategy we only move to the next penalty level
2550                            when *all* ringing phones are done in the current penalty level */
2551                         ring_one(qe, outgoing, &numbusies);
2552                         /* and retry... */
2553                 }
2554                 if (pos == 1 /* not found */) {
2555                         if (numlines == (numbusies + numnochan)) {
2556                                 ast_debug(1, "Everyone is busy at this time\n");
2557                         } else {
2558                                 ast_log(LOG_NOTICE, "No one is answering queue '%s' (%d/%d/%d)\n", queue, numlines, numbusies, numnochan);
2559                         }
2560                         *to = 0;
2561                         return NULL;
2562                 }
2563                 winner = ast_waitfor_n(watchers, pos, to);
2564                 for (o = start; o; o = o->call_next) {
2565                         if (o->stillgoing && (o->chan) &&  (o->chan->_state == AST_STATE_UP)) {
2566                                 if (!peer) {
2567                                         ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2568                                         peer = o;
2569                                 }
2570                         } else if (o->chan && (o->chan == winner)) {
2571
2572                                 ast_copy_string(on, o->member->interface, sizeof(on));
2573                                 ast_copy_string(membername, o->member->membername, sizeof(membername));
2574
2575                                 if (!ast_strlen_zero(o->chan->call_forward) && !forwardsallowed) {
2576                                         ast_verb(3, "Forwarding %s to '%s' prevented.\n", in->name, o->chan->call_forward);
2577                                         numnochan++;
2578                                         do_hang(o);
2579                                         winner = NULL;
2580                                         continue;
2581                                 } else if (!ast_strlen_zero(o->chan->call_forward)) {
2582                                         char tmpchan[256];
2583                                         char *stuff;
2584                                         char *tech;
2585
2586                                         ast_copy_string(tmpchan, o->chan->call_forward, sizeof(tmpchan));
2587                                         if ((stuff = strchr(tmpchan, '/'))) {
2588                                                 *stuff++ = '\0';
2589                                                 tech = tmpchan;
2590                                         } else {
2591                                                 snprintf(tmpchan, sizeof(tmpchan), "%s@%s", o->chan->call_forward, o->chan->context);
2592                                                 stuff = tmpchan;
2593                                                 tech = "Local";
2594                                         }
2595                                         /* Before processing channel, go ahead and check for forwarding */
2596                                         ast_verb(3, "Now forwarding %s to '%s/%s' (thanks to %s)\n", in->name, tech, stuff, o->chan->name);
2597                                         /* Setup parameters */
2598                                         o->chan = ast_request(tech, in->nativeformats, stuff, &status);
2599                                         if (!o->chan) {
2600                                                 ast_log(LOG_NOTICE, "Unable to create local channel for call forward to '%s/%s'\n", tech, stuff);
2601                                                 o->stillgoing = 0;
2602                                                 numnochan++;
2603                                         } else {
2604                                                 ast_channel_inherit_variables(in, o->chan);
2605                                                 ast_channel_datastore_inherit(in, o->chan);
2606                                                 if (o->chan->cid.cid_num)
2607                                                         ast_free(o->chan->cid.cid_num);
2608                                                 o->chan->cid.cid_num = ast_strdup(in->cid.cid_num);
2609
2610                                                 if (o->chan->cid.cid_name)
2611                                                         ast_free(o->chan->cid.cid_name);
2612                                                 o->chan->cid.cid_name = ast_strdup(in->cid.cid_name);
2613
2614                                                 ast_string_field_set(o->chan, accountcode, in->accountcode);
2615                                                 o->chan->cdrflags = in->cdrflags;
2616
2617                                                 if (in->cid.cid_ani) {
2618                                                         if (o->chan->cid.cid_ani)
2619                                                                 ast_free(o->chan->cid.cid_ani);
2620                                                         o->chan->cid.cid_ani = ast_strdup(in->cid.cid_ani);
2621                                                 }
2622                                                 if (o->chan->cid.cid_rdnis)
2623                                                         ast_free(o->chan->cid.cid_rdnis);
2624                                                 o->chan->cid.cid_rdnis = ast_strdup(S_OR(in->macroexten, in->exten));
2625                                                 if (ast_call(o->chan, tmpchan, 0)) {
2626                                                         ast_log(LOG_NOTICE, "Failed to dial on local channel for call forward to '%s'\n", tmpchan);
2627                                                         do_hang(o);
2628                                                         numnochan++;
2629                                                 }
2630                                         }
2631                                         /* Hangup the original channel now, in case we needed it */
2632                                         ast_hangup(winner);
2633                                         continue;
2634                                 }
2635                                 f = ast_read(winner);
2636                                 if (f) {
2637                                         if (f->frametype == AST_FRAME_CONTROL) {
2638                                                 switch (f->subclass) {
2639                                                 case AST_CONTROL_ANSWER:
2640                                                         /* This is our guy if someone answered. */
2641                                                         if (!peer) {
2642                                                                 ast_verb(3, "%s answered %s\n", o->chan->name, in->name);
2643                                                                 peer = o;
2644                                                         }
2645                                                         break;
2646                                                 case AST_CONTROL_BUSY:
2647                                                         ast_verb(3, "%s is busy\n", o->chan->name);
2648                                                         if (in->cdr)
2649                                                                 ast_cdr_busy(in->cdr);
2650                                                         do_hang(o);
2651                                                         endtime = (long) time(NULL);
2652                                                         endtime -= starttime;
2653                                                         rna(endtime*1000, qe, on, membername);
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_CONGESTION:
2662                                                         ast_verb(3, "%s is circuit-busy\n", o->chan->name);
2663                                                         if (in->cdr)
2664                                                                 ast_cdr_busy(in->cdr);
2665                                                         endtime = (long) time(NULL);
2666                                                         endtime -= starttime;
2667                                                         rna(endtime*1000, qe, on, membername);
2668                                                         do_hang(o);
2669                                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2670                                                                 if (qe->parent->timeoutrestart)
2671                                                                         *to = orig;
2672                                                                 ring_one(qe, outgoing, &numbusies);
2673                                                         }
2674                                                         numbusies++;
2675                                                         break;
2676                                                 case AST_CONTROL_RINGING:
2677                                                         ast_verb(3, "%s is ringing\n", o->chan->name);
2678                                                         break;
2679                                                 case AST_CONTROL_OFFHOOK:
2680                                                         /* Ignore going off hook */
2681                                                         break;
2682                                                 default:
2683                                                         ast_debug(1, "Dunno what to do with control type %d\n", f->subclass);
2684                                                 }
2685                                         }
2686                                         ast_frfree(f);
2687                                 } else {
2688                                         endtime = (long) time(NULL) - starttime;
2689                                         rna(endtime * 1000, qe, on, membername);
2690                                         do_hang(o);
2691                                         if (qe->parent->strategy != QUEUE_STRATEGY_RINGALL) {
2692                                                 if (qe->parent->timeoutrestart)
2693                                                         *to = orig;
2694                                                 ring_one(qe, outgoing, &numbusies);
2695                                         }
2696                                 }
2697                         }
2698                 }
2699                 if (winner == in) {
2700                         f = ast_read(in);
2701                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
2702                                 /* Got hung up */
2703                                 *to = -1;
2704                                 if (f) {
2705                                         if (f->data.uint32) {
2706                                                 in->hangupcause = f->data.uint32;
2707                                         }
2708                                         ast_frfree(f);
2709                                 }
2710                                 return NULL;
2711                         }
2712                         if ((f->frametype == AST_FRAME_DTMF) && caller_disconnect && (f->subclass == '*')) {
2713                                 ast_verb(3, "User hit %c to disconnect call.\n", f->subclass);
2714                                 *to = 0;
2715                                 ast_frfree(f);
2716                                 return NULL;
2717                         }
2718                         if ((f->frametype == AST_FRAME_DTMF) && valid_exit(qe, f->subclass)) {
2719                                 ast_verb(3, "User pressed digit: %c\n", f->subclass);
2720                                 *to = 0;
2721                                 *digit = f->subclass;
2722                                 ast_frfree(f);
2723                                 return NULL;
2724                         }
2725                         ast_frfree(f);
2726                 }
2727                 if (!*to) {
2728                         for (o = start; o; o = o->call_next)
2729                                 rna(orig, qe, o->interface, o->member->membername);
2730                 }
2731         }
2732
2733 #ifdef HAVE_EPOLL
2734         for (epollo = outgoing; epollo; epollo = epollo->q_next) {
2735                 if (epollo->chan)
2736                         ast_poll_channel_del(in, epollo->chan);
2737         }
2738 #endif
2739
2740         return peer;
2741 }
2742
2743 /*! 
2744  * \brief Check if we should start attempting to call queue members.
2745  *
2746  * The behavior of this function is dependent first on whether autofill is enabled
2747  * and second on whether the ring strategy is ringall. If autofill is not enabled,
2748  * then return true if we're the head of the queue. If autofill is enabled, then
2749  * we count the available members and see if the number of available members is enough
2750  * that given our position in the queue, we would theoretically be able to connect to
2751  * one of those available members
2752  */
2753 static int is_our_turn(struct queue_ent *qe)
2754 {
2755         struct queue_ent *ch;
2756         struct member *cur;
2757         int avl = 0;
2758         int idx = 0;
2759         int res;
2760
2761         if (!qe->parent->autofill) {
2762                 /* Atomically read the parent head -- does not need a lock */
2763                 ch = qe->parent->head;
2764                 /* If we are now at the top of the head, break out */
2765                 if (ch == qe) {
2766                         ast_debug(1, "It's our turn (%s).\n", qe->chan->name);
2767                         res = 1;
2768                 } else {
2769                         ast_debug(1, "It's not our turn (%s).\n", qe->chan->name);
2770                         res = 0;
2771                 }       
2772
2773         } else {
2774                 /* This needs a lock. How many members are available to be served? */
2775                 ao2_lock(qe->parent);
2776                         
2777                 ch = qe->parent->head;
2778         
2779                 if (qe->parent->strategy == QUEUE_STRATEGY_RINGALL) {
2780                         ast_debug(1, "Even though there may be multiple members available, the strategy is ringall so only the head call is allowed in\n");
2781                         avl = 1;
2782                 } else {
2783                         struct ao2_iterator mem_iter = ao2_iterator_init(qe->parent->members, 0);
2784                         while ((cur = ao2_iterator_next(&mem_iter))) {
2785                                 switch (cur->status) {
2786                                 case AST_DEVICE_INUSE:
2787                                         if (!qe->parent->ringinuse)
2788                                                 break;
2789                                         /* else fall through */
2790                                 case AST_DEVICE_NOT_INUSE:
2791                                 case AST_DEVICE_UNKNOWN:
2792                                         if (!cur->paused)
2793                                                 avl++;
2794                                         break;
2795                                 }
2796                                 ao2_ref(cur, -1);
2797                         }
2798                 }
2799
2800                 ast_debug(1, "There are %d available members.\n", avl);
2801         
2802                 while ((idx < avl) && (ch) && (ch != qe)) {
2803                         if (!ch->pending)
2804                                 idx++;
2805                         ch = ch->next;                  
2806                 }
2807         
2808                 /* If the queue entry is within avl [the number of available members] calls from the top ... */
2809                 if (ch && idx < avl) {
2810                         ast_debug(1, "It's our turn (%s).\n", qe->chan->name);
2811                         res = 1;
2812                 } else {
2813                         ast_debug(1, "It's not our turn (%s).\n", qe->chan->name);
2814                         res = 0;
2815                 }
2816                 
2817                 ao2_unlock(qe->parent);
2818         }
2819
2820         return res;
2821 }
2822
2823 /*!
2824  * \brief update rules for queues
2825  *
2826  * Calculate min/max penalties making sure if relative they stay within bounds.
2827  * Update queues penalty and set dialplan vars, goto next list entry.
2828 */
2829 static void update_qe_rule(struct queue_ent *qe)
2830 {
2831         int max_penalty = qe->pr->max_relative ? qe->max_penalty + qe->pr->max_value : qe->pr->max_value;
2832         int min_penalty = qe->pr->min_relative ? qe->min_penalty + qe->pr->min_value : qe->pr->min_value;
2833         char max_penalty_str[20], min_penalty_str[20]; 
2834         /* a relative change to the penalty could put it below 0 */
2835         if (max_penalty < 0)
2836                 max_penalty = 0;
2837         if (min_penalty < 0)
2838                 min_penalty = 0;
2839         if (min_penalty > max_penalty)
2840                 min_penalty = max_penalty;
2841         snprintf(max_penalty_str, sizeof(max_penalty_str), "%d", max_penalty);
2842         snprintf(min_penalty_str, sizeof(min_penalty_str), "%d", min_penalty);
2843         pbx_builtin_setvar_helper(qe->chan, "QUEUE_MAX_PENALTY", max_penalty_str);
2844         pbx_builtin_setvar_helper(qe->chan, "QUEUE_MIN_PENALTY", min_penalty_str);
2845         qe->max_penalty = max_penalty;
2846         qe->min_penalty = min_penalty;
2847         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);
2848         qe->pr = AST_LIST_NEXT(qe->pr, list);
2849 }
2850
2851 /*! \brief The waiting areas for callers who are not actively calling members
2852  *
2853  * This function is one large loop. This function will return if a caller
2854  * either exits the queue or it becomes that caller's turn to attempt calling
2855  * queue members. Inside the loop, we service the caller with periodic announcements,
2856  * holdtime announcements, etc. as configured in queues.conf
2857  *
2858  * \retval  0 if the caller's turn has arrived
2859  * \retval -1 if the caller should exit the queue.
2860  */
2861 static int wait_our_turn(struct queue_ent *qe, int ringing, enum queue_result *reason)
2862 {
2863         int res = 0;
2864
2865         /* This is the holding pen for callers 2 through maxlen */
2866         for (;;) {
2867                 enum queue_member_status status;
2868
2869                 if (is_our_turn(qe))
2870                         break;
2871
2872                 /* If we have timed out, break out */
2873                 if (qe->expire && (time(NULL) >= qe->expire)) {
2874                         *reason = QUEUE_TIMEOUT;
2875                         break;
2876                 }
2877
2878                 status = get_member_status(qe->parent, qe->max_penalty, qe->min_penalty);
2879
2880                 /* leave the queue if no agents, if enabled */
2881                 if (qe->parent->leavewhenempty && (status == QUEUE_NO_MEMBERS)) {
2882                         *reason = QUEUE_LEAVEEMPTY;
2883                         ast_queue_log(qe->parent->name, qe->chan->uniqueid, "NONE", "EXITEMPTY", "%d|%d|%ld", qe->pos, qe->opos, (long) time(NULL) - qe->start);
2884                         leave_queue(qe);
2885                         break;
2886                 }
2887
2888                 /* leave the queue if no reachable agents, if enabled */
2889                 if ((qe->parent->leavewhenempty == QUEUE_EMPTY_STRICT) && (status == QUEUE_NO_REACHABLE_MEMBERS || status == QUEUE_NO_UNPAUSED_REACHABLE_MEMBERS)) {
2890                         *reason = QUEUE_LEAVEUNAVAIL;
2891                         ast_queue_log(qe->parent->name, qe->chan->uniqueid, "NONE", "EXITEMPTY", "%d|%d|%ld", qe->pos, qe->opos, (long) time(NULL) - qe->start);
2892                         leave_queue(qe);
2893                         break;
2894                 }
2895                 if ((qe->parent->leavewhenempty == QUEUE_EMPTY_LOOSE) && (status == QUEUE_NO_REACHABLE_MEMBERS)) {
2896                         *reason = QUEUE_LEAVEUNAVAIL;
2897                         ast_queue_log(qe->parent->name, qe->chan->uniqueid, "NONE", "EXITEMPTY", "%d|%d|%ld", qe->pos, qe->opos, (long) time(NULL) - qe->start);
2898                         leave_queue(qe);
2899                         break;
2900                 }
2901
2902                 /* Make a position announcement, if enabled */
2903                 if (qe->parent->announcefrequency &&
2904                         (res = say_position(qe,ringing)))
2905                         break;
2906
2907                 /* If we have timed out, break out */
2908                 if (qe->expire && (time(NULL) >= qe->expire)) {
2909                         *reason = QUEUE_TIMEOUT;
2910                         break;
2911                 }
2912
2913                 /* Make a periodic announcement, if enabled */
2914                 if (qe->parent->periodicannouncefrequency &&
2915                         (res = say_periodic_announcement(qe,ringing)))
2916                         break;
2917                 
2918                 /* see if we need to move to the next penalty level for this queue */
2919                 while (qe->pr && ((time(NULL) - qe->start) >= qe->pr->time)) {
2920                         update_qe_rule(qe);
2921                 }
2922
2923                 /* If we have timed out, break out */
2924                 if (qe->expire && (time(NULL) >= qe->expire)) {
2925                         *reason = QUEUE_TIMEOUT;
2926                         break;
2927                 }
2928                 
2929                 /* Wait a second before checking again */
2930                 if ((res = ast_waitfordigit(qe->chan, RECHECK * 1000))) {
2931                         if (res > 0 && !valid_exit(qe, res))
2932                                 res = 0;
2933                         else
2934                                 break;
2935                 }
2936                 
2937                 /* If we have timed out, break out */
2938                 if (qe->expire && (time(NULL) >= qe->expire)) {
2939                         *reason = QUEUE_TIMEOUT;
2940                         break;
2941                 }
2942         }
2943
2944         return res;
2945 }
2946
2947 /*!
2948  * \brief update the queue status
2949  * \retval Always 0
2950 */
2951 static int update_queue(struct call_queue *q, struct member *member, int callcompletedinsl)
2952 {
2953         struct member *mem;
2954         struct call_queue *qtmp;
2955         struct ao2_iterator queue_iter; 
2956         
2957         if (shared_lastcall) {
2958                 queue_iter = ao2_iterator_init(queues, 0);
2959                 while ((qtmp = ao2_iterator_next(&queue_iter))) {
2960                         ao2_lock(qtmp);
2961                         if ((mem = ao2_find(qtmp->members, member, OBJ_POINTER))) {
2962                                 time(&mem->lastcall);
2963                                 mem->calls++;
2964                                 mem->lastqueue = q;
2965                                 ao2_ref(mem, -1);
2966                         }
2967                         ao2_unlock(qtmp);
2968                         ao2_ref(qtmp, -1);
2969                 }
2970         } else {
2971                 ao2_lock(q);
2972                 time(&member->lastcall);
2973                 member->calls++;
2974                 member->lastqueue = q;
2975                 ao2_unlock(q);
2976         }       
2977         ao2_lock(q);
2978         q->callscompleted++;
2979         if (callcompletedinsl)
2980                 q->callscompletedinsl++;
2981         ao2_unlock(q);
2982         return 0;
2983 }
2984
2985 /*! \brief Calculate the metric of each member in the outgoing callattempts
2986  *
2987  * A numeric metric is given to each member depending on the ring strategy used
2988  * by the queue. Members with lower metrics will be called before members with
2989  * higher metrics
2990  * \retval -1 if penalties are exceeded
2991  * \retval 0 otherwise
2992  */
2993 static int calc_metric(struct call_queue *q, struct member *mem, int pos, struct queue_ent *qe, struct callattempt *tmp)
2994 {
2995         if ((qe->max_penalty && (mem->penalty > qe->max_penalty)) || (qe->min_penalty && (mem->penalty < qe->min_penalty)))
2996                 return -1;
2997
2998         switch (q->strategy) {
2999         case QUEUE_STRATEGY_RINGALL:
3000                 /* Everyone equal, except for penalty */
3001                 tmp->metric = mem->penalty * 1000000;
3002                 break;
3003         case QUEUE_STRATEGY_LINEAR:
3004                 if (pos < qe->linpos) {
3005                         tmp->metric = 1000 + pos;
3006                 } else {
3007                         if (pos > qe->linpos)
3008                                 /* Indicate there is another priority */
3009                                 qe->linwrapped = 1;
3010                         tmp->metric = pos;
3011                 }
3012                 tmp->metric += mem->penalty * 1000000;
3013                 break;
3014         case QUEUE_STRATEGY_RRMEMORY:
3015                 if (pos < q->rrpos) {
3016                         tmp->metric = 1000 + pos;
3017                 } else {
3018                         if (pos > q->rrpos)
3019                                 /* Indicate there is another priority */
3020                                 q->wrapped = 1;
3021                         tmp->metric = pos;
3022                 }
3023                 tmp->metric += mem->penalty * 1000000;
3024                 break;
3025         case QUEUE_STRATEGY_RANDOM:
3026                 tmp->metric = ast_random() % 1000;
3027                 tmp->metric += mem->penalty * 1000000;
3028                 break;
3029         case QUEUE_STRATEGY_WRANDOM:
3030                 tmp->metric = ast_random() % ((1 + mem->penalty) * 1000);
3031                 break;
3032         case QUEUE_STRATEGY_FEWESTCALLS:
3033                 tmp->metric = mem->calls;
3034                 tmp->metric += mem->penalty * 1000000;
3035                 break;
3036         case QUEUE_STRATEGY_LEASTRECENT:
3037                 if (!mem->lastcall)
3038                         tmp->metric = 0;
3039                 else
3040                         tmp->metric = 1000000 - (time(NULL) - mem->lastcall);
3041                 tmp->metric += mem->penalty * 1000000;
3042                 break;
3043         default:
3044                 ast_log(LOG_WARNING, "Can't calculate metric for unknown strategy %d\n", q->strategy);
3045                 break;
3046         }
3047         return 0;
3048 }
3049
3050 enum agent_complete_reason {
3051         CALLER,
3052         AGENT,
3053         TRANSFER
3054 };
3055
3056 /*! \brief Send out AMI message with member call completion status information */
3057 static void send_agent_complete(const struct queue_ent *qe, const char *queuename,
3058         const struct ast_channel *peer, const struct member *member, time_t callstart,
3059         char *vars, size_t vars_len, enum agent_complete_reason rsn)
3060 {
3061         const char *reason = NULL;      /* silence dumb compilers */
3062
3063         if (!qe->parent->eventwhencalled)
3064                 return;
3065
3066         switch (rsn) {
3067         case CALLER:
3068                 reason = "caller";
3069                 break;
3070         case AGENT:
3071                 reason = "agent";
3072                 break;
3073         case TRANSFER:
3074                 reason = "transfer";
3075                 break;
3076         }
3077
3078         manager_event(EVENT_FLAG_AGENT, "AgentComplete",
3079                 "Queue: %s\r\n"
3080                 "Uniqueid: %s\r\n"
3081                 "Channel: %s\r\n"
3082                 "Member: %s\r\n"
3083                 "MemberName: %s\r\n"
3084                 "HoldTime: %ld\r\n"
3085                 "TalkTime: %ld\r\n"
3086                 "Reason: %s\r\n"
3087                 "%s",
3088                 queuename, qe->chan->uniqueid, peer->name, member->interface, member->membername,
3089                 (long)(callstart - qe->start), (long)(time(NULL) - callstart), reason,
3090                 qe->parent->eventwhencalled == QUEUE_EVENT_VARIABLES ? vars2manager(qe->chan, vars, vars_len) : "");
3091 }
3092
3093 struct queue_transfer_ds {
3094         struct queue_ent *qe;
3095         struct member *member;
3096         int starttime;
3097 };
3098
3099 static void queue_transfer_destroy(void *data)
3100 {
3101         struct queue_transfer_ds *qtds = data;
3102         ast_free(qtds);
3103 }
3104
3105 /*! \brief a datastore used to help correctly log attended transfers of queue callers
3106  */
3107 static const struct ast_datastore_info queue_transfer_info = {
3108         .type = "queue_transfer",
3109         .chan_fixup = queue_transfer_fixup,
3110         .destroy = queue_transfer_destroy,
3111 };
3112
3113 /*! \brief Log an attended transfer when a queue caller channel is masqueraded
3114  *
3115  * When a caller is masqueraded, we want to log a transfer. Fixup time is the closest we can come to when
3116  * the actual transfer occurs. This happens during the masquerade after datastores are moved from old_chan
3117  * to new_chan. This is why new_chan is referenced for exten, context, and datastore information.
3118  *
3119  * At the end of this, we want to remove the datastore so that this fixup function is not called on any
3120  * future masquerades of the caller during the current call.
3121  */
3122 static void queue_transfer_fixup(void *data, struct ast_channel *old_chan, struct ast_channel *new_chan) 
3123 {
3124         struct queue_transfer_ds *qtds = data;
3125         struct queue_ent *qe = qtds->qe;
3126         struct member *member = qtds->member;
3127         int callstart = qtds->starttime;
3128         struct ast_datastore *datastore;
3129
3130         ast_queue_log(qe->parent->name, qe->chan->uniqueid, member->membername, "TRANSFER", "%s|%s|%ld|%ld|%d",
3131                                 new_chan->exten, new_chan->context, (long) (callstart - qe->start),
3132                                 (long) (time(NULL) - callstart), qe->opos);
3133         
3134         if (!(datastore = ast_channel_datastore_find(new_chan, &queue_transfer_info, NULL))) {
3135                 ast_log(LOG_WARNING, "Can't find the queue_transfer datastore.\n");
3136                 return;
3137         }
3138
3139         ast_channel_datastore_remove(new_chan, datastore);
3140         ast_datastore_free(datastore);
3141 }
3142
3143 /*! \brief mechanism to tell if a queue caller was atxferred by a queue member.
3144  *
3145  * When a caller is atxferred, then the queue_transfer_info datastore
3146  * is removed from the channel. If it's still there after the bridge is
3147  * broken, then the caller was not atxferred.
3148  */
3149 static int attended_transfer_occurred(struct ast_channel *chan)
3150 {
3151         return ast_channel_datastore_find(chan, &queue_transfer_info, NULL) ? 0 : 1;
3152 }
3153
3154 /*! \brief create a datastore for storing relevant info to log attended transfers in the queue_log
3155  */
3156 static void setup_transfer_datastore(struct queue_ent *qe, struct member *member, int starttime)
3157 {
3158         struct ast_datastore *ds;
3159         struct queue_transfer_ds *qtds = ast_calloc(1, sizeof(*qtds));
3160
3161         if (!qtds) {
3162                 ast_log(LOG_WARNING, "Memory allocation error!\n");
3163                 return;
3164         }
3165
3166         ast_channel_lock(qe->chan);
3167         if (!(ds = ast_datastore_alloc(&queue_transfer_info, NULL))) {
3168                 ast_channel_unlock(qe->chan);
3169                 ast_log(LOG_WARNING, "Unable to create transfer datastore. queue_log will not show attended transfer\n");
3170                 return;
3171         }
3172
3173         qtds->qe = qe;
3174         /* This member is refcounted in try_calling, so no need to add it here, too */
3175         qtds->member = member;
3176         qtds->starttime = starttime;
3177         ds->data = qtds;
3178         ast_channel_datastore_add(qe->chan, ds);
3179         ast_channel_unlock(qe->chan);
3180 }
3181
3182 /*! \brief A large function which calls members, updates statistics, and bridges the caller and a member
3183  * 
3184  * Here is the process of this function
3185  * 1. Process any options passed to the Queue() application. Options here mean the third argument to Queue()
3186  * 2. Iterate trough the members of the queue, creating a callattempt corresponding to each member. During this
3187  *    iteration, we also check the dialed_interfaces datastore to see if we have already attempted calling this
3188  *    member. If we have, we do not create a callattempt. This is in place to prevent call forwarding loops. Also
3189  *    during each iteration, we call calc_metric to determine which members should be rung when.
3190  * 3. Call ring_one to place a call to the appropriate member(s)
3191  * 4. Call wait_for_answer to wait for an answer. If no one answers, return.
3192  * 5. Take care of any holdtime announcements, member delays, or other options which occur after a call has been answered.
3193  * 6. Start the monitor or mixmonitor if the option is set
3194  * 7. Remove the caller from the queue to allow other callers to advance
3195  * 8. Bridge the call.
3196  * 9. Do any post processing after the call has disconnected.
3197  *
3198  * \param[in] qe the queue_ent structure which corresponds to the caller attempting to reach members
3199  * \param[in] options the options passed as the third parameter to the Queue() application
3200  * \param[in] announceoverride filename to play to user when waiting 
3201  * \param[in] url the url passed as the fourth parameter to the Queue() application
3202  * \param[in,out] tries the number of times we have tried calling queue members
3203  * \param[out] noption set if the call to Queue() has the 'n' option set.
3204  * \param[in] agi the agi passed as the fifth parameter to the Queue() application
3205  * \param[in] macro the macro passed as the sixth parameter to the Queue() application
3206  * \param[in] gosub the gosub passed as the seventh parameter to the Queue() application
3207  * \param[in] ringing 1 if the 'r' option is set, otherwise 0
3208  */
3209 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)
3210 {
3211         struct member *cur;
3212         struct callattempt *outgoing = NULL; /* the list of calls we are building */
3213         int to, orig;
3214         char oldexten[AST_MAX_EXTENSION]="";
3215         char oldcontext[AST_MAX_CONTEXT]="";
3216         char queuename[256]="";
3217         char interfacevar[256]="";
3218         struct ast_channel *peer;
3219         struct ast_channel *which;
3220         struct callattempt *lpeer;
3221         struct member *member;
3222         struct ast_app *application;
3223         int res = 0, bridge = 0;
3224         int numbusies = 0;
3225         int x=0;
3226         char *announce = NULL;
3227         char digit = 0;
3228         time_t callstart;
3229         time_t now = time(NULL);
3230         struct ast_bridge_config bridge_config;
3231         char nondataquality = 1;
3232         char *agiexec = NULL;
3233         char *macroexec = NULL;
3234         char *gosubexec = NULL;
3235         int ret = 0;
3236         const char *monitorfilename;
3237         const char *monitor_exec;
3238         const char *monitor_options;
3239         char tmpid[256], tmpid2[256];
3240         char meid[1024], meid2[1024];
3241         char mixmonargs[1512];
3242         struct ast_app *mixmonapp = NULL;
3243         char *p;
3244         char vars[2048];
3245         int forwardsallowed = 1;
3246         int callcompletedinsl;
3247         struct ao2_iterator memi;
3248         struct ast_datastore *datastore;
3249
3250         ast_channel_lock(qe->chan);
3251         datastore = ast_channel_datastore_find(qe->chan, &dialed_interface_info, NULL);
3252         ast_channel_unlock(qe->chan);
3253
3254         memset(&bridge_config, 0, sizeof(bridge_config));
3255         tmpid[0] = 0;
3256         meid[0] = 0;
3257         time(&now);
3258
3259         /* If we've already exceeded our timeout, then just stop
3260          * This should be extremely rare. queue_exec will take care
3261          * of removing the caller and reporting the timeout as the reason.
3262          */
3263         if (qe->expire && now >= qe->expire) {
3264                 res = 0;
3265                 goto out;
3266         }
3267                 
3268         for (; options && *options; options++)
3269                 switch (*options) {
3270                 case 't':
3271                         ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_REDIRECT);
3272                         break;
3273                 case 'T':
3274                         ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_REDIRECT);
3275                         break;
3276                 case 'w':
3277                         ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_AUTOMON);
3278                         break;
3279                 case 'W':
3280                         ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_AUTOMON);
3281                         break;
3282                 case 'd':
3283                         nondataquality = 0;
3284                         break;
3285                 case 'h':
3286                         ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_DISCONNECT);
3287                         break;
3288                 case 'H':
3289                         ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_DISCONNECT);
3290                         break;
3291                 case 'k':
3292                         ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_PARKCALL);
3293                         break;
3294                 case 'K':
3295                         ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_PARKCALL);
3296                         break;
3297                 case 'n':
3298                         if (qe->parent->strategy == QUEUE_STRATEGY_RRMEMORY || qe->parent->strategy == QUEUE_STRATEGY_LINEAR)
3299                                 (*tries)++;
3300                         else
3301                                 *tries = qe->parent->membercount;
3302                         *noption = 1;
3303                         break;
3304                 case 'i':
3305                         forwardsallowed = 0;
3306                         break;
3307                 case 'x':
3308                         ast_set_flag(&(bridge_config.features_callee), AST_FEATURE_AUTOMIXMON);
3309                         break;
3310                 case 'X':
3311                         ast_set_flag(&(bridge_config.features_caller), AST_FEATURE_AUTOMIXMON);
3312                         break;
3313
3314                 }
3315
3316         /* Hold the lock while we setup the outgoing calls */
3317         if (use_weight)
3318                 ao2_lock(queues);
3319         ao2_lock(qe->parent);
3320         ast_debug(1, "%s is trying to call a queue member.\n",
3321                                                         qe->chan->name);
3322         ast_copy_string(queuename, qe->parent->name, sizeof(queuename));
3323         if (!ast_strlen_zero(qe->announce))
3324                 announce = qe->announce;
3325         if (!ast_strlen_zero(announceoverride))
3326                 announce = announceoverride;
3327
3328         memi = ao2_iterator_init(qe->parent->members, 0);
3329         while ((cur = ao2_iterator_next(&memi))) {
3330                 struct callattempt *tmp = ast_calloc(1, sizeof(*tmp));
3331                 struct ast_dialed_interface *di;
3332                 AST_LIST_HEAD(, ast_dialed_interface) *dialed_interfaces;
3333                 if (!tmp) {
3334                         ao2_ref(cur, -1);
3335                         ao2_unlock(qe->parent);
3336                         if (use_weight)
3337                                 ao2_unlock(queues);
3338                         goto out;
3339                 }
3340                 if (!datastore) {
3341                         if (!(datastore = ast_datastore_alloc(&dialed_interface_info, NULL))) {
3342                                 ao2_ref(cur, -1);
3343                                 ao2_unlock(qe->parent);
3344                                 if (use_weight)
3345                                         ao2_unlock(queues);
3346                                 free(tmp);
3347                                 goto out;
3348                         }
3349                         datastore->inheritance = DATASTORE_INHERIT_FOREVER;
3350                         if (!(dialed_interfaces = ast_calloc(1, sizeof(*dialed_interfaces)))) {
3351                                 ao2_ref(cur, -1);
3352                                 ao2_unlock(&qe->parent);
3353                                 if (use_weight)
3354                                         ao2_unlock(queues);
3355                                 free(tmp);
3356                                 goto out;
3357                         }
3358                         datastore->data = dialed_interfaces;
3359                         AST_LIST_HEAD_INIT(dialed_interfaces);
3360
3361                         ast_channel_lock(qe->chan);
3362                         ast_channel_datastore_add(qe->chan, datastore);
3363                         ast_channel_unlock(qe->chan);
3364                 } else
3365                         dialed_interfaces = datastore->data;
3366
3367                 AST_LIST_LOCK(dialed_interfaces);
3368                 AST_LIST_TRAVERSE(dialed_interfaces, di, list) {
3369                         if (!strcasecmp(cur->interface, di->interface)) {
3370                                 ast_log(LOG_DEBUG, "Skipping dialing interface '%s' since it has already been dialed\n", 
3371                                         di->interface);
3372                                 break;
3373                         }
3374                 }
3375                 AST_LIST_UNLOCK(dialed_interfaces);
3376                 
3377                 if (di) {
3378                         free(tmp);
3379                         continue;
3380                 }
3381
3382                 /* It is always ok to dial a Local interface.  We only keep track of
3383                  * which "real" interfaces have been dialed.  The Local channel will
3384                  * inherit this list so that if it ends up dialing a real interface,
3385                  * it won't call one that has already been called. */
3386                 if (strncasecmp(cur->interface, "Local/", 6)) {
3387                         if (!(di = ast_calloc(1, sizeof(*di) + strlen(cur->interface)))) {
3388                                 ao2_ref(cur, -1);
3389                                 ao2_unlock(qe->parent);
3390                                 if (use_weight)
3391                                         ao2_unlock(queues);
3392                                 free(tmp);
3393                                 goto out;
3394                         }
3395                         strcpy(di->interface, cur->interface);
3396
3397                         AST_LIST_LOCK(dialed_interfaces);
3398                         AST_LIST_INSERT_TAIL(dialed_interfaces, di, list);
3399                         AST_LIST_UNLOCK(dialed_interfaces);
3400                 }
3401
3402                 tmp->stillgoing = -1;
3403                 tmp->member = cur;
3404                 tmp->oldstatus = cur->status;
3405                 tmp->lastcall = cur->lastcall;
3406                 tmp->lastqueue = cur->lastqueue;
3407                 ast_copy_string(tmp->interface, cur->interface, sizeof(tmp->interface));
3408                 /* Special case: If we ring everyone, go ahead and ring them, otherwise
3409                    just calculate their metric for the appropriate strategy */
3410                 if (!calc_metric(qe->parent, cur, x++, qe, tmp)) {
3411                         /* Put them in the list of outgoing thingies...  We're ready now.
3412                            XXX If we're forcibly removed, these outgoing calls won't get
3413                            hung up XXX */
3414                         tmp->q_next = outgoing;
3415                         outgoing = tmp;         
3416                         /* If this line is up, don't try anybody else */
3417                         if (outgoing->chan && (outgoing->chan->_state == AST_STATE_UP))
3418                                 break;
3419                 } else {
3420                         ao2_ref(cur, -1);
3421                         ast_free(tmp);
3422                 }
3423         }
3424
3425         if (qe->parent->timeoutpriority == TIMEOUT_PRIORITY_APP) {
3426                 /* Application arguments have higher timeout priority (behaviour for <=1.6) */
3427                 if (qe->expire && (!qe->parent->timeout || (qe->expire - now) <= qe->parent->timeout))
3428                         to = (qe->expire - now) * 1000;
3429                 else
3430                         to = (qe->parent->timeout) ? qe->parent->timeout * 1000 : -1;
3431         } else {
3432                 /* Config timeout is higher priority thatn application timeout */
3433                 if (qe->expire && qe->expire<=now) {
3434                         to = 0;
3435                 } else if (qe->parent->timeout) {
3436                         to = qe->parent->timeout * 1000;
3437                 } else {
3438                         to = -1;
3439      &