Trim post dash portion of name if unspecified
[asterisk/asterisk.git] / apps / app_queue.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * True call queues with optional send URL on answer
5  * 
6  * Copyright (C) 1999, Mark Spencer
7  *
8  * Mark Spencer <markster@linux-support.net>
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <asterisk/lock.h>
15 #include <asterisk/file.h>
16 #include <asterisk/logger.h>
17 #include <asterisk/channel.h>
18 #include <asterisk/pbx.h>
19 #include <asterisk/options.h>
20 #include <asterisk/module.h>
21 #include <asterisk/translate.h>
22 #include <asterisk/say.h>
23 #include <asterisk/parking.h>
24 #include <asterisk/musiconhold.h>
25 #include <asterisk/cli.h>
26 #include <asterisk/manager.h> /* JDG */
27 #include <asterisk/config.h>
28 #include <stdlib.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <string.h>
32 #include <stdlib.h>
33 #include <stdio.h>
34 #include <sys/time.h>
35 #include <sys/signal.h>
36 #include <netinet/in.h>
37
38 #include <pthread.h>
39
40 #define QUEUE_STRATEGY_RINGALL          0
41 #define QUEUE_STRATEGY_ROUNDROBIN       1
42 #define QUEUE_STRATEGY_LEASTRECENT      2
43 #define QUEUE_STRATEGY_FEWESTCALLS      3
44 #define QUEUE_STRATEGY_RANDOM           4
45
46 static struct strategy {
47         int strategy;
48         char *name;
49 } strategies[] = {
50         { QUEUE_STRATEGY_RINGALL, "ringall" },
51         { QUEUE_STRATEGY_ROUNDROBIN, "roundrobin" },
52         { QUEUE_STRATEGY_LEASTRECENT, "leastrecent" },
53         { QUEUE_STRATEGY_FEWESTCALLS, "fewestcalls" },
54         { QUEUE_STRATEGY_RANDOM, "random" },
55 };
56
57 #define DEFAULT_RETRY           5
58 #define DEFAULT_TIMEOUT         15
59 #define RECHECK                         1               /* Recheck every second to see we we're at the top yet */
60
61 static char *tdesc = "True Call Queueing";
62
63 static char *app = "Queue";
64
65 static char *synopsis = "Queue a call for a call queue";
66
67 static char *descrip =
68 "  Queue(queuename[|options[|URL][|announceoverride]]):\n"
69 "Queues an incoming call in a particular call queue as defined in queues.conf.\n"
70 "  This application returns -1 if the originating channel hangs up, or if the\n"
71 "call is bridged and  either of the parties in the bridge terminate the call.\n"
72 "Returns 0 if the queue is full, nonexistant, or has no members.\n"
73 "The option string may contain zero or more of the following characters:\n"
74 "      't' -- allow the called user transfer the calling user\n"
75 "      'T' -- to allow the calling user to transfer the call.\n"
76 "      'd' -- data-quality (modem) call (minimum delay).\n"
77 "      'H' -- allow caller to hang up by hitting *.\n"
78 "  In addition to transferring the call, a call may be parked and then picked\n"
79 "up by another user.\n"
80 "  The optionnal URL will be sent to the called party if the channel supports\n"
81 "it.\n";
82
83 // [PHM 06/26/03]
84 static char *app_aqm = "AddQueueMember" ;
85 static char *app_aqm_synopsis = "Dynamically adds queue members" ;
86 static char *app_aqm_descrip =
87 "   AddQueueMember(queuename[|interface]):\n"
88 "Dynamically adds interface to an existing queue\n"
89 "Returns -1 if there is an error.\n"
90 "Example: AddQueueMember(techsupport|SIP/3000)\n"
91 "";
92
93 static char *app_rqm = "RemoveQueueMember" ;
94 static char *app_rqm_synopsis = "Dynamically removes queue members" ;
95 static char *app_rqm_descrip =
96 "   RemoveQueueMember(queuename[|interface]):\n"
97 "Dynamically removes interface to an existing queue\n"
98 "Returns -1 if there is an error.\n"
99 "Example: RemoveQueueMember(techsupport|SIP/3000)\n"
100 "";
101
102
103
104
105 /* We define a customer "local user" structure because we
106    use it not only for keeping track of what is in use but
107    also for keeping track of who we're dialing. */
108
109 struct localuser {
110         struct ast_channel *chan;
111         char numsubst[256];
112         char tech[40];
113         int stillgoing;
114         int metric;
115         int allowredirect_in;
116         int allowredirect_out;
117         int ringbackonly;
118         int musiconhold;
119         int dataquality;
120         int allowdisconnect;
121         struct member *member;
122         struct localuser *next;
123 };
124
125 LOCAL_USER_DECL;
126
127 struct queue_ent {
128         struct ast_call_queue *parent;  /* What queue is our parent */
129         char moh[80];                           /* Name of musiconhold to be used */
130         char announce[80];              /* Announcement to play */
131         char context[80];               /* Context when user exits queue */
132         int pos;                                        /* Where we are in the queue */
133         time_t start;                           /* When we started holding */
134         struct ast_channel *chan;       /* Our channel */
135         struct queue_ent *next;         /* The next queue entry */
136 };
137
138 struct member {
139         char tech[80];                          /* Technology */
140         char loc[256];                          /* Location */
141         int penalty;                            /* Are we a last resort? */
142         int calls;
143         int dynamic;                            /* Are we dynamically added? */
144         time_t lastcall;        /* When last successful call was hungup */
145         struct member *next;            /* Next member */
146 };
147
148 struct ast_call_queue {
149         ast_mutex_t     lock;   
150         char name[80];                  /* Name of the queue */
151         char moh[80];                   /* Name of musiconhold to be used */
152         char announce[80];              /* Announcement to play */
153         char context[80];               /* Announcement to play */
154         int strategy;                   /* Queueing strategy */
155         int announcetimeout;    /* How often to announce their position */
156         int count;                              /* How many entries are in the queue */
157         int maxlen;                             /* Max number of entries in queue */
158
159         int dead;                               /* Whether this queue is dead or not */
160         int retry;                              /* Retry calling everyone after this amount of time */
161         int timeout;                    /* How long to wait for an answer */
162         
163         /* Queue strategy things */
164         
165         int rrpos;                              /* Round Robin - position */
166         int wrapped;                    /* Round Robin - wrapped around? */
167
168         struct member *members; /* Member channels to be tried */
169         struct queue_ent *head; /* Start of the actual queue */
170         struct ast_call_queue *next;    /* Next call queue */
171 };
172
173 static struct ast_call_queue *queues = NULL;
174 static ast_mutex_t qlock = AST_MUTEX_INITIALIZER;
175
176 static char *int2strat(int strategy)
177 {
178         int x;
179         for (x=0;x<sizeof(strategies) / sizeof(strategies[0]);x++) {
180                 if (strategy == strategies[x].strategy)
181                         return strategies[x].name;
182         }
183         return "<unknown>";
184 }
185
186 static int strat2int(char *strategy)
187 {
188         int x;
189         for (x=0;x<sizeof(strategies) / sizeof(strategies[0]);x++) {
190                 if (!strcasecmp(strategy, strategies[x].name))
191                         return strategies[x].strategy;
192         }
193         return -1;
194 }
195
196 static int join_queue(char *queuename, struct queue_ent *qe)
197 {
198         struct ast_call_queue *q;
199         struct queue_ent *cur, *prev = NULL;
200         int res = -1;
201         int pos = 0;
202         ast_mutex_lock(&qlock);
203         q = queues;
204         while(q) {
205                 if (!strcasecmp(q->name, queuename)) {
206                         /* This is our one */
207                         ast_mutex_lock(&q->lock);
208                         if (q->members && (!q->maxlen || (q->count < q->maxlen))) {
209                                 /* There's space for us, put us at the end */
210                                 prev = NULL;
211                                 cur = q->head;
212                                 while(cur) {
213                                         cur->pos = ++pos;
214                                         prev = cur;
215                                         cur = cur->next;
216                                 }
217                                 if (prev)
218                                         prev->next = qe;
219                                 else
220                                         q->head = qe;
221                                 /* Fix additional pointers and
222                                   information  */
223                                 qe->next = NULL;
224                                 qe->parent = q;
225                                 qe->pos = ++pos;
226                                 strncpy(qe->moh, q->moh, sizeof(qe->moh));
227                                 strncpy(qe->announce, q->announce, sizeof(qe->announce));
228                                 strncpy(qe->context, q->context, sizeof(qe->context));
229                                 q->count++;
230                                 res = 0;
231                                 manager_event(EVENT_FLAG_CALL, "Join", 
232                                                                 "Channel: %s\r\nCallerID: %s\r\nQueue: %s\r\nPosition: %d\r\nCount: %d\r\n",
233                                                                 qe->chan->name, (qe->chan->callerid ? qe->chan->callerid : ""), q->name, qe->pos, q->count );
234 #if 0
235 ast_log(LOG_NOTICE, "Queue '%s' Join, Channel '%s', Position '%d'\n", q->name, qe->chan->name, qe->pos );
236 #endif
237                         }
238                         ast_mutex_unlock(&q->lock);
239                         break;
240                 }
241                 q = q->next;
242         }
243         ast_mutex_unlock(&qlock);
244         return res;
245 }
246
247 static void free_members(struct ast_call_queue *q)
248 {
249         /* Free non-dynamic members */
250         struct member *curm, *next, *prev;
251         curm = q->members;
252         prev = NULL;
253         while(curm) {
254                 next = curm->next;
255                 if (!curm->dynamic) {
256                         if (prev)
257                                 prev->next = next;
258                         else
259                                 q->members = next;
260                         free(curm);
261                 } else 
262                         prev = curm;
263                 curm = next;
264         }
265 }
266
267 static void destroy_queue(struct ast_call_queue *q)
268 {
269         struct ast_call_queue *cur, *prev = NULL;
270         ast_mutex_lock(&qlock);
271         cur = queues;
272         while(cur) {
273                 if (cur == q) {
274                         if (prev)
275                                 prev->next = cur->next;
276                         else
277                                 queues = cur->next;
278                 } else {
279                         prev = cur;
280                 }
281                 cur = cur->next;
282         }
283         ast_mutex_unlock(&qlock);
284         free_members(q);
285         free(q);
286 }
287
288 static void leave_queue(struct queue_ent *qe)
289 {
290         struct ast_call_queue *q;
291         struct queue_ent *cur, *prev = NULL;
292         int pos = 0;
293         q = qe->parent;
294         if (!q)
295                 return;
296         ast_mutex_lock(&q->lock);
297
298         prev = NULL;
299         cur = q->head;
300         while(cur) {
301                 if (cur == qe) {
302                         q->count--;
303
304                         /* Take us out of the queue */
305                         manager_event(EVENT_FLAG_CALL, "Leave",
306                                  "Channel: %s\r\nQueue: %s\r\nCount: %d\r\n",
307                                  qe->chan->name, q->name,  q->count);
308 #if 0
309 ast_log(LOG_NOTICE, "Queue '%s' Leave, Channel '%s'\n", q->name, qe->chan->name );
310 #endif
311                         /* Take us out of the queue */
312                         if (prev)
313                                 prev->next = cur->next;
314                         else
315                                 q->head = cur->next;
316                 } else {
317                         cur->pos = ++pos;
318                         prev = cur;
319                 }
320                 cur = cur->next;
321         }
322         ast_mutex_unlock(&q->lock);
323         if (q->dead && !q->count) {     
324                 /* It's dead and nobody is in it, so kill it */
325                 destroy_queue(q);
326         }
327 }
328
329 static void hanguptree(struct localuser *outgoing, struct ast_channel *exception)
330 {
331         /* Hang up a tree of stuff */
332         struct localuser *oo;
333         while(outgoing) {
334                 /* Hangup any existing lines we have open */
335                 if (outgoing->chan && (outgoing->chan != exception))
336                         ast_hangup(outgoing->chan);
337                 oo = outgoing;
338                 outgoing=outgoing->next;
339                 free(oo);
340         }
341 }
342
343 static int ring_entry(struct queue_ent *qe, struct localuser *tmp)
344 {
345         int res;
346         /* Request the peer */
347         tmp->chan = ast_request(tmp->tech, qe->chan->nativeformats, tmp->numsubst);
348         if (!tmp->chan) {                       /* If we can't, just go on to the next call */
349 #if 0
350                 ast_log(LOG_NOTICE, "Unable to create channel of type '%s'\n", cur->tech);
351 #endif                  
352                 if (qe->chan->cdr)
353                         ast_cdr_busy(qe->chan->cdr);
354                 tmp->stillgoing = 0;
355                 return 0;
356         }
357         tmp->chan->appl = "AppQueue";
358         tmp->chan->data = "(Outgoing Line)";
359         tmp->chan->whentohangup = 0;
360         if (tmp->chan->callerid)
361                 free(tmp->chan->callerid);
362         if (tmp->chan->ani)
363                 free(tmp->chan->ani);
364         if (qe->chan->callerid)
365                 tmp->chan->callerid = strdup(qe->chan->callerid);
366         else
367                 tmp->chan->callerid = NULL;
368         if (qe->chan->ani)
369                 tmp->chan->ani = strdup(qe->chan->ani);
370         else
371                 tmp->chan->ani = NULL;
372         /* Presense of ADSI CPE on outgoing channel follows ours */
373         tmp->chan->adsicpe = qe->chan->adsicpe;
374         /* Place the call, but don't wait on the answer */
375         res = ast_call(tmp->chan, tmp->numsubst, 0);
376         if (res) {
377                 /* Again, keep going even if there's an error */
378                 if (option_debug)
379                         ast_log(LOG_DEBUG, "ast call on peer returned %d\n", res);
380                 else if (option_verbose > 2)
381                         ast_verbose(VERBOSE_PREFIX_3 "Couldn't call %s\n", tmp->numsubst);
382                 ast_hangup(tmp->chan);
383                 tmp->chan = NULL;
384                 tmp->stillgoing = 0;
385                 return 0;
386         } else
387                 if (option_verbose > 2)
388                         ast_verbose(VERBOSE_PREFIX_3 "Called %s\n", tmp->numsubst);
389         return 0;
390 }
391
392 static int ring_one(struct queue_ent *qe, struct localuser *outgoing)
393 {
394         struct localuser *cur;
395         struct localuser *best;
396         int bestmetric=0;
397         do {
398                 best = NULL;
399                 cur = outgoing;
400                 while(cur) {
401                         if (cur->stillgoing &&                                                  /* Not already done */
402                                 !cur->chan &&                                                           /* Isn't already going */
403                                 (!best || (cur->metric < bestmetric))) {        /* We haven't found one yet, or it's better */
404                                         bestmetric = cur->metric;
405                                         best = cur;
406                         }
407                         cur = cur->next;
408                 }
409                 if (best) {
410                         if (!qe->parent->strategy) {
411                                 /* Ring everyone who shares this best metric (for ringall) */
412                                 cur = outgoing;
413                                 while(cur) {
414                                         if (cur->stillgoing && !cur->chan && (cur->metric == bestmetric)) {
415                                                 ast_log(LOG_DEBUG, "(Parallel) Trying '%s/%s' with metric %d\n", cur->tech, cur->numsubst, cur->metric);
416                                                 ring_entry(qe, cur);
417                                         }
418                                         cur = cur->next;
419                                 }
420                         } else {
421                                 /* Ring just the best channel */
422                                 ast_log(LOG_DEBUG, "Trying '%s/%s' with metric %d\n", best->tech, best->numsubst, best->metric);
423                                 ring_entry(qe, best);
424                         }
425                 }
426         } while (best && !best->chan);
427         if (!best) {
428                 ast_log(LOG_DEBUG, "Nobody left to try ringing in queue\n");
429                 return 0;
430         }
431         return 1;
432 }
433
434 static int valid_exit(struct queue_ent *qe, char digit)
435 {
436         char tmp[2];
437         if (!strlen(qe->context))
438                 return 0;
439         tmp[0] = digit;
440         tmp[1] = '\0';
441         if (ast_exists_extension(qe->chan, qe->context, tmp, 1, qe->chan->callerid)) {
442                 strncpy(qe->chan->context, qe->context, sizeof(qe->chan->context) - 1);
443                 strncpy(qe->chan->exten, tmp, sizeof(qe->chan->exten) - 1);
444                 qe->chan->priority = 0;
445                 return 1;
446         }
447         return 0;
448 }
449
450 #define MAX 256
451
452 static struct localuser *wait_for_answer(struct queue_ent *qe, struct localuser *outgoing, int *to, int *allowredir_in, int *allowredir_out, int *allowdisconnect, char *digit)
453 {
454         char *queue = qe->parent->name;
455         struct localuser *o;
456         int found;
457         int numlines;
458         int sentringing = 0;
459         int numbusies = 0;
460         int orig = *to;
461         struct ast_frame *f;
462         struct localuser *peer = NULL;
463         struct ast_channel *watchers[MAX];
464         int pos;
465         struct ast_channel *winner;
466         struct ast_channel *in = qe->chan;
467         
468         while(*to && !peer) {
469                 o = outgoing;
470                 found = -1;
471                 pos = 1;
472                 numlines = 0;
473                 watchers[0] = in;
474                 while(o) {
475                         /* Keep track of important channels */
476                         if (o->stillgoing && o->chan) {
477                                 watchers[pos++] = o->chan;
478                                 found = 1;
479                         }
480                         o = o->next;
481                         numlines++;
482                 }
483                 if (found < 0) {
484                         if (numlines == numbusies) {
485                                 ast_log(LOG_DEBUG, "Everyone is busy at this time\n");
486                         } else {
487                                 ast_log(LOG_NOTICE, "No one is answered queue %s\n", queue);
488                         }
489                         *to = 0;
490                         return NULL;
491                 }
492                 winner = ast_waitfor_n(watchers, pos, to);
493                 o = outgoing;
494                 while(o) {
495                         if (o->stillgoing && (o->chan) &&  (o->chan->_state == AST_STATE_UP)) {
496                                 if (!peer) {
497                                         if (option_verbose > 2)
498                                                 ast_verbose( VERBOSE_PREFIX_3 "%s answered %s\n", o->chan->name, in->name);
499                                         peer = o;
500                                         *allowredir_in = o->allowredirect_in;
501                                         *allowredir_out = o->allowredirect_out;
502                                         *allowdisconnect = o->allowdisconnect;
503                                 }
504                         } else if (o->chan && (o->chan == winner)) {
505                                 f = ast_read(winner);
506                                 if (f) {
507                                         if (f->frametype == AST_FRAME_CONTROL) {
508                                                 switch(f->subclass) {
509                                             case AST_CONTROL_ANSWER:
510                                                         /* This is our guy if someone answered. */
511                                                         if (!peer) {
512                                                                 if (option_verbose > 2)
513                                                                         ast_verbose( VERBOSE_PREFIX_3 "%s answered %s\n", o->chan->name, in->name);
514                                                                 peer = o;
515                                                                 *allowredir_in = o->allowredirect_in;
516                                                                 *allowredir_out = o->allowredirect_out;
517                                                                 *allowdisconnect = o->allowdisconnect;
518                                                         }
519                                                         break;
520                                                 case AST_CONTROL_BUSY:
521                                                         if (option_verbose > 2)
522                                                                 ast_verbose( VERBOSE_PREFIX_3 "%s is busy\n", o->chan->name);
523                                                         o->stillgoing = 0;
524                                                         if (in->cdr)
525                                                                 ast_cdr_busy(in->cdr);
526                                                         ast_hangup(o->chan);
527                                                         o->chan = NULL;
528                                                         if (qe->parent->strategy)
529                                                                 ring_one(qe, outgoing);
530                                                         numbusies++;
531                                                         break;
532                                                 case AST_CONTROL_CONGESTION:
533                                                         if (option_verbose > 2)
534                                                                 ast_verbose( VERBOSE_PREFIX_3 "%s is circuit-busy\n", o->chan->name);
535                                                         o->stillgoing = 0;
536                                                         if (in->cdr)
537                                                                 ast_cdr_busy(in->cdr);
538                                                         ast_hangup(o->chan);
539                                                         o->chan = NULL;
540                                                         if (qe->parent->strategy)
541                                                                 ring_one(qe, outgoing);
542                                                         numbusies++;
543                                                         break;
544                                                 case AST_CONTROL_RINGING:
545                                                         if (option_verbose > 2)
546                                                                 ast_verbose( VERBOSE_PREFIX_3 "%s is ringing\n", o->chan->name);
547                                                         if (!sentringing) {
548 #if 0
549                                                                 ast_indicate(in, AST_CONTROL_RINGING);
550 #endif                                                          
551                                                                 sentringing++;
552                                                         }
553                                                         break;
554                                                 case AST_CONTROL_OFFHOOK:
555                                                         /* Ignore going off hook */
556                                                         break;
557                                                 default:
558                                                         ast_log(LOG_DEBUG, "Dunno what to do with control type %d\n", f->subclass);
559                                                 }
560                                         }
561                                         ast_frfree(f);
562                                 } else {
563                                         o->stillgoing = 0;
564                                         ast_hangup(o->chan);
565                                         o->chan = NULL;
566                                         if (qe->parent->strategy)
567                                                 ring_one(qe, outgoing);
568                                 }
569                         }
570                         o = o->next;
571                 }
572                 if (winner == in) {
573                         f = ast_read(in);
574 #if 0
575                         if (f && (f->frametype != AST_FRAME_VOICE))
576                                         printf("Frame type: %d, %d\n", f->frametype, f->subclass);
577                         else if (!f || (f->frametype != AST_FRAME_VOICE))
578                                 printf("Hangup received on %s\n", in->name);
579 #endif
580                         if (!f || ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP))) {
581                                 /* Got hung up */
582                                 *to=-1;
583                                 return NULL;
584                         }
585                         if (f && (f->frametype == AST_FRAME_DTMF) && allowdisconnect && (f->subclass == '*')) {
586                             if (option_verbose > 3)
587                                 ast_verbose(VERBOSE_PREFIX_3 "User hit %c to disconnect call.\n", f->subclass);
588                                 *to=0;
589                                 return NULL;
590                         }
591                         if (f && (f->frametype == AST_FRAME_DTMF) && (f->subclass != '*') && valid_exit(qe, f->subclass)) {
592                                 if (option_verbose > 3)
593                                         ast_verbose(VERBOSE_PREFIX_3 "User pressed digit: %c", f->subclass);
594                                 *to=0;
595                                 *digit=f->subclass;
596                                 return NULL;
597                         }
598                 }
599                 if (!*to && (option_verbose > 2))
600                         ast_verbose( VERBOSE_PREFIX_3 "Nobody picked up in %d ms\n", orig);
601         }
602
603         return peer;
604         
605 }
606
607 static int wait_our_turn(struct queue_ent *qe)
608 {
609         struct queue_ent *ch;
610         int res = 0;
611         for (;;) {
612                 /* Atomically read the parent head */
613                 ast_mutex_lock(&qe->parent->lock);
614                 ch = qe->parent->head;
615                 ast_mutex_unlock(&qe->parent->lock);
616                 /* If we are now at the top of the head, break out */
617                 if (qe->parent->head == qe)
618                         break;
619                 /* Wait a second before checking again */
620                 res = ast_waitfordigit(qe->chan, RECHECK * 1000);
621                 if (res)
622                         break;
623         }
624         return res;
625 }
626
627 static int update_queue(struct ast_call_queue *q, struct localuser *user)
628 {
629         struct member *cur;
630         /* Since a reload could have taken place, we have to traverse the list to
631                 be sure it's still valid */
632         ast_mutex_lock(&q->lock);
633         cur = q->members;
634         while(cur) {
635                 if (user->member == cur) {
636                         time(&cur->lastcall);
637                         cur->calls++;
638                         break;
639                 }
640                 cur = cur->next;
641         }
642         ast_mutex_unlock(&q->lock);
643         return 0;
644 }
645
646 static int calc_metric(struct ast_call_queue *q, struct member *mem, int pos, struct queue_ent *qe, struct localuser *tmp)
647 {
648         switch (q->strategy) {
649         case QUEUE_STRATEGY_RINGALL:
650                 /* Everyone equal, except for penalty */
651                 tmp->metric = mem->penalty * 1000000;
652                 break;
653         case QUEUE_STRATEGY_ROUNDROBIN:
654                 if (!pos) {
655                         if (!q->wrapped) {
656                                 /* No more channels, start over */
657                                 q->rrpos = 0;
658                         } else {
659                                 /* Prioritize next entry */
660                                 q->rrpos++;
661                         }
662                         q->wrapped = 0;
663                 }
664                 if (pos < q->rrpos) {
665                         tmp->metric = 1000 + pos;
666                 } else {
667                         if (pos > q->rrpos) {
668                                 /* Indicate there is another priority */
669                                 q->wrapped = 1;
670                         }
671                         tmp->metric = pos;
672                 }
673                 tmp->metric += mem->penalty * 1000000;
674                 break;
675         case QUEUE_STRATEGY_RANDOM:
676                 tmp->metric = rand() % 1000;
677                 tmp->metric += mem->penalty * 1000000;
678                 break;
679         case QUEUE_STRATEGY_FEWESTCALLS:
680                 tmp->metric = mem->calls;
681                 tmp->metric += mem->penalty * 1000000;
682                 break;
683         case QUEUE_STRATEGY_LEASTRECENT:
684                 if (!mem->lastcall)
685                         tmp->metric = 0;
686                 else
687                         tmp->metric = 1000000 - (time(NULL) - mem->lastcall);
688                 tmp->metric += mem->penalty * 1000000;
689                 break;
690         default:
691                 ast_log(LOG_WARNING, "Can't calculate metric for unknown strategy %d\n", q->strategy);
692                 break;
693         }
694         return 0;
695 }
696
697 static int try_calling(struct queue_ent *qe, char *options, char *announceoverride, char *url)
698 {
699         struct member *cur;
700         struct localuser *outgoing=NULL, *tmp = NULL;
701         int to;
702         int allowredir_in=0;
703         int allowredir_out=0;
704         int allowdisconnect=0;
705         char restofit[AST_MAX_EXTENSION];
706         char *newnum;
707         struct ast_channel *peer;
708         struct localuser *lpeer;
709         int res = 0, bridge = 0;
710         int zapx = 2;
711         int x=0;
712         char *announce = NULL;
713         char digit = 0;
714         /* Hold the lock while we setup the outgoing calls */
715         ast_mutex_lock(&qe->parent->lock);
716         cur = qe->parent->members;
717         if (strlen(qe->announce))
718                 announce = qe->announce;
719         if (announceoverride && strlen(announceoverride))
720                 announce = announceoverride;
721         while(cur) {
722                 /* Get a technology/[device:]number pair */
723                 tmp = malloc(sizeof(struct localuser));
724                 if (!tmp) {
725                         ast_log(LOG_WARNING, "Out of memory\n");
726                         goto out;
727                 }
728                 memset(tmp, 0, sizeof(struct localuser));
729                 tmp->stillgoing = -1;
730                 if (options) {
731                         if (strchr(options, 't'))
732                                 tmp->allowredirect_in = 1;
733                         if (strchr(options, 'T'))
734                                 tmp->allowredirect_out = 1;
735                         if (strchr(options, 'r'))
736                                 tmp->ringbackonly = 1;
737                         if (strchr(options, 'm'))
738                                 tmp->musiconhold = 1;
739                         if (strchr(options, 'd'))
740                                 tmp->dataquality = 1;
741                         if (strchr(options, 'H'))
742                                 tmp->allowdisconnect = 1;
743                 }
744                 if (url) {
745                         ast_log(LOG_DEBUG, "Queue with URL=%s_\n", url);
746                 } else 
747                         ast_log(LOG_DEBUG, "Simple queue (no URL)\n");
748
749                 tmp->member = cur;              /* Never directly dereference!  Could change on reload */
750                 strncpy(tmp->tech, cur->tech, sizeof(tmp->tech)-1);
751                 strncpy(tmp->numsubst, cur->loc, sizeof(tmp->numsubst)-1);
752                 /* If we're dialing by extension, look at the extension to know what to dial */
753                 if ((newnum = strstr(tmp->numsubst, "BYEXTENSION"))) {
754                         strncpy(restofit, newnum + strlen("BYEXTENSION"), sizeof(restofit)-1);
755                         snprintf(newnum, sizeof(tmp->numsubst) - (newnum - tmp->numsubst), "%s%s", qe->chan->exten,restofit);
756                         if (option_debug)
757                                 ast_log(LOG_DEBUG, "Dialing by extension %s\n", tmp->numsubst);
758                 }
759                 /* Special case: If we ring everyone, go ahead and ring them, otherwise
760                    just calculate their metric for the appropriate strategy */
761                 calc_metric(qe->parent, cur, x++, qe, tmp);
762                 /* Put them in the list of outgoing thingies...  We're ready now. 
763                    XXX If we're forcibly removed, these outgoing calls won't get
764                    hung up XXX */
765                 tmp->next = outgoing;
766                 outgoing = tmp;         
767                 /* If this line is up, don't try anybody else */
768                 if (outgoing->chan && (outgoing->chan->_state == AST_STATE_UP))
769                         break;
770
771                 cur = cur->next;
772         }
773         if (qe->parent->timeout)
774                 to = qe->parent->timeout * 1000;
775         else
776                 to = -1;
777         ring_one(qe, outgoing);
778         ast_mutex_unlock(&qe->parent->lock);
779         lpeer = wait_for_answer(qe, outgoing, &to, &allowredir_in, &allowredir_out, &allowdisconnect, &digit);
780         if (lpeer)
781                 peer = lpeer->chan;
782         else
783                 peer = NULL;
784         if (!peer) {
785                 if (to) {
786                         /* Musta gotten hung up */
787                         res = -1;
788                 } else {
789                         if (digit && valid_exit(qe, digit))
790                                 res=digit;
791                         else
792                                 /* Nobody answered, next please? */
793                                 res=0;
794                 }
795                 goto out;
796         }
797         if (peer) {
798                 /* Ah ha!  Someone answered within the desired timeframe.  Of course after this
799                    we will always return with -1 so that it is hung up properly after the 
800                    conversation.  */
801                 if (!strcmp(qe->chan->type,"Zap")) {
802                         if (tmp->dataquality) zapx = 0;
803                         ast_channel_setoption(qe->chan,AST_OPTION_TONE_VERIFY,&zapx,sizeof(char),0);
804                 }                       
805                 if (!strcmp(peer->type,"Zap")) {
806                         if (tmp->dataquality) zapx = 0;
807                         ast_channel_setoption(peer,AST_OPTION_TONE_VERIFY,&zapx,sizeof(char),0);
808                 }
809                 /* Update parameters for the queue */
810                 update_queue(qe->parent, lpeer);
811                 hanguptree(outgoing, peer);
812                 /* Stop music on hold */
813                 ast_moh_stop(qe->chan);
814                 outgoing = NULL;
815                 if (announce) {
816                         int res2;
817                         res2 = ast_autoservice_start(qe->chan);
818                         if (!res2)
819                                 res2 = ast_streamfile(peer, announce, peer->language);
820                         /* XXX Need a function to wait on *both* streams XXX */
821                         if (!res2)
822                                 res2 = ast_waitstream(peer, "");
823                         res2 |= ast_autoservice_stop(qe->chan);
824                         if (res2) {
825                                 /* Agent must have hung up */
826                                 ast_log(LOG_WARNING, "Agent on %s hungup on the customer.  They're going to be pissed.\n", peer->name);
827                                 ast_hangup(peer);
828                                 return -1;
829                         }
830                 }
831                 /* If appropriate, log that we have a destination channel */
832                 if (qe->chan->cdr)
833                         ast_cdr_setdestchan(qe->chan->cdr, peer->name);
834                 /* Make sure channels are compatible */
835                 res = ast_channel_make_compatible(qe->chan, peer);
836                 if (res < 0) {
837                         ast_log(LOG_WARNING, "Had to drop call because I couldn't make %s compatible with %s\n", qe->chan->name, peer->name);
838                         ast_hangup(peer);
839                         return -1;
840                 }
841                 /* Drop out of the queue at this point, to prepare for next caller */
842                 leave_queue(qe);                        
843                 /* JDG: sendurl */
844                 if( url && strlen(url) && ast_channel_supports_html(peer) ) {
845                         ast_log(LOG_DEBUG, "app_queue: sendurl=%s.\n", url);
846                         ast_channel_sendurl( peer, url );
847                 } /* /JDG */
848                 bridge = ast_bridge_call(qe->chan, peer, allowredir_in, allowredir_out, allowdisconnect);
849
850                 if(bridge != AST_PBX_NO_HANGUP_PEER)
851                         ast_hangup(peer);
852
853                 if( bridge == 0 ) res=1; /* JDG: bridge successfull, leave app_queue */
854                 else res = bridge; /* bridge error, stay in the queue */
855         }       
856 out:
857         hanguptree(outgoing, NULL);
858         return res;
859 }
860
861 static int wait_a_bit(struct queue_ent *qe)
862 {
863         int retrywait;
864         /* Hold the lock while we setup the outgoing calls */
865         ast_mutex_lock(&qe->parent->lock);
866         retrywait = qe->parent->retry * 1000;
867         ast_mutex_unlock(&qe->parent->lock);
868         return ast_waitfordigit(qe->chan, retrywait);
869 }
870
871 // [PHM 06/26/03]
872
873 static struct member * interface_exists( struct ast_call_queue * q, char * interface )
874 {
875         struct member * ret = NULL ;
876         struct member *mem;
877         char buf[500] ;
878
879         if( q != NULL )
880         {
881                 mem = q->members ;
882
883                 while( mem != NULL ) {
884                         sprintf( buf, "%s/%s", mem->tech, mem->loc);
885
886                         if( strcmp( buf, interface ) == 0 ) {
887                                 ret = mem ;
888                                 break ;
889                         }
890                         else
891                                 mem = mem->next ;
892                 }
893         }
894
895         return( ret ) ;
896 }
897
898
899 static struct member * create_queue_node( char * interface )
900 {
901         struct member * cur ;
902         char * tmp ;
903         
904         /* Add a new member */
905
906         cur = malloc(sizeof(struct member));
907
908         if (cur) {
909                 memset(cur, 0, sizeof(struct member));
910                 strncpy(cur->tech, interface, sizeof(cur->tech) - 1);
911                 if ((tmp = strchr(cur->tech, '/')))
912                         *tmp = '\0';
913                 if ((tmp = strchr(interface, '/'))) {
914                         tmp++;
915                         strncpy(cur->loc, tmp, sizeof(cur->loc) - 1);
916                 } else
917                         ast_log(LOG_WARNING, "No location at interface '%s'\n", interface);
918         }
919
920         return( cur ) ;
921 }
922
923
924 static int rqm_exec(struct ast_channel *chan, void *data)
925 {
926         int res=-1;
927         struct localuser *u;
928         char *queuename;
929         struct member * node ;
930         struct member * look ;
931         char info[512];
932         char *interface=NULL;
933         struct ast_call_queue *q;
934         int found=0 ;
935
936         if (!data) {
937                 ast_log(LOG_WARNING, "RemoveQueueMember requires an argument (queuename|optional interface)\n");
938                 return -1;
939         }
940         
941         LOCAL_USER_ADD(u); // not sure if we need this, but better be safe than sorry ;-)
942         
943         /* Parse our arguments XXX Check for failure XXX */
944         strncpy(info, (char *)data, strlen((char *)data) + AST_MAX_EXTENSION-1);
945         queuename = info;
946         if (queuename) {
947                 interface = strchr(queuename, '|');
948                 if (interface) {
949                         *interface = '\0';
950                         interface++;
951                 }
952                 else
953                         interface = chan->name ;
954         }
955
956         if( ( q = queues) != NULL )
957         {
958                 while( q && ( res != 0 ) && (!found) ) 
959                 {
960                         ast_mutex_lock(&q->lock);
961                         if( strcmp( q->name, queuename) == 0 )
962                         {
963                                 // found queue, try to remove  interface
964                                 found=1 ;
965
966                                 if( ( node = interface_exists( q, interface ) ) != NULL )
967                                 {
968                                         if( ( look = q->members ) == node )
969                                         {
970                                                 // 1st
971                                                 q->members = node->next;
972                                         }
973                                         else
974                                         {
975                                                 while( look != NULL )
976                                                         if( look->next == node )
977                                                         {
978                                                                 look->next = node->next ;
979                                                                 break ;
980                                                         }
981                                                         else
982                                                                 look = look->next ;
983                                         }
984
985                                         free( node ) ;
986
987                                         ast_log(LOG_NOTICE, "Removed interface '%s' to queue '%s'\n", 
988                                                 interface, queuename);
989                                         res = 0 ;
990                                 }
991                                 else
992                                         ast_log(LOG_WARNING, "Unable to remove interface '%s' from queue '%s': "
993                                                 "Not there\n", interface, queuename);
994                         }
995
996                         ast_mutex_unlock(&q->lock);
997                         q = q->next;
998                 }
999         }
1000
1001         if( ! found )
1002                 ast_log(LOG_WARNING, "Unable to remove interface from queue '%s': No such queue\n", queuename);
1003
1004         LOCAL_USER_REMOVE(u);
1005         return res;
1006 }
1007
1008
1009
1010 static int aqm_exec(struct ast_channel *chan, void *data)
1011 {
1012         int res=-1;
1013         struct localuser *u;
1014         char *queuename;
1015         char info[512];
1016         char tmpchan[512]="";
1017         char *interface=NULL;
1018         struct ast_call_queue *q;
1019         struct member *save;
1020         int found=0 ;
1021
1022         if (!data) {
1023                 ast_log(LOG_WARNING, "AddQueueMember requires an argument (queuename|optional interface)\n");
1024                 return -1;
1025         }
1026         
1027         LOCAL_USER_ADD(u); // not sure if we need this, but better be safe than sorry ;-)
1028         
1029         /* Parse our arguments XXX Check for failure XXX */
1030         strncpy(info, (char *)data, strlen((char *)data) + AST_MAX_EXTENSION-1);
1031         queuename = info;
1032         if (queuename) {
1033                 interface = strchr(queuename, '|');
1034                 if (interface) {
1035                         *interface = '\0';
1036                         interface++;
1037                 }
1038                 else {
1039                         strncpy(tmpchan, chan->name, sizeof(tmpchan) - 1);
1040                         interface = strrchr(tmpchan, '-');
1041                         if (interface)
1042                                 *interface = '\0';
1043                         interface = tmpchan;
1044                 }
1045         }
1046
1047         if( ( q = queues) != NULL )
1048         {
1049                 while( q && ( res != 0 ) && (!found) ) 
1050                 {
1051                         ast_mutex_lock(&q->lock);
1052                         if( strcmp( q->name, queuename) == 0 )
1053                         {
1054                                 // found queue, try to enable interface
1055                                 found=1 ;
1056
1057                                 if( interface_exists( q, interface ) == NULL )
1058                                 {
1059                                         save = q->members ;
1060                                         q->members = create_queue_node( interface ) ;
1061
1062                                         if( q->members != NULL ) {
1063                                                 q->members->dynamic = 1;
1064                                                 q->members->next = save ;
1065                                         } else
1066                                                 q->members = save ;
1067
1068                                         ast_log(LOG_NOTICE, "Added interface '%s' to queue '%s'\n", interface, queuename);
1069                                         res = 0 ;
1070                                 }
1071                                 else
1072                                         ast_log(LOG_WARNING, "Unable to add interface '%s' to queue '%s': "
1073                                                 "Already there\n", interface, queuename);
1074                         }
1075
1076                         ast_mutex_unlock(&q->lock);
1077                         q = q->next;
1078                 }
1079         }
1080
1081         if( ! found )
1082                 ast_log(LOG_WARNING, "Unable to add interface to queue '%s': No such queue\n", queuename);
1083
1084         LOCAL_USER_REMOVE(u);
1085         return res;
1086 }
1087
1088
1089 static int queue_exec(struct ast_channel *chan, void *data)
1090 {
1091         int res=-1;
1092         struct localuser *u;
1093         char *queuename;
1094         char info[512];
1095         char *options = NULL;
1096         char *url = NULL;
1097         char *announceoverride = NULL;
1098         
1099         /* Our queue entry */
1100         struct queue_ent qe;
1101         
1102         if (!data) {
1103                 ast_log(LOG_WARNING, "Queue requires an argument (queuename|optional timeout|optional URL)\n");
1104                 return -1;
1105         }
1106         
1107         LOCAL_USER_ADD(u);
1108         
1109         /* Parse our arguments XXX Check for failure XXX */
1110         strncpy(info, (char *)data, strlen((char *)data) + AST_MAX_EXTENSION-1);
1111         queuename = info;
1112         if (queuename) {
1113                 options = strchr(queuename, '|');
1114                 if (options) {
1115                         *options = '\0';
1116                         options++;
1117                         url = strchr(options, '|');
1118                         if (url) {
1119                                 *url = '\0';
1120                                 url++;
1121                                 announceoverride = strchr(url, '|');
1122                                 if (announceoverride) {
1123                                         *announceoverride = '\0';
1124                                         announceoverride++;
1125                                 }
1126                         }
1127                 }
1128         }
1129         printf("queue: %s, options: %s, url: %s, announce: %s\n",
1130                 queuename, options, url, announceoverride);
1131         /* Setup our queue entry */
1132         memset(&qe, 0, sizeof(qe));
1133         qe.chan = chan;
1134         qe.start = time(NULL);
1135         if (!join_queue(queuename, &qe)) {
1136                 /* Start music on hold */
1137                 ast_moh_start(chan, qe.moh);
1138                 for (;;) {
1139                         res = wait_our_turn(&qe);
1140                         /* If they hungup, return immediately */
1141                         if (res < 0) {
1142                                 if (option_verbose > 2) {
1143                                         ast_verbose(VERBOSE_PREFIX_3 "User disconnected while waiting their turn\n");
1144                                         res = -1;
1145                                 }
1146                                 break;
1147                         }
1148                         if (!res)
1149                                 break;
1150                         if (valid_exit(&qe, res))
1151                                 break;
1152                 }
1153                 if (!res) {
1154                         for (;;) {
1155                                 res = try_calling(&qe, options, announceoverride, url);
1156                                 if (res)
1157                                         break;
1158                                 res = wait_a_bit(&qe);
1159                                 if (res < 0) {
1160                                         if (option_verbose > 2) {
1161                                                 ast_verbose(VERBOSE_PREFIX_3 "User disconnected when they almost made it\n");
1162                                                 res = -1;
1163                                         }
1164                                         break;
1165                                 }
1166                                 if (res && valid_exit(&qe, res))
1167                                         break;
1168                         }
1169                 }
1170                 /* Don't allow return code > 0 */
1171                 if (res > 0 && res != AST_PBX_KEEPALIVE) {
1172                         res = 0;        
1173                         ast_moh_stop(chan);
1174                 }
1175                 leave_queue(&qe);
1176         } else {
1177                 ast_log(LOG_WARNING, "Unable to join queue '%s'\n", queuename);
1178                 res =  0;
1179         }
1180         LOCAL_USER_REMOVE(u);
1181         return res;
1182 }
1183
1184 static void reload_queues(void)
1185 {
1186         struct ast_call_queue *q, *ql, *qn;
1187         struct ast_config *cfg;
1188         char *cat, *tmp;
1189         struct ast_variable *var;
1190         struct member *prev, *cur;
1191         int new;
1192         cfg = ast_load("queues.conf");
1193         if (!cfg) {
1194                 ast_log(LOG_NOTICE, "No call queueing config file, so no call queues\n");
1195                 return;
1196         }
1197         ast_mutex_lock(&qlock);
1198         /* Mark all queues as dead for the moment */
1199         q = queues;
1200         while(q) {
1201                 q = q->next;
1202         }
1203         /* Chug through config file */
1204         cat = ast_category_browse(cfg, NULL);
1205         while(cat) {
1206                 if (strcasecmp(cat, "general")) {
1207                         /* Look for an existing one */
1208                         q = queues;
1209                         while(q) {
1210                                 if (!strcmp(q->name, cat))
1211                                         break;
1212                                 q = q->next;
1213                         }
1214                         if (!q) {
1215                                 /* Make one then */
1216                                 q = malloc(sizeof(struct ast_call_queue));
1217                                 if (q) {
1218                                         /* Initialize it */
1219                                         memset(q, 0, sizeof(struct ast_call_queue));
1220                                         ast_mutex_init(&q->lock);
1221                                         strncpy(q->name, cat, sizeof(q->name));
1222                                         new = 1;
1223                                 } else new = 0;
1224                         } else
1225                                         new = 0;
1226                         if (q) {
1227                                 if (!new) 
1228                                         ast_mutex_lock(&q->lock);
1229                                 /* Re-initialize the queue */
1230                                 q->dead = 0;
1231                                 q->retry = 0;
1232                                 q->timeout = -1;
1233                                 q->maxlen = 0;
1234                                 free_members(q);
1235                                 strcpy(q->moh, "");
1236                                 strcpy(q->announce, "");
1237                                 strcpy(q->context, "");
1238                                 prev = NULL;
1239                                 var = ast_variable_browse(cfg, cat);
1240                                 while(var) {
1241                                         if (!strcasecmp(var->name, "member")) {
1242                                                 /* Add a new member */
1243                                                 cur = malloc(sizeof(struct member));
1244                                                 if (cur) {
1245                                                         memset(cur, 0, sizeof(struct member));
1246                                                         strncpy(cur->tech, var->value, sizeof(cur->tech) - 1);
1247                                                         if ((tmp = strchr(cur->tech, ','))) {
1248                                                                 *tmp = '\0';
1249                                                                 tmp++;
1250                                                                 cur->penalty = atoi(tmp);
1251                                                                 if (cur->penalty < 0)
1252                                                                         cur->penalty = 0;
1253                                                         }
1254                                                         if ((tmp = strchr(cur->tech, '/')))
1255                                                                 *tmp = '\0';
1256                                                         if ((tmp = strchr(var->value, '/'))) {
1257                                                                 tmp++;
1258                                                                 strncpy(cur->loc, tmp, sizeof(cur->loc) - 1);
1259                                                                 if ((tmp = strchr(cur->loc, ',')))
1260                                                                         *tmp = '\0';
1261                                                         } else
1262                                                                 ast_log(LOG_WARNING, "No location at line %d of queue.conf\n", var->lineno);
1263                                                         if (prev)
1264                                                                 prev->next = cur;
1265                                                         else
1266                                                                 q->members = cur;
1267                                                         prev = cur;
1268                                                 }
1269                                         } else if (!strcasecmp(var->name, "music")) {
1270                                                 strncpy(q->moh, var->value, sizeof(q->moh) - 1);
1271                                         } else if (!strcasecmp(var->name, "announce")) {
1272                                                 strncpy(q->announce, var->value, sizeof(q->announce) - 1);
1273                                         } else if (!strcasecmp(var->name, "context")) {
1274                                                 strncpy(q->context, var->value, sizeof(q->context) - 1);
1275                                         } else if (!strcasecmp(var->name, "timeout")) {
1276                                                 q->timeout = atoi(var->value);
1277                                         } else if (!strcasecmp(var->name, "retry")) {
1278                                                 q->retry = atoi(var->value);
1279                                         } else if (!strcasecmp(var->name, "maxlen")) {
1280                                                 q->maxlen = atoi(var->value);
1281                                         } else if (!strcasecmp(var->name, "strategy")) {
1282                                                 q->strategy = strat2int(var->value);
1283                                                 if (q->strategy < 0) {
1284                                                         ast_log(LOG_WARNING, "'%s' isn't a valid strategy, using ringall instead\n", var->value);
1285                                                         q->strategy = 0;
1286                                                 }
1287                                         } else {
1288                                                 ast_log(LOG_WARNING, "Unknown keyword in queue '%s': %s at line %d of queue.conf\n", cat, var->name, var->lineno);
1289                                         }
1290                                         var = var->next;
1291                                 }
1292                                 if (q->retry < 1)
1293                                         q->retry = DEFAULT_RETRY;
1294                                 if (q->timeout < 0)
1295                                         q->timeout = DEFAULT_TIMEOUT;
1296                                 if (q->maxlen < 0)
1297                                         q->maxlen = 0;
1298                                 if (!new) 
1299                                         ast_mutex_unlock(&q->lock);
1300                                 if (new) {
1301                                         q->next = queues;
1302                                         queues = q;
1303                                 }
1304                         }
1305                 }
1306                 cat = ast_category_browse(cfg, cat);
1307         }
1308         ast_destroy(cfg);
1309         q = queues;
1310         ql = NULL;
1311         while(q) {
1312                 qn = q->next;
1313                 if (q->dead) {
1314                         if (ql)
1315                                 ql->next = q->next;
1316                         else
1317                                 queues = q->next;
1318                         if (!q->count) {
1319                                 free(q);
1320                         } else
1321                                 ast_log(LOG_WARNING, "XXX Leaking a litttle memory :( XXX\n");
1322                 } else
1323                         ql = q;
1324                 q = qn;
1325         }
1326         ast_mutex_unlock(&qlock);
1327 }
1328
1329 static int queues_show(int fd, int argc, char **argv)
1330 {
1331         struct ast_call_queue *q;
1332         struct queue_ent *qe;
1333         struct member *mem;
1334         int pos;
1335         time_t now;
1336         char max[80];
1337         char calls[80];
1338         
1339         time(&now);
1340         if (argc != 2)
1341                 return RESULT_SHOWUSAGE;
1342         q = queues;
1343         if (!q) {       
1344                 ast_cli(fd, "No queues.\n");
1345                 return RESULT_SUCCESS;
1346         }
1347         while(q) {
1348                 ast_mutex_lock(&q->lock);
1349                 if (q->maxlen)
1350                         snprintf(max, sizeof(max), "%d", q->maxlen);
1351                 else
1352                         strcpy(max, "unlimited");
1353                 ast_cli(fd, "%-12.12s has %d calls (max %s) in '%s' strategy\n", q->name, q->count, max, int2strat(q->strategy));
1354                 if (q->members) {
1355                         ast_cli(fd, "   Members: \n");
1356                         for (mem = q->members; mem; mem = mem->next) {
1357                                 if (mem->penalty)
1358                                         snprintf(max, sizeof(max) - 20, " with penalty %d", mem->penalty);
1359                                 else
1360                                         strcpy(max, "");
1361                                 if (mem->dynamic)
1362                                         strcat(max, " (dynamic)");
1363                                 if (mem->calls) {
1364                                         snprintf(calls, sizeof(calls), " has taken %d calls (last was %ld secs ago)",
1365                                                         mem->calls, time(NULL) - mem->lastcall);
1366                                 } else
1367                                         strcpy(calls, " has taken no calls yet");
1368                                 ast_cli(fd, "      %s/%s%s%s\n", mem->tech, mem->loc, max, calls);
1369                         }
1370                 } else
1371                         ast_cli(fd, "   No Members\n");
1372                 if (q->head) {
1373                         pos = 1;
1374                         ast_cli(fd, "   Callers: \n");
1375                         for (qe = q->head; qe; qe = qe->next) 
1376                                 ast_cli(fd, "      %d. %s (wait: %d:%02.2d)\n", pos++, qe->chan->name,
1377                                                                 (now - qe->start) / 60, (now - qe->start) % 60);
1378                 } else
1379                         ast_cli(fd, "   No Callers\n");
1380                 ast_cli(fd, "\n");
1381                 ast_mutex_unlock(&q->lock);
1382                 q = q->next;
1383         }
1384         return RESULT_SUCCESS;
1385 }
1386
1387 /* JDG: callback to display queues status in manager */
1388 static int manager_queues_show( struct mansession *s, struct message *m )
1389 {
1390         char *a[] = { "show", "queues" };
1391         return queues_show( s->fd, 2, a );
1392 } /* /JDG */
1393
1394
1395 /* Dump queue status */
1396 static int manager_queues_status( struct mansession *s, struct message *m )
1397 {
1398         time_t now;
1399         int pos;
1400         struct ast_call_queue *q;
1401         struct queue_ent *qe;
1402         astman_send_ack(s, "Queue status will follow");
1403         time(&now);
1404         q = queues;
1405         while(q) {
1406                 ast_mutex_lock(&q->lock);
1407                 ast_cli(s->fd, "Event: QueueParams\r\n"
1408                                         "Queue: %s\r\n"
1409                                         "Max: %d\r\n"
1410                                         "Calls: %d\r\n"
1411                                         "\r\n",
1412                                                 q->name, q->maxlen, q->count);
1413 #if 0
1414                 /* Do we care about queue members? */                                   
1415                 for (mem = q->members; mem; mem = mem->next) 
1416                         ast_cli(fd, "      %s/%s\n", mem->tech, mem->loc);
1417 #endif                  
1418                 pos = 1;
1419                 for (qe = q->head; qe; qe = qe->next) 
1420                         ast_cli(s->fd, "Event: QueueMember\r\n"
1421                                 "Queue: %s\r\n"
1422                                 "Position: %d\r\n"
1423                                 "Channel: %s\r\n"
1424                                 "CallerID: %s\r\n"
1425                                 "Wait: %ld\r\n"
1426                                 "\r\n", 
1427                                         q->name, pos++, qe->chan->name, (qe->chan->callerid ? qe->chan->callerid : ""), now - qe->start);
1428                 ast_mutex_unlock(&q->lock);
1429                 q = q->next;
1430         }
1431         return RESULT_SUCCESS;
1432 }
1433
1434 static char show_queues_usage[] = 
1435 "Usage: show queues\n"
1436 "       Provides summary information on call queues.\n";
1437
1438 static struct ast_cli_entry cli_show_queues = {
1439         { "show", "queues", NULL }, queues_show, 
1440         "Show status of queues", show_queues_usage, NULL };
1441
1442 int unload_module(void)
1443 {
1444         STANDARD_HANGUP_LOCALUSERS;
1445         ast_cli_unregister(&cli_show_queues);
1446         ast_manager_unregister( "Queues" );
1447         ast_manager_unregister( "QueueStatus" );
1448         return ast_unregister_application(app);
1449 }
1450
1451 int load_module(void)
1452 {
1453         int res;
1454         res = ast_register_application(app, queue_exec, synopsis, descrip);
1455         if (!res) {
1456                 ast_cli_register(&cli_show_queues);
1457                 ast_manager_register( "Queues", 0, manager_queues_show, "Queues" );
1458                 ast_manager_register( "QueueStatus", 0, manager_queues_status, "Queue Status" );
1459
1460                 // [PHM 06/26/03]
1461                 ast_register_application(app_aqm, aqm_exec, app_aqm_synopsis, app_aqm_descrip) ;
1462                 ast_register_application(app_rqm, rqm_exec, app_rqm_synopsis, app_rqm_descrip) ;
1463         }
1464         reload_queues();
1465         return res;
1466 }
1467
1468
1469 int reload(void)
1470 {
1471         reload_queues();
1472         return 0;
1473 }
1474
1475 char *description(void)
1476 {
1477         return tdesc;
1478 }
1479
1480 int usecount(void)
1481 {
1482         int res;
1483         STANDARD_USECOUNT(res);
1484         return res;
1485 }
1486
1487 char *key()
1488 {
1489         return ASTERISK_GPL_KEY;
1490 }