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