don't play any sounds when using the quiet option (bug #4348)
[asterisk/asterisk.git] / apps / app_chanspy.c
index 4561d98..292a151 100755 (executable)
  * the GNU General Public License
  */
 
-#include <asterisk/file.h>
-#include <asterisk/logger.h>
-#include <asterisk/channel.h>
-#include <asterisk/features.h>
-#include <asterisk/options.h>
-#include <asterisk/app.h>
-#include <asterisk/utils.h>
-#include <asterisk/say.h>
-#include <asterisk/pbx.h>
-#include <asterisk/translate.h>
-#include <asterisk/module.h>
-#include <asterisk/lock.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
 #include <ctype.h>
 
+#include "asterisk.h"
+#include "asterisk/file.h"
+#include "asterisk/logger.h"
+#include "asterisk/channel.h"
+#include "asterisk/features.h"
+#include "asterisk/options.h"
+#include "asterisk/app.h"
+#include "asterisk/utils.h"
+#include "asterisk/say.h"
+#include "asterisk/pbx.h"
+#include "asterisk/translate.h"
+#include "asterisk/module.h"
+#include "asterisk/lock.h"
+
+#define AST_MONITOR_DIR AST_SPOOL_DIR "/monitor"
+
 AST_MUTEX_DEFINE_STATIC(modlock);
 
 #define ast_fit_in_short(in) (in < -32768 ? -32768 : in > 32767 ? 32767 : in)
-#define find_smallest_of_three(a, b, c) ((a < b && a < c) ? a : (b < a && b < c) ? b : c)
 #define AST_NAME_STRLEN 256
 #define ALL_DONE(u, ret) LOCAL_USER_REMOVE(u); return ret;
 #define get_volfactor(x) x ? ((x > 0) ? (1 << x) : ((1 << abs(x)) * -1)) : 0
 #define minmax(x,y) x ? (x > y) ? y : ((x < (y * -1)) ? (y * -1) : x) : 0
-#define CS_BUFLEN 640
 
 
 static char *synopsis = "Tap into any type of asterisk channel and listen to audio";
@@ -46,7 +48,8 @@ static char *desc = "   Chanspy([<scanspec>][|<options>])\n\n"
 " - q: quiet, don't announce channels beep, etc.\n"
 " - b: bridged, only spy on channels involved in a bridged call.\n"
 " - v([-4..4]): adjust the initial volume. (negative is quieter)\n"
-" - g(grp): enforce group.  Match only calls where their ${SPYGROUP} is 'grp'.\n\n"
+" - g(grp): enforce group.  Match only calls where their ${SPYGROUP} is 'grp'.\n"
+" - r[(basename)]: Record session to monitor spool dir (with optional basename, default is 'chanspy')\n\n"
 "If <scanspec> is specified, only channel names *beginning* with that string will be scanned.\n"
 "('all' or an empty string are also both valid <scanspec>)\n\n"
 "While Spying:\n\n"
@@ -60,27 +63,47 @@ static char *desc = "   Chanspy([<scanspec>][|<options>])\n\n"
 #define OPTION_BRIDGED   (1 << 1)      /* Only look at bridged calls */
 #define OPTION_VOLUME    (1 << 2)      /* Specify initial volume */
 #define OPTION_GROUP     (1 << 3)   /* Only look at channels in group */
+#define OPTION_RECORD    (1 << 4)   /* Record */
 
 AST_DECLARE_OPTIONS(chanspy_opts,{
        ['q'] = { OPTION_QUIET },
        ['b'] = { OPTION_BRIDGED },
        ['v'] = { OPTION_VOLUME, 1 },
        ['g'] = { OPTION_GROUP, 2 },
+       ['r'] = { OPTION_RECORD, 3 },
 });
 
 STANDARD_LOCAL_USER;
-
 LOCAL_USER_DECL;
 
 struct chanspy_translation_helper {
+       /* spy data */
+       struct ast_channel_spy spy;
+
+       /* read frame */
+       int fmt0;
+       short *buf0;
+       int len0;
        struct ast_trans_pvt *trans0;
+
+       /* write frame */
+       int fmt1;
        struct ast_trans_pvt *trans1;
+       short *buf1;
+       int len1;
+
+       /* muxed frame */
+       struct ast_frame frame;
+       short *buf;
+       int len;
+       
+       int samples;
+       int rsamples;
        int volfactor;
-       struct ast_channel_spy *spy;
+       int fd;
 };
 
 /* Prototypes */
-static struct ast_channel *local_get_channel_by_name(char *name);
 static struct ast_channel *local_get_channel_begin_name(char *name);
 static struct ast_channel *local_channel_walk(struct ast_channel *chan);
 static void spy_release(struct ast_channel *chan, void *data);
@@ -90,10 +113,11 @@ static void ast_flush_spy_queue(struct ast_channel_spy *spy);
 static int spy_generate(struct ast_channel *chan, void *data, int len, int samples);
 static void start_spying(struct ast_channel *chan, struct ast_channel *spychan, struct ast_channel_spy *spy);
 static void stop_spying(struct ast_channel *chan, struct ast_channel_spy *spy);
-static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor);
+static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor, int fd);
 static int chanspy_exec(struct ast_channel *chan, void *data);
 
 
+#if 0
 static struct ast_channel *local_get_channel_by_name(char *name) 
 {
        struct ast_channel *ret;
@@ -105,6 +129,7 @@ static struct ast_channel *local_get_channel_by_name(char *name)
 
        return ret;
 }
+#endif
 
 static struct ast_channel *local_channel_walk(struct ast_channel *chan) 
 {
@@ -138,20 +163,29 @@ static struct ast_channel *local_get_channel_begin_name(char *name)
 static void spy_release(struct ast_channel *chan, void *data) 
 {
        struct chanspy_translation_helper *csth = data;
-       int same=0;
 
-       same = (csth->trans0 == csth->trans1) ? 1 : 0;
 
        if (csth->trans0) {
                ast_translator_free_path(csth->trans0);
                csth->trans0 = NULL;
        }
-       if (same)
-               return;
        if (csth->trans1) {
                ast_translator_free_path(csth->trans1);
                csth->trans1 = NULL;
        }
+
+       if (csth->buf0) {
+               free(csth->buf0);
+               csth->buf0 = NULL;
+       }
+       if (csth->buf1) {
+               free(csth->buf1);
+               csth->buf1 = NULL;
+       }
+       if (csth->buf) {
+               free(csth->buf);
+               csth->buf = NULL;
+       }
        return;
 }
 
@@ -189,98 +223,243 @@ static void ast_flush_spy_queue(struct ast_channel_spy *spy)
        ast_mutex_unlock(&spy->lock);
 }
 
-
 static int spy_generate(struct ast_channel *chan, void *data, int len, int samples) 
 {
-       struct ast_frame *f0, *f1, write_frame, *f;
-       int x=0, framelen_a = 0, framelen_b = 0, size = 0;
-       short buf[CS_BUFLEN], buf0[CS_BUFLEN], buf1[CS_BUFLEN];
+       struct ast_frame *f, *f0, *f1;
+       int x, vf, dlen, maxsamp, loops;
        struct chanspy_translation_helper *csth = data;
-       int nc = 0, vf;
+
+       if (csth->rsamples < csth->samples) {
+               csth->rsamples += samples;
+               return 0;
+       } 
+       csth->rsamples += samples;
+       loops = 0;
+       do {
+               loops++;
+               f = f0 = f1 = NULL;
+               x = vf = dlen = maxsamp = 0;
+               if (csth->rsamples == csth->samples) {
+                       csth->rsamples = csth->samples = 0;
+               }
+
+               ast_mutex_lock(&csth->spy.lock);
+               f0 = spy_queue_shift(&csth->spy, 0);
+               f1 = spy_queue_shift(&csth->spy, 1);
+               ast_mutex_unlock(&csth->spy.lock);
+
+               if (csth->spy.status == CHANSPY_DONE) {
+                       return -1;
+               }
+       
+               if (!f0 && !f1) {
+                       return 0;
+               }
+
+               if (f0 && csth->fmt0 && csth->fmt0 != f0->subclass) {
+                       ast_translator_free_path(csth->trans0);
+                       csth->trans0 = NULL;
+                       csth->fmt0 = f0->subclass;
+               }
+
+               if (f1 && csth->fmt1 && csth->fmt1 != f1->subclass) {
+                       ast_translator_free_path(csth->trans1);
+                       csth->trans1 = NULL;
+                       csth->fmt1 = f1->subclass;
+               }
        
-       ast_mutex_lock(&csth->spy->lock);
-       f0 = spy_queue_shift(csth->spy, 0);
-       f1 = spy_queue_shift(csth->spy, 1);
-       ast_mutex_unlock(&csth->spy->lock);
-
-       if (f0 && f1) {
-               if (!csth->trans0) {
-                       if (f0->subclass != AST_FORMAT_SLINEAR && (csth->trans0 = ast_translator_build_path(AST_FORMAT_SLINEAR, f0->subclass)) == NULL) {
-                               ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(f0->subclass));
+               if (!csth->fmt0 && f0) {
+                       csth->fmt0 = f0->subclass;
+               }
+
+               if (!csth->fmt1 && f1) {
+                       csth->fmt1 = f1->subclass;
+               }
+
+               if (csth->fmt0 && csth->fmt0 != AST_FORMAT_SLINEAR && !csth->trans0) {
+                       if ((csth->trans0 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt0)) == NULL) {
+                               ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt0));
+                               csth->spy.status = CHANSPY_DONE;
                                return -1;
                        }
-                       if (!csth->trans1) {
-                               if (f1->subclass == f0->subclass) {
-                                       csth->trans1 = csth->trans0;
-                               } else if (f1->subclass != AST_FORMAT_SLINEAR && (csth->trans1 = ast_translator_build_path(AST_FORMAT_SLINEAR, f1->subclass)) == NULL) {
-                                       ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(f1->subclass));
-                                       return -1;
+               }
+               if (csth->fmt1 && csth->fmt1 != AST_FORMAT_SLINEAR && !csth->trans1) {
+                       if ((csth->trans1 = ast_translator_build_path(AST_FORMAT_SLINEAR, csth->fmt1)) == NULL) {
+                               ast_log(LOG_WARNING, "Cannot build a path from %s to slin\n", ast_getformatname(csth->fmt1));
+                               csth->spy.status = CHANSPY_DONE;
+                               return -1;
+                       }
+               }
+       
+               if (f0) {
+                       if (csth->trans0) {
+                               if ((f = ast_translate(csth->trans0, f0, 0))) {
+                                       if (csth->len0 < f->datalen) {
+                                               if (!csth->len0) {
+                                                       if (!(csth->buf0 = malloc(f->datalen * 2))) {
+                                                               csth->spy.status = CHANSPY_DONE;
+                                                               return -1;
+                                                       }
+                                               } else {
+                                                       if (!realloc(csth->buf0, f->datalen * 2)) {
+                                                               csth->spy.status = CHANSPY_DONE;
+                                                               return -1;
+                                                       }
+                                               }
+                                               csth->len0 = f->datalen;
+                                       }
+                                       memcpy(csth->buf0, f->data, f->datalen);
+                                       maxsamp = f->samples;
+                                       ast_frfree(f);
+                               } else {
+                                       return 0;
                                }
-                               
+                       } else {
+                               if (csth->len0 < f0->datalen) {
+                                       if (!csth->len0) {
+                                               if (!(csth->buf0 = malloc(f0->datalen * 2))) {
+                                                       csth->spy.status = CHANSPY_DONE;
+                                                       return -1;
+                                               }
+                                       } else {
+                                               if (!realloc(csth->buf0, f0->datalen * 2)) {
+                                                       csth->spy.status = CHANSPY_DONE;
+                                                       return -1;
+                                               }
+                                       }
+                                       csth->len0 = f0->datalen;
+                               }
+                               memcpy(csth->buf0, f0->data, f0->datalen);
+                               maxsamp = f0->samples;
                        }
                }
-
-               memset(buf, 0, sizeof(buf));
-               memset(buf0, 0, sizeof(buf0));
-               memset(buf1, 0, sizeof(buf1));
-               if (csth->trans0) {
-                       if ((f = ast_translate(csth->trans0, f0, 0))) {
-                               framelen_a = f->datalen * sizeof(short);
-                               memcpy(buf0, f->data, framelen_a);
-                               ast_frfree(f);
-                       } else 
-                               return 0;
-               } else {
-                       framelen_a = f0->datalen * sizeof(short);
-                       memcpy(buf0, f0->data, framelen_a);
-               }
-               if (csth->trans1) {
-                       if ((f = ast_translate(csth->trans1, f1, 0))) {
-                               framelen_b = f->datalen * sizeof(short);
-                               memcpy(buf1, f->data, framelen_b);
-                               ast_frfree(f);
-                       } else 
-                               return 0;
-               } else {
-                       framelen_b = f1->datalen * sizeof(short);
-                       memcpy(buf1, f1->data, framelen_b);
+       
+               if (f1) {
+                       if (csth->trans1) {
+                               if ((f = ast_translate(csth->trans1, f1, 0))) {
+                                       if (csth->len1 < f->datalen) {
+                                               if (!csth->len1) {
+                                                       if (!(csth->buf1 = malloc(f->datalen * 2))) {
+                                                               csth->spy.status = CHANSPY_DONE;
+                                                               return -1;
+                                                       }
+                                               } else {
+                                                       if (!realloc(csth->buf1, f->datalen * 2)) {
+                                                               csth->spy.status = CHANSPY_DONE;
+                                                               return -1;
+                                                       }
+                                               }
+                                               csth->len1 = f->datalen;
+                                       }
+                                       memcpy(csth->buf1, f->data, f->datalen);
+                                       if (f->samples > maxsamp) {
+                                               maxsamp = f->samples;
+                                       }
+                                       ast_frfree(f);
+                               
+                               } else {
+                                       return 0;
+                               }
+                       } else {
+                               if (csth->len1 < f1->datalen) {
+                                       if (!csth->len1) {
+                                               if (!(csth->buf1 = malloc(f1->datalen * 2))) {
+                                                       csth->spy.status = CHANSPY_DONE;
+                                                       return -1;
+                                               }
+                                       } else {
+                                               if (!realloc(csth->buf1, f1->datalen * 2)) {
+                                                       csth->spy.status = CHANSPY_DONE;
+                                                       return -1;
+                                               }
+                                       }
+                                       csth->len1 = f1->datalen;
+                               }
+                               memcpy(csth->buf1, f1->data, f1->datalen);
+                               if (f1->samples > maxsamp) {
+                                       maxsamp = f1->samples;
+                               }
+                       }
                }
-               size = find_smallest_of_three(len, framelen_a, framelen_b);
 
                vf = get_volfactor(csth->volfactor);
                vf = minmax(vf, 16);
-               for(x=0; x < size; x++) {
+
+               dlen = (csth->len0 > csth->len1) ? csth->len0 : csth->len1;
+
+               if (csth->len < dlen) {
+                       if (!csth->len) {
+                               if (!(csth->buf = malloc(dlen*2))) {
+                                       csth->spy.status = CHANSPY_DONE;
+                                       return -1;
+                               }
+                       } else {
+                               if (!realloc(csth->buf, dlen * 2)) {
+                                       csth->spy.status = CHANSPY_DONE;
+                                       return -1;
+                               }
+                       }
+                       csth->len = dlen;
+               }
+
+               for(x=0; x < maxsamp; x++) {
                        if (vf < 0) {
-                               buf0[x] /= abs(vf);
-                               buf1[x] /= abs(vf);
+                               if (f0) {
+                                       csth->buf0[x] /= abs(vf);
+                               }
+                               if (f1) {
+                                       csth->buf1[x] /= abs(vf);
+                               }
                        } else if (vf > 0) {
-                               buf0[x] *= vf;
-                               buf1[x] *= vf;
+                               if (f0) {
+                                       csth->buf0[x] *= vf;
+                               }
+                               if (f1) {
+                                       csth->buf1[x] *= vf;
+                               }
                        }
-                       buf[x] = ast_fit_in_short(buf0[x] + buf1[x]);
-               }
-               memset(&write_frame, 0, sizeof(write_frame));
-               write_frame.frametype = AST_FRAME_VOICE;
-               write_frame.subclass = AST_FORMAT_SLINEAR;
-               write_frame.datalen = size;
-               write_frame.samples = size;
-               write_frame.data = buf;
-               write_frame.offset = 0;
-               ast_write(chan, &write_frame);
-       } else {
-               nc++;
-               if(nc > 1) {
+                       if (f0 && f1) {
+                               if (x < csth->len0 && x < csth->len1) {
+                                       csth->buf[x] = ast_fit_in_short(csth->buf0[x] + csth->buf1[x]);
+                               } else if (x < csth->len0) {
+                                       csth->buf[x] = csth->buf0[x];
+                               } else if (x < csth->len1) {
+                                       csth->buf[x] = csth->buf1[x];
+                               }
+                       } else if (f0 && x < csth->len0) {
+                               csth->buf[x] = csth->buf0[x];
+                       } else if (f1 && x < csth->len1) {
+                               csth->buf[x] = csth->buf1[x];
+                       }
+               }
+
+               csth->frame.data = csth->buf;
+               csth->frame.samples = maxsamp;
+               csth->frame.datalen = csth->frame.samples * 2;
+               csth->samples += csth->frame.samples;
+               
+               if (ast_write(chan, &csth->frame)) {
+                       csth->spy.status = CHANSPY_DONE;
                        return -1;
                }
-       }
-       
-       if (f0)
-               ast_frfree(f0);
-       if (f1) 
-               ast_frfree(f1);
+               if (csth->fd) {
+                       write(csth->fd, csth->frame.data, csth->frame.datalen);
+               }
 
-       return 0;
+               if (f0) {
+                       ast_frfree(f0);
+               }
+               if (f1) {
+                       ast_frfree(f1);
+               }
+
+               if (loops > 10) {
+                       ast_log(LOG_WARNING, "Too Many Loops Bailing Out....");
+                       break;
+               }
+       } while (csth->samples <  csth->rsamples);
 
+       return 0;
 }
 
 static struct ast_generator spygen = {
@@ -330,7 +509,7 @@ static void stop_spying(struct ast_channel *chan, struct ast_channel_spy *spy)
                        return;
                }
                count++;
-               if(count > 10) {
+               if (count > 10) {
                        return;
                }
                sched_yield();
@@ -350,33 +529,52 @@ static void stop_spying(struct ast_channel *chan, struct ast_channel_spy *spy)
 
 }
 
-static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor) 
+static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int *volfactor, int fd) 
 {
        struct chanspy_translation_helper csth;
        int running = 1, res = 0, x = 0;
        char inp[24];
        char *name=NULL;
-       struct ast_channel_spy spy;
+       struct ast_frame *f;
 
        if (chan && !ast_check_hangup(chan) && spyee && !ast_check_hangup(spyee)) {
                memset(inp, 0, sizeof(inp));
                name = ast_strdupa(spyee->name);
                if (option_verbose >= 2)
                        ast_verbose(VERBOSE_PREFIX_2 "Spying on channel %s\n", name);
-               
-               memset(&spy, 0, sizeof(struct ast_channel_spy));
-               spy.status = CHANSPY_RUNNING;
-               ast_mutex_init(&spy.lock);
-               start_spying(spyee, chan, &spy);
-               
+
                memset(&csth, 0, sizeof(csth));
+               csth.spy.status = CHANSPY_RUNNING;
+               ast_mutex_init(&csth.spy.lock);
                csth.volfactor = *volfactor;
-               csth.spy = &spy;
+               csth.frame.frametype = AST_FRAME_VOICE;
+               csth.frame.subclass = AST_FORMAT_SLINEAR;
+               csth.frame.datalen = 320;
+               csth.frame.samples = 160;
+               if (fd) {
+                       csth.fd = fd;
+               }
+               start_spying(spyee, chan, &csth.spy);
                ast_activate_generator(chan, &spygen, &csth);
 
-               while(spy.status == CHANSPY_RUNNING && chan && !ast_check_hangup(chan) && spyee && !ast_check_hangup(spyee) && running == 1) {
-                       res = ast_waitfordigit(chan, 100);
-
+               while(csth.spy.status == CHANSPY_RUNNING && 
+                         chan && !ast_check_hangup(chan) && 
+                         spyee && 
+                         !ast_check_hangup(spyee) 
+                         && running == 1 && 
+                         (res = ast_waitfor(chan, -1) > -1)) {
+                       if ((f = ast_read(chan))) {
+                               res = 0;
+                               if (f->frametype == AST_FRAME_DTMF) {
+                                       res = f->subclass;
+                               }
+                               ast_frfree(f);
+                               if (!res) {
+                                       continue;
+                               }
+                       } else {
+                               break;
+                       }
                        if (x == sizeof(inp)) {
                                x = 0;
                        }
@@ -406,16 +604,16 @@ static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int
                        }
                }
                ast_deactivate_generator(chan);
-               stop_spying(spyee, &spy);
+               stop_spying(spyee, &csth.spy);
 
-               if (option_verbose >= 2)
+               if (option_verbose >= 2) {
                        ast_verbose(VERBOSE_PREFIX_2 "Done Spying on channel %s\n", name);
-
-               ast_flush_spy_queue(&spy);
+               }
+               ast_flush_spy_queue(&csth.spy);
        } else {
                running = 0;
        }
-       ast_mutex_destroy(&spy.lock);
+       ast_mutex_destroy(&csth.spy.lock);
        return running;
 }
 
@@ -423,33 +621,44 @@ static int channel_spy(struct ast_channel *chan, struct ast_channel *spyee, int
 
 static int chanspy_exec(struct ast_channel *chan, void *data)
 {
-       int res=-1;
        struct localuser *u;
        struct ast_channel *peer=NULL, *prev=NULL;
-       char *ptr=NULL;
-       char name[AST_NAME_STRLEN], peer_name[AST_NAME_STRLEN];
-       int count=0, waitms=100, num=0;
-       char *args;
+       char name[AST_NAME_STRLEN],
+               peer_name[AST_NAME_STRLEN],
+               *args,
+               *ptr = NULL,
+               *options = NULL,
+               *spec = NULL,
+               *argv[5],
+               *mygroup = NULL,
+               *recbase = NULL;
+       int res = -1,
+               volfactor = 0,
+               silent = 0,
+               argc = 0,
+               bronly = 0,
+               chosen = 0,
+               count=0,
+               waitms = 100,
+               num = 0,
+               oldrf = 0,
+               oldwf = 0,
+               fd = 0;
        struct ast_flags flags;
-       char *options=NULL;
-       char *spec = NULL;
-       int volfactor=0;
-       int silent=0;
-       int argc = 0;
-       char *argv[5];
-       char *mygroup = NULL;
-       int bronly = 0;
-       int chosen = 0;
+
 
        if (!(args = ast_strdupa((char *)data))) {
                ast_log(LOG_ERROR, "Out of memory!\n");
                return -1;
        }
 
+       oldrf = chan->readformat;
+       oldwf = chan->writeformat;
        if (ast_set_read_format(chan, AST_FORMAT_SLINEAR) < 0) {
                ast_log(LOG_ERROR, "Could Not Set Read Format.\n");
                return -1;
        }
+       
        if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) {
                ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
                return -1;
@@ -472,11 +681,16 @@ static int chanspy_exec(struct ast_channel *chan, void *data)
        }
        
        if (options) {
-               char *opts[2];
+               char *opts[3];
                ast_parseoptions(chanspy_opts, &flags, opts, options);
                if (ast_test_flag(&flags, OPTION_GROUP)) {
                        mygroup = opts[1];
                }
+               if (ast_test_flag(&flags, OPTION_RECORD)) {
+                       if (!(recbase = opts[2])) {
+                               recbase = "chanspy";
+                       }
+               }
                silent = ast_test_flag(&flags, OPTION_QUIET);
                bronly = ast_test_flag(&flags, OPTION_BRIDGED);
                if (ast_test_flag(&flags, OPTION_VOLUME) && opts[1]) {
@@ -488,21 +702,31 @@ static int chanspy_exec(struct ast_channel *chan, void *data)
                }
        }
 
+       if (recbase) {
+               char filename[512];
+               snprintf(filename,sizeof(filename),"%s/%s.%ld.raw",AST_MONITOR_DIR, recbase, time(NULL));
+               if ((fd = open(filename, O_CREAT | O_WRONLY, O_TRUNC)) <= 0) {
+                       ast_log(LOG_WARNING, "Cannot open %s for recording\n", filename);
+                       fd = 0;
+               }
+       }
 
        for(;;) {
-               res = ast_streamfile(chan, "beep", chan->language);
-               if (!res)
-                       res = ast_waitstream(chan, "");
-               if (res < 0) {
-                       ast_clear_flag(chan, AST_FLAG_SPYING);
-                       ALL_DONE(u, -1);
-               }                       
+               if (!silent) {
+                       res = ast_streamfile(chan, "beep", chan->language);
+                       if (!res)
+                               res = ast_waitstream(chan, "");
+                       if (res < 0) {
+                               ast_clear_flag(chan, AST_FLAG_SPYING);
+                               break;
+                       }
+               }
 
                count = 0;
                res = ast_waitfordigit(chan, waitms);
                if (res < 0) {
                        ast_clear_flag(chan, AST_FLAG_SPYING);
-                       ALL_DONE(u, -1);
+                       break;
                }
                                
                peer = local_channel_walk(NULL);
@@ -534,7 +758,7 @@ static int chanspy_exec(struct ast_channel *chan, void *data)
                                                *ptr = '\0';
                                                ptr++;
                                                for (x = 0 ; x < strlen(peer_name) ; x++) {
-                                                       if(peer_name[x] == '/') {
+                                                       if (peer_name[x] == '/') {
                                                                break;
                                                        }
                                                        peer_name[x] = tolower(peer_name[x]);
@@ -554,10 +778,9 @@ static int chanspy_exec(struct ast_channel *chan, void *data)
                                                }
                                                count++;
                                                prev = peer;
-                                               res = channel_spy(chan, peer, &volfactor);
+                                               res = channel_spy(chan, peer, &volfactor, fd);
                                                if (res == -1) {
-                                                       ast_clear_flag(chan, AST_FLAG_SPYING);
-                                                       ALL_DONE(u, -1);
+                                                       break;
                                                } else if (res > 1 && spec) {
                                                        snprintf(name, AST_NAME_STRLEN, "%s/%d", spec, res);
                                                        if ((peer = local_get_channel_begin_name(name))) {
@@ -576,6 +799,18 @@ static int chanspy_exec(struct ast_channel *chan, void *data)
        }
        
 
+       if (fd > 0) {
+               close(fd);
+       }
+
+       if (oldrf && ast_set_read_format(chan, oldrf) < 0) {
+               ast_log(LOG_ERROR, "Could Not Set Read Format.\n");
+       }
+       
+       if (oldwf && ast_set_write_format(chan, oldwf) < 0) {
+               ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
+       }
+
        ast_clear_flag(chan, AST_FLAG_SPYING);
        ALL_DONE(u, res);
 }