fix codec timing issues
[asterisk/asterisk.git] / apps / app_chanspy.c
1 /*
2  * Asterisk -- A telephony toolkit for Linux.
3  *
4  * ChanSpy Listen in on any channel.
5  * 
6  * Copyright (C) 2005 Anthony Minessale II (anthmct@yahoo.com)
7  *
8  * Disclaimed to Digium
9  *
10  * This program is free software, distributed under the terms of
11  * the GNU General Public License
12  */
13
14 #include <asterisk/file.h>
15 #include <asterisk/logger.h>
16 #include <asterisk/channel.h>
17 #include <asterisk/features.h>
18 #include <asterisk/options.h>
19 #include <asterisk/app.h>
20 #include <asterisk/utils.h>
21 #include <asterisk/say.h>
22 #include <asterisk/pbx.h>
23 #include <asterisk/translate.h>
24 #include <asterisk/module.h>
25 #include <asterisk/lock.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <ctype.h>
30
31 AST_MUTEX_DEFINE_STATIC(modlock);
32
33 #define ast_fit_in_short(in) (in < -32768 ? -32768 : in > 32767 ? 32767 : in)
34 #define AST_NAME_STRLEN 256
35 #define ALL_DONE(u, ret) LOCAL_USER_REMOVE(u); return ret;
36 #define get_volfactor(x) x ? ((x > 0) ? (1 << x) : ((1 << abs(x)) * -1)) : 0
37 #define minmax(x,y) x ? (x > y) ? y : ((x < (y * -1)) ? (y * -1) : x) : 0
38
39
40 static char *synopsis = "Tap into any type of asterisk channel and listen to audio";
41 static char *app = "ChanSpy";
42 static char *desc = "   Chanspy([<scanspec>][|<options>])\n\n"
43 "Valid Options:\n"
44 " - q: quiet, don't announce channels beep, etc.\n"
45 " - b: bridged, only spy on channels involved in a bridged call.\n"
46 " - v([-4..4]): adjust the initial volume. (negative is quieter)\n"
47 " - g(grp): enforce group.  Match only calls where their ${SPYGROUP} is 'grp'.\n\n"
48 "If <scanspec> is specified, only channel names *beginning* with that string will be scanned.\n"
49 "('all' or an empty string are also both valid <scanspec>)\n\n"
50 "While Spying:\n\n"
51 "Dialing # cycles the volume level.\n"
52 "Dialing * will stop spying and look for another channel to spy on.\n"
53 "Dialing a series of digits followed by # builds a channel name to append to <scanspec>\n"
54 "(e.g. run Chanspy(Agent) and dial 1234# while spying to jump to channel Agent/1234)\n\n"
55 "";
56
57 #define OPTION_QUIET     (1 << 0)       /* Quiet, no announcement */
58 #define OPTION_BRIDGED   (1 << 1)       /* Only look at bridged calls */
59 #define OPTION_VOLUME    (1 << 2)       /* Specify initial volume */
60 #define OPTION_GROUP     (1 << 3)   /* Only look at channels in group */
61
62 AST_DECLARE_OPTIONS(chanspy_opts,{
63         ['q'] = { OPTION_QUIET },
64         ['b'] = { OPTION_BRIDGED },
65         ['v'] = { OPTION_VOLUME, 1 },
66         ['g'] = { OPTION_GROUP, 2 },
67 });
68
69 STANDARD_LOCAL_USER;
70 LOCAL_USER_DECL;
71
72 struct chanspy_translation_helper {
73         /* spy data */
74         struct ast_channel_spy spy;
75
76         /* read frame */
77         int fmt0;
78         short *buf0;
79         int len0;
80         struct ast_trans_pvt *trans0;
81
82         /* write frame */
83         int fmt1;
84         struct ast_trans_pvt *trans1;
85         short *buf1;
86         int len1;
87
88         /* muxed frame */
89         struct ast_frame frame;
90         short *buf;
91         int len;
92         
93         int samples;
94         int rsamples;
95         int volfactor;
96 };
97
98 /* Prototypes */
99 static struct ast_channel *local_get_channel_by_name(char *name);
100 static struct ast_channel *local_get_channel_begin_name(char *name);
101 static struct ast_channel *local_channel_walk(struct ast_channel *chan);
102 static void spy_release(struct ast_channel *chan, void *data);
103 static void *spy_alloc(struct ast_channel *chan, void *params);
104 static struct ast_frame *spy_queue_shift(struct ast_channel_spy *spy, int qnum);
105 static void ast_flush_spy_queue(struct ast_channel_spy *spy);
106 static int spy_generate(struct ast_channel *chan, void *data, int len, int samples);
107 static void start_spying(struct ast_channel *chan, struct ast_channel *spychan, struct ast_channel_spy *spy);
108 static void stop_spying(struct ast_channel *chan, struct ast_channel_spy *spy);
109 static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor);
110 static int chanspy_exec(struct ast_channel *chan, void *data);
111
112
113 static struct ast_channel *local_get_channel_by_name(char *name) 
114 {
115         struct ast_channel *ret;
116         ast_mutex_lock(&modlock);
117         if ((ret = ast_get_channel_by_name_locked(name))) {
118                 ast_mutex_unlock(&ret->lock);
119         }
120         ast_mutex_unlock(&modlock);
121
122         return ret;
123 }
124
125 static struct ast_channel *local_channel_walk(struct ast_channel *chan) 
126 {
127         struct ast_channel *ret;
128         ast_mutex_lock(&modlock);       
129         if ((ret = ast_channel_walk_locked(chan))) {
130                 ast_mutex_unlock(&ret->lock);
131         }
132         ast_mutex_unlock(&modlock);                     
133         return ret;
134 }
135
136 static struct ast_channel *local_get_channel_begin_name(char *name) 
137 {
138         struct ast_channel *chan, *ret = NULL;
139         ast_mutex_lock(&modlock);
140         chan = local_channel_walk(NULL);
141         while (chan) {
142                 if (!strncmp(chan->name, name, strlen(name))) {
143                         ret = chan;
144                         break;
145                 }
146                 chan = local_channel_walk(chan);
147         }
148         ast_mutex_unlock(&modlock);
149         
150         return ret;
151 }
152
153
154 static void spy_release(struct ast_channel *chan, void *data) 
155 {
156         struct chanspy_translation_helper *csth = data;
157
158
159         if (csth->trans0) {
160                 ast_translator_free_path(csth->trans0);
161                 csth->trans0 = NULL;
162         }
163         if (csth->trans1) {
164                 ast_translator_free_path(csth->trans1);
165                 csth->trans1 = NULL;
166         }
167
168         if (csth->buf0) {
169                 free(csth->buf0);
170                 csth->buf0 = NULL;
171         }
172         if (csth->buf1) {
173                 free(csth->buf1);
174                 csth->buf1 = NULL;
175         }
176         if (csth->buf) {
177                 free(csth->buf);
178                 csth->buf = NULL;
179         }
180         return;
181 }
182
183 static void *spy_alloc(struct ast_channel *chan, void *params) 
184 {
185         return params;
186 }
187
188 static struct ast_frame *spy_queue_shift(struct ast_channel_spy *spy, int qnum) 
189 {
190         struct ast_frame *f;
191         
192         if (qnum < 0 || qnum > 1)
193                 return NULL;
194
195         f = spy->queue[qnum];
196         if (f) {
197                 spy->queue[qnum] = f->next;
198                 return f;
199         }
200         return NULL;
201 }
202
203
204 static void ast_flush_spy_queue(struct ast_channel_spy *spy) 
205 {
206         struct ast_frame *f=NULL;
207         int x = 0;
208         ast_mutex_lock(&spy->lock);
209         for(x=0;x<2;x++) {
210                 f = NULL;
211                 while((f = spy_queue_shift(spy, x))) 
212                         ast_frfree(f);
213         }
214         ast_mutex_unlock(&spy->lock);
215 }
216
217 static int spy_generate(struct ast_channel *chan, void *data, int len, int samples) 
218 {
219         struct ast_frame *f, *f0, *f1;
220         int x, vf, dlen, maxsamp, loops;
221         struct chanspy_translation_helper *csth = data;
222
223         if (csth->rsamples < csth->samples) {
224                 csth->rsamples += samples;
225                 return 0;
226         } 
227         csth->rsamples += samples;
228         loops = 0;
229         do {
230                 loops++;
231                 f = f0 = f1 = NULL;
232                 x = vf = dlen = maxsamp = 0;
233                 if (csth->rsamples == csth->samples) {
234                         csth->rsamples = csth->samples = 0;
235                 }
236
237                 ast_mutex_lock(&csth->spy.lock);
238                 f0 = spy_queue_shift(&csth->spy, 0);
239                 f1 = spy_queue_shift(&csth->spy, 1);
240                 ast_mutex_unlock(&csth->spy.lock);
241
242                 if (csth->spy.status == CHANSPY_DONE) {
243                         return -1;
244                 }
245         
246                 if (!f0 && !f1) {
247                         return 0;
248                 }
249
250                 if (f0 && csth->fmt0 && csth->fmt0 != f0->subclass) {
251                         ast_translator_free_path(csth->trans0);
252                         csth->trans0 = NULL;
253                         csth->fmt0 = csth->fmt0;
254                 }
255
256                 if (f1 && csth->fmt1 && csth->fmt1 != f1->subclass) {
257                         ast_translator_free_path(csth->trans1);
258                         csth->trans1 = NULL;
259                         csth->fmt1 = csth->fmt1;
260                 }
261         
262                 if (!csth->fmt0 && f0) {
263                         csth->fmt0 = f0->subclass;
264                 }
265
266                 if (!csth->fmt1 && f1) {
267                         csth->fmt1 = f1->subclass;
268                 }
269
270                 if (csth->fmt0 && csth->fmt0 != AST_FORMAT_SLINEAR && !csth->trans0) {
271                         if ((csth->trans0 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt0)) == NULL) {
272                                 ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt0));
273                                 csth->spy.status = CHANSPY_DONE;
274                                 return -1;
275                         }
276                 }
277                 if (csth->fmt1 && csth->fmt1 != AST_FORMAT_SLINEAR && !csth->trans1) {
278                         if ((csth->trans1 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt1)) == NULL) {
279                                 ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt1));
280                                 csth->spy.status = CHANSPY_DONE;
281                                 return -1;
282                         }
283                 }
284         
285                 if (f0) {
286                         if (csth->trans0) {
287                                 if ((f = ast_translate(csth->trans0, f0, 0))) {
288                                         if (csth->len0 < f->datalen) {
289                                                 if (!csth->len0) {
290                                                         if (!(csth->buf0 = malloc(f->datalen * 2))) {
291                                                                 csth->spy.status = CHANSPY_DONE;
292                                                                 return -1;
293                                                         }
294                                                 } else {
295                                                         if (!realloc(csth->buf0, f->datalen * 2)) {
296                                                                 csth->spy.status = CHANSPY_DONE;
297                                                                 return -1;
298                                                         }
299                                                 }
300                                                 csth->len0 = f->datalen;
301                                         }
302                                         memcpy(csth->buf0, f->data, f->datalen);
303                                         maxsamp = f->samples;
304                                         ast_frfree(f);
305                                 } else {
306                                         return 0;
307                                 }
308                         } else {
309                                 memcpy(csth->buf0, f0->data, f0->datalen);
310                                 maxsamp = f0->samples;
311                         }
312                 }
313         
314                 if (f1) {
315                         if (csth->trans1) {
316                                 if ((f = ast_translate(csth->trans1, f1, 0))) {
317                                         if (csth->len1 < f->datalen) {
318                                                 if (!csth->len1) {
319                                                         if (!(csth->buf1 = malloc(f->datalen))) {
320                                                                 csth->spy.status = CHANSPY_DONE;
321                                                                 return -1;
322                                                         }
323                                                 } else {
324                                                         if (!realloc(csth->buf1, f->datalen)) {
325                                                                 csth->spy.status = CHANSPY_DONE;
326                                                                 return -1;
327                                                         }
328                                                 }
329                                                 csth->len1 = f->datalen;
330                                         }
331                                         memcpy(csth->buf1, f->data, f->datalen);
332                                         if (f->samples > maxsamp) {
333                                                 maxsamp = f->samples;
334                                         }
335                                         ast_frfree(f);
336                                 
337                                 } else {
338                                         return 0;
339                                 }
340                         } else {
341                                 memcpy(csth->buf1, f1->data, f1->datalen);
342                                 if (f1->samples > maxsamp) {
343                                         maxsamp = f1->samples;
344                                 }
345                         }
346                 }
347
348                 vf = get_volfactor(csth->volfactor);
349                 vf = minmax(vf, 16);
350
351                 dlen = (csth->len0 > csth->len1) ? csth->len0 : csth->len1;
352
353                 if (csth->len < dlen) {
354                         if (!csth->len) {
355                                 if (!(csth->buf = malloc(dlen*2))) {
356                                         csth->spy.status = CHANSPY_DONE;
357                                         return -1;
358                                 }
359                         } else {
360                                 if (!realloc(csth->buf, dlen * 2)) {
361                                         csth->spy.status = CHANSPY_DONE;
362                                         return -1;
363                                 }
364                         }
365                         csth->len = dlen;
366                 }
367
368                 for(x=0; x < maxsamp; x++) {
369                         if (vf < 0) {
370                                 if (f0) {
371                                         csth->buf0[x] /= abs(vf);
372                                 }
373                                 if (f1) {
374                                         csth->buf1[x] /= abs(vf);
375                                 }
376                         } else if (vf > 0) {
377                                 if (f0) {
378                                         csth->buf0[x] *= vf;
379                                 }
380                                 if (f1) {
381                                         csth->buf1[x] *= vf;
382                                 }
383                         }
384                         if (f0 && f1) {
385                                 if (x < csth->len0 && x < csth->len1) {
386                                         csth->buf[x] = ast_fit_in_short(csth->buf0[x] + csth->buf1[x]);
387                                 } else if (x < csth->len0) {
388                                         csth->buf[x] = csth->buf0[x];
389                                 } else if (x < csth->len1) {
390                                         csth->buf[x] = csth->buf1[x];
391                                 }
392                         } else if (f0 && x < csth->len0) {
393                                 csth->buf[x] = csth->buf0[x];
394                         } else if (f1 && x < csth->len1) {
395                                 csth->buf[x] = csth->buf1[x];
396                         }
397                 }
398
399                 csth->frame.data = csth->buf;
400                 csth->frame.samples = maxsamp;
401                 csth->frame.datalen = csth->frame.samples * 2;
402                 csth->samples += csth->frame.samples;
403                 
404                 if (ast_write(chan, &csth->frame)) {
405                         csth->spy.status = CHANSPY_DONE;
406                         return -1;
407                 }
408
409                 if (f0) {
410                         ast_frfree(f0);
411                 }
412                 if (f1) {
413                         ast_frfree(f1);
414                 }
415
416                 if (loops > 10) {
417                         ast_log(LOG_WARNING, "Too Many Loops Bailing Out....");
418                         break;
419                 }
420         } while (csth->samples <  csth->rsamples);
421
422         return 0;
423 }
424
425 static struct ast_generator spygen = {
426     alloc: spy_alloc, 
427     release: spy_release, 
428     generate: spy_generate, 
429 };
430
431 static void start_spying(struct ast_channel *chan, struct ast_channel *spychan, struct ast_channel_spy *spy) 
432 {
433
434         struct ast_channel_spy *cptr=NULL;
435         struct ast_channel *peer;
436
437
438         ast_log(LOG_WARNING, "Attaching %s to %s\n", spychan->name, chan->name);
439
440
441         ast_mutex_lock(&chan->lock);
442         if (chan->spiers) {
443                 for(cptr=chan->spiers;cptr && cptr->next;cptr=cptr->next);
444                 cptr->next = spy;
445         } else {
446                 chan->spiers = spy;
447         }
448         ast_mutex_unlock(&chan->lock);
449         if ( ast_test_flag(chan, AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(chan))) {
450                 ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);  
451         }
452
453 }
454
455 static void stop_spying(struct ast_channel *chan, struct ast_channel_spy *spy) 
456 {
457         struct ast_channel_spy *cptr=NULL, *prev=NULL;
458         int count = 0;
459
460         while(ast_mutex_trylock(&chan->lock)) {
461                 /* if its locked already it's almost surely hanging up and we are too late 
462                    we can safely remove the head pointer if it points at us without needing a lock.
463                    since everybody spying will be in the same boat whomever is pointing at the head
464                    will surely erase it which is all we really need since it's a linked list of
465                    staticly declared structs that belong to each spy.
466                 */
467                 if (chan->spiers == spy) {
468                         chan->spiers = NULL;
469                         return;
470                 }
471                 count++;
472                 if (count > 10) {
473                         return;
474                 }
475                 sched_yield();
476         }
477
478         for(cptr=chan->spiers; cptr; cptr=cptr->next) {
479                 if (cptr == spy) {
480                         if (prev) {
481                                 prev->next = cptr->next;
482                                 cptr->next = NULL;
483                         } else
484                                 chan->spiers = NULL;
485                 }
486                 prev = cptr;
487         }
488         ast_mutex_unlock(&chan->lock);
489
490 }
491
492 static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor) 
493 {
494         struct chanspy_translation_helper csth;
495         int running = 1, res = 0, x = 0;
496         char inp[24];
497         char *name=NULL;
498         struct ast_frame *f;
499
500         if (chan && !ast_check_hangup(chan) && spyee && !ast_check_hangup(spyee)) {
501                 memset(inp, 0, sizeof(inp));
502                 name = ast_strdupa(spyee->name);
503                 if (option_verbose >= 2)
504                         ast_verbose(VERBOSE_PREFIX_2 "Spying on channel %s\n", name);
505
506                 memset(&csth, 0, sizeof(csth));
507                 csth.spy.status = CHANSPY_RUNNING;
508                 ast_mutex_init(&csth.spy.lock);
509                 csth.volfactor = *volfactor;
510                 csth.frame.frametype = AST_FRAME_VOICE;
511                 csth.frame.subclass = AST_FORMAT_SLINEAR;
512                 csth.frame.datalen = 320;
513                 csth.frame.samples = 160;
514                 start_spying(spyee, chan, &csth.spy);
515                 ast_activate_generator(chan, &spygen, &csth);
516
517                 while(csth.spy.status == CHANSPY_RUNNING && 
518                           chan && !ast_check_hangup(chan) && 
519                           spyee && 
520                           !ast_check_hangup(spyee) 
521                           && running == 1 && 
522                           (res = ast_waitfor(chan, -1) > -1)) {
523                         if ((f = ast_read(chan))) {
524                                 res = 0;
525                                 if (f->frametype == AST_FRAME_DTMF) {
526                                         res = f->subclass;
527                                 }
528                                 ast_frfree(f);
529                                 if (!res) {
530                                         continue;
531                                 }
532                         } else {
533                                 break;
534                         }
535                         if (x == sizeof(inp)) {
536                                 x = 0;
537                         }
538                         if (res < 0) {
539                                 running = -1;
540                         }
541                         if (res == 0) {
542                                 continue;
543                         } else if (res == '*') {
544                                 running = 0; 
545                         } else if (res == '#') {
546                                 if (!ast_strlen_zero(inp)) {
547                                         running = x ? atoi(inp) : -1;
548                                         break;
549                                 } else {
550                                         csth.volfactor++;
551                                         if (csth.volfactor > 4) {
552                                                 csth.volfactor = -4;
553                                         }
554                                         if (option_verbose > 2) {
555                                                 ast_verbose(VERBOSE_PREFIX_3"Setting spy volume on %s to %d\n", chan->name, csth.volfactor);
556                                         }
557                                         *volfactor = csth.volfactor;
558                                 }
559                         } else if (res >= 48 && res <= 57) {
560                                 inp[x++] = res;
561                         }
562                 }
563                 ast_deactivate_generator(chan);
564                 stop_spying(spyee, &csth.spy);
565
566                 if (option_verbose >= 2) {
567                         ast_verbose(VERBOSE_PREFIX_2 "Done Spying on channel %s\n", name);
568                 }
569                 ast_flush_spy_queue(&csth.spy);
570         } else {
571                 running = 0;
572         }
573         ast_mutex_destroy(&csth.spy.lock);
574         return running;
575 }
576
577
578
579 static int chanspy_exec(struct ast_channel *chan, void *data)
580 {
581         struct localuser *u;
582         struct ast_channel *peer=NULL, *prev=NULL;
583         char name[AST_NAME_STRLEN],
584                 peer_name[AST_NAME_STRLEN],
585                 *args,
586                 *ptr = NULL,
587                 *options = NULL,
588                 *spec = NULL,
589                 *argv[5],
590                 *mygroup = NULL;
591         int res = -1,
592                 volfactor = 0,
593                 silent = 0,
594                 argc = 0,
595                 bronly = 0,
596                 chosen = 0,
597                 count=0,
598                 waitms = 100,
599                 num = 0;
600         struct ast_flags flags;
601
602
603         if (!(args = ast_strdupa((char *)data))) {
604                 ast_log(LOG_ERROR, "Out of memory!\n");
605                 return -1;
606         }
607
608         if (ast_set_read_format(chan, AST_FORMAT_SLINEAR) < 0) {
609                 ast_log(LOG_ERROR, "Could Not Set Read Format.\n");
610                 return -1;
611         }
612         
613         if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
614                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
615                 return -1;
616         }
617
618         LOCAL_USER_ADD(u);
619         ast_answer(chan);
620
621         ast_set_flag(chan, AST_FLAG_SPYING); /* so nobody can spy on us while we are spying */
622
623
624         if ((argc = ast_separate_app_args(args, '|', argv, sizeof(argv) / sizeof(argv[0])))) {
625                 spec = argv[0];
626                 if ( argc > 1) {
627                         options = argv[1];
628                 }
629                 if (ast_strlen_zero(spec) || !strcmp(spec, "all")) {
630                         spec = NULL;
631                 }
632         }
633         
634         if (options) {
635                 char *opts[2];
636                 ast_parseoptions(chanspy_opts, &flags, opts, options);
637                 if (ast_test_flag(&flags, OPTION_GROUP)) {
638                         mygroup = opts[1];
639                 }
640                 silent = ast_test_flag(&flags, OPTION_QUIET);
641                 bronly = ast_test_flag(&flags, OPTION_BRIDGED);
642                 if (ast_test_flag(&flags, OPTION_VOLUME) && opts[1]) {
643                         if (sscanf(opts[0], "%d", &volfactor) != 1)
644                                 ast_log(LOG_NOTICE, "volfactor must be a number between -4 and 4\n");
645                         else {
646                                 volfactor = minmax(volfactor, 4);
647                         }
648                 }
649         }
650
651
652         for(;;) {
653                 res = ast_streamfile(chan, "beep", chan->language);
654                 if (!res)
655                         res = ast_waitstream(chan, "");
656                 if (res < 0) {
657                         ast_clear_flag(chan, AST_FLAG_SPYING);
658                         ALL_DONE(u, -1);
659                 }                       
660
661                 count = 0;
662                 res = ast_waitfordigit(chan, waitms);
663                 if (res < 0) {
664                         ast_clear_flag(chan, AST_FLAG_SPYING);
665                         ALL_DONE(u, -1);
666                 }
667                                 
668                 peer = local_channel_walk(NULL);
669                 prev=NULL;
670                 while(peer) {
671                         if (peer != chan) {
672                                 char *group = NULL;
673                                 int igrp = 1;
674
675                                 if (peer == prev && !chosen) {
676                                         break;
677                                 }
678                                 chosen = 0;
679                                 group = pbx_builtin_getvar_helper(peer, "SPYGROUP");
680                                 if (mygroup) {
681                                         if (!group || strcmp(mygroup, group)) {
682                                                 igrp = 0;
683                                         }
684                                 }
685                                 
686                                 if (igrp && (!spec || ((strlen(spec) < strlen(peer->name) &&
687                                                                            !strncasecmp(peer->name, spec, strlen(spec)))))) {
688                                         if (peer && (!bronly || ast_bridged_channel(peer)) &&
689                                                 !ast_check_hangup(peer) && !ast_test_flag(peer, AST_FLAG_SPYING)) {
690                                                 int x = 0;
691
692                                                 strncpy(peer_name, peer->name, AST_NAME_STRLEN);
693                                                 ptr = strchr(peer_name, '/');
694                                                 *ptr = '\0';
695                                                 ptr++;
696                                                 for (x = 0 ; x < strlen(peer_name) ; x++) {
697                                                         if (peer_name[x] == '/') {
698                                                                 break;
699                                                         }
700                                                         peer_name[x] = tolower(peer_name[x]);
701                                                 }
702
703                                                 if (!silent) {
704                                                         if (ast_fileexists(peer_name, NULL, NULL) != -1) {
705                                                                 res = ast_streamfile(chan, peer_name, chan->language);
706                                                                 if (!res)
707                                                                         res = ast_waitstream(chan, "");
708                                                                 if (res)
709                                                                         break;
710                                                         } else
711                                                                 res = ast_say_character_str(chan, peer_name, "", chan->language);
712                                                         if ((num=atoi(ptr))) 
713                                                                 ast_say_digits(chan, atoi(ptr), "", chan->language);
714                                                 }
715                                                 count++;
716                                                 prev = peer;
717                                                 res = channel_spy(chan, peer, &volfactor);
718                                                 if (res == -1) {
719                                                         ast_clear_flag(chan, AST_FLAG_SPYING);
720                                                         ALL_DONE(u, -1);
721                                                 } else if (res > 1 && spec) {
722                                                         snprintf(name, AST_NAME_STRLEN, "%s/%d", spec, res);
723                                                         if ((peer = local_get_channel_begin_name(name))) {
724                                                                 chosen = 1;
725                                                         }
726                                                         continue;
727                                                 }
728                                         }
729                                 }
730                         }
731                         if ((peer = local_channel_walk(peer)) == NULL) {
732                                 break;
733                         }
734                 }
735                 waitms = count ? 100 : 5000;
736         }
737         
738
739         ast_clear_flag(chan, AST_FLAG_SPYING);
740         ALL_DONE(u, res);
741 }
742
743 int unload_module(void)
744 {
745         STANDARD_HANGUP_LOCALUSERS;
746         return ast_unregister_application(app);
747 }
748
749 int load_module(void)
750 {
751         return ast_register_application(app, chanspy_exec, synopsis, desc);
752 }
753
754 char *description(void)
755 {
756         return synopsis;
757 }
758
759 int usecount(void)
760 {
761         int res;
762         STANDARD_USECOUNT(res);
763         return res;
764 }
765
766 char *key()
767 {
768         return ASTERISK_GPL_KEY;
769 }