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