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