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