9337299100a6ffa1d662b22c9e92dfbdceb4fe37
[asterisk/asterisk.git] / apps / app_chanspy.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005 Anthony Minessale II (anthmct@yahoo.com)
5  * Copyright (C) 2005 - 2008, Digium, Inc.
6  *
7  * A license has been granted to Digium (via disclaimer) for the use of
8  * this code.
9  *
10  * See http://www.asterisk.org for more information about
11  * the Asterisk project. Please do not directly contact
12  * any of the maintainers of this project for assistance;
13  * the project provides a web site, mailing lists and IRC
14  * channels for your use.
15  *
16  * This program is free software, distributed under the terms of
17  * the GNU General Public License Version 2. See the LICENSE file
18  * at the top of the source tree.
19  */
20
21 /*! \file
22  *
23  * \brief ChanSpy: Listen in on any channel.
24  *
25  * \author Anthony Minessale II <anthmct@yahoo.com>
26  * \author Joshua Colp <jcolp@digium.com>
27  * \author Russell Bryant <russell@digium.com>
28  *
29  * \ingroup applications
30  */
31
32 /*** MODULEINFO
33         <support_level>core</support_level>
34  ***/
35
36 #include "asterisk.h"
37
38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
39
40 #include <ctype.h>
41 #include <errno.h>
42
43 #include "asterisk/paths.h" /* use ast_config_AST_MONITOR_DIR */
44 #include "asterisk/file.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/audiohook.h"
47 #include "asterisk/features.h"
48 #include "asterisk/app.h"
49 #include "asterisk/utils.h"
50 #include "asterisk/say.h"
51 #include "asterisk/pbx.h"
52 #include "asterisk/translate.h"
53 #include "asterisk/manager.h"
54 #include "asterisk/module.h"
55 #include "asterisk/lock.h"
56 #include "asterisk/options.h"
57 #include "asterisk/autochan.h"
58
59 #define AST_NAME_STRLEN 256
60 #define NUM_SPYGROUPS 128
61
62 /*** DOCUMENTATION
63         <application name="ChanSpy" language="en_US">
64                 <synopsis>
65                         Listen to a channel, and optionally whisper into it.
66                 </synopsis>
67                 <syntax>
68                         <parameter name="chanprefix" />
69                         <parameter name="options">
70                                 <optionlist>
71                                         <option name="b">
72                                                 <para>Only spy on channels involved in a bridged call.</para>
73                                         </option>
74                                         <option name="B">
75                                                 <para>Instead of whispering on a single channel barge in on both
76                                                 channels involved in the call.</para>
77                                         </option>
78                                         <option name="c">
79                                                 <argument name="digit" required="true">
80                                                         <para>Specify a DTMF digit that can be used to spy on the next available channel.</para>
81                                                 </argument>
82                                         </option>
83                                         <option name="d">
84                                                 <para>Override the typical numeric DTMF functionality and instead
85                                                 use DTMF to switch between spy modes.</para>
86                                                 <enumlist>
87                                                         <enum name="4">
88                                                                 <para>spy mode</para>
89                                                         </enum>
90                                                         <enum name="5">
91                                                                 <para>whisper mode</para>
92                                                         </enum>
93                                                         <enum name="6">
94                                                                 <para>barge mode</para>
95                                                         </enum>
96                                                 </enumlist>
97                                         </option>
98                                         <option name="e">
99                                                 <argument name="ext" required="true" />
100                                                 <para>Enable <emphasis>enforced</emphasis> mode, so the spying channel can
101                                                 only monitor extensions whose name is in the <replaceable>ext</replaceable> : delimited 
102                                                 list.</para>
103                                         </option>
104                                         <option name="E">
105                                                 <para>Exit when the spied-on channel hangs up.</para>
106                                         </option>
107                                         <option name="g">
108                                                 <argument name="grp" required="true">
109                                                         <para>Only spy on channels in which one or more of the groups
110                                                         listed in <replaceable>grp</replaceable> matches one or more groups from the
111                                                         <variable>SPYGROUP</variable> variable set on the channel to be spied upon.</para>
112                                                 </argument>
113                                                 <note><para>both <replaceable>grp</replaceable> and <variable>SPYGROUP</variable> can contain 
114                                                 either a single group or a colon-delimited list of groups, such
115                                                 as <literal>sales:support:accounting</literal>.</para></note>
116                                         </option>
117                                         <option name="n" argsep="@">
118                                                 <para>Say the name of the person being spied on if that person has recorded
119                                                 his/her name. If a context is specified, then that voicemail context will
120                                                 be searched when retrieving the name, otherwise the <literal>default</literal> context
121                                                 be used when searching for the name (i.e. if SIP/1000 is the channel being
122                                                 spied on and no mailbox is specified, then <literal>1000</literal> will be used when searching
123                                                 for the name).</para>
124                                                 <argument name="mailbox" />
125                                                 <argument name="context" />
126                                         </option>
127                                         <option name="o">
128                                                 <para>Only listen to audio coming from this channel.</para>
129                                         </option>
130                                         <option name="q">
131                                                 <para>Don't play a beep when beginning to spy on a channel, or speak the
132                                                 selected channel name.</para>
133                                         </option>
134                                         <option name="r">
135                                                 <para>Record the session to the monitor spool directory. An optional base for the filename 
136                                                 may be specified. The default is <literal>chanspy</literal>.</para>
137                                                 <argument name="basename" />
138                                         </option>
139                                         <option name="s">
140                                                 <para>Skip the playback of the channel type (i.e. SIP, IAX, etc) when
141                                                 speaking the selected channel name.</para>
142                                         </option>
143                                         <option name="S">
144                                                 <para>Stop when no more channels are left to spy on.</para>
145                                         </option>
146                                         <option name="v">
147                                                 <argument name="value" />
148                                                 <para>Adjust the initial volume in the range from <literal>-4</literal> 
149                                                 to <literal>4</literal>. A negative value refers to a quieter setting.</para>
150                                         </option>
151                                         <option name="w">
152                                                 <para>Enable <literal>whisper</literal> mode, so the spying channel can talk to
153                                                 the spied-on channel.</para>
154                                         </option>
155                                         <option name="W">
156                                                 <para>Enable <literal>private whisper</literal> mode, so the spying channel can
157                                                 talk to the spied-on channel but cannot listen to that channel.</para>
158                                         </option>
159                                         <option name="x">
160                                                 <argument name="digit" required="true">
161                                                         <para>Specify a DTMF digit that can be used to exit the application.</para>
162                                                 </argument>
163                                         </option>
164                                         <option name="X">
165                                                 <para>Allow the user to exit ChanSpy to a valid single digit
166                                                 numeric extension in the current context or the context
167                                                 specified by the <variable>SPY_EXIT_CONTEXT</variable> channel variable. The
168                                                 name of the last channel that was spied on will be stored
169                                                 in the <variable>SPY_CHANNEL</variable> variable.</para>
170                                         </option>
171                                 </optionlist>           
172                         </parameter>
173                 </syntax>
174                 <description>
175                         <para>This application is used to listen to the audio from an Asterisk channel. This includes the audio 
176                         coming in and out of the channel being spied on. If the <literal>chanprefix</literal> parameter is specified,
177                         only channels beginning with this string will be spied upon.</para>
178                         <para>While spying, the following actions may be performed:</para>
179                         <para> - Dialing <literal>#</literal> cycles the volume level.</para>
180                         <para> - Dialing <literal>*</literal> will stop spying and look for another channel to spy on.</para>
181                         <para> - Dialing a series of digits followed by <literal>#</literal> builds a channel name to append
182                         to 'chanprefix'. For example, executing ChanSpy(Agent) and then dialing the digits '1234#' 
183                         while spying will begin spying on the channel 'Agent/1234'. Note that this feature will be overridden if the 'd' option
184                         is used</para>
185                         <note><para>The <replaceable>X</replaceable> option supersedes the three features above in that if a valid
186                         single digit extension exists in the correct context ChanSpy will exit to it.
187                         This also disables choosing a channel based on <literal>chanprefix</literal> and a digit sequence.</para></note>
188                 </description>
189                 <see-also>
190                         <ref type="application">ExtenSpy</ref>
191                 </see-also>
192         </application>
193         <application name="ExtenSpy" language="en_US">
194                 <synopsis>
195                         Listen to a channel, and optionally whisper into it.
196                 </synopsis>
197                 <syntax>
198                         <parameter name="exten" required="true" argsep="@">
199                                 <argument name="exten" required="true">
200                                         <para>Specify extension.</para>
201                                 </argument>
202                                 <argument name="context">
203                                         <para>Optionally specify a context, defaults to <literal>default</literal>.</para>
204                                 </argument>
205                         </parameter>
206                         <parameter name="options">
207                                 <optionlist>
208                                         <option name="b">
209                                                 <para>Only spy on channels involved in a bridged call.</para>
210                                         </option>
211                                         <option name="B">
212                                                 <para>Instead of whispering on a single channel barge in on both
213                                                 channels involved in the call.</para>
214                                         </option>
215                                         <option name="c">
216                                                 <argument name="digit" required="true">
217                                                         <para>Specify a DTMF digit that can be used to spy on the next available channel.</para>
218                                                 </argument>
219                                         </option>
220                                         <option name="d">
221                                                 <para>Override the typical numeric DTMF functionality and instead
222                                                 use DTMF to switch between spy modes.</para>
223                                                 <enumlist>
224                                                         <enum name="4">
225                                                                 <para>spy mode</para>
226                                                         </enum>
227                                                         <enum name="5">
228                                                                 <para>whisper mode</para>
229                                                         </enum>
230                                                         <enum name="6">
231                                                                 <para>barge mode</para>
232                                                         </enum>
233                                                 </enumlist>
234                                         </option>
235                                         <option name="e">
236                                                 <argument name="ext" required="true" />
237                                                 <para>Enable <emphasis>enforced</emphasis> mode, so the spying channel can
238                                                 only monitor extensions whose name is in the <replaceable>ext</replaceable> : delimited 
239                                                 list.</para>
240                                         </option>
241                                         <option name="E">
242                                                 <para>Exit when the spied-on channel hangs up.</para>
243                                         </option>
244                                         <option name="g">
245                                                 <argument name="grp" required="true">
246                                                         <para>Only spy on channels in which one or more of the groups
247                                                         listed in <replaceable>grp</replaceable> matches one or more groups from the
248                                                         <variable>SPYGROUP</variable> variable set on the channel to be spied upon.</para>
249                                                 </argument>
250                                                 <note><para>both <replaceable>grp</replaceable> and <variable>SPYGROUP</variable> can contain 
251                                                 either a single group or a colon-delimited list of groups, such
252                                                 as <literal>sales:support:accounting</literal>.</para></note>
253                                         </option>
254                                         <option name="n" argsep="@">
255                                                 <para>Say the name of the person being spied on if that person has recorded
256                                                 his/her name. If a context is specified, then that voicemail context will
257                                                 be searched when retrieving the name, otherwise the <literal>default</literal> context
258                                                 be used when searching for the name (i.e. if SIP/1000 is the channel being
259                                                 spied on and no mailbox is specified, then <literal>1000</literal> will be used when searching
260                                                 for the name).</para>
261                                                 <argument name="mailbox" />
262                                                 <argument name="context" />
263                                         </option>
264                                         <option name="o">
265                                                 <para>Only listen to audio coming from this channel.</para>
266                                         </option>
267                                         <option name="q">
268                                                 <para>Don't play a beep when beginning to spy on a channel, or speak the
269                                                 selected channel name.</para>
270                                         </option>
271                                         <option name="r">
272                                                 <para>Record the session to the monitor spool directory. An optional base for the filename 
273                                                 may be specified. The default is <literal>chanspy</literal>.</para>
274                                                 <argument name="basename" />
275                                         </option>
276                                         <option name="s">
277                                                 <para>Skip the playback of the channel type (i.e. SIP, IAX, etc) when
278                                                 speaking the selected channel name.</para>
279                                         </option>
280                                         <option name="S">
281                                                 <para>Stop when there are no more extensions left to spy on.</para>
282                                         </option>
283                                         <option name="v">
284                                                 <argument name="value" />
285                                                 <para>Adjust the initial volume in the range from <literal>-4</literal> 
286                                                 to <literal>4</literal>. A negative value refers to a quieter setting.</para>
287                                         </option>
288                                         <option name="w">
289                                                 <para>Enable <literal>whisper</literal> mode, so the spying channel can talk to
290                                                 the spied-on channel.</para>
291                                         </option>
292                                         <option name="W">
293                                                 <para>Enable <literal>private whisper</literal> mode, so the spying channel can
294                                                 talk to the spied-on channel but cannot listen to that channel.</para>
295                                         </option>
296                                         <option name="x">
297                                                 <argument name="digit" required="true">
298                                                         <para>Specify a DTMF digit that can be used to exit the application.</para>
299                                                 </argument>
300                                         </option>
301                                         <option name="X">
302                                                 <para>Allow the user to exit ChanSpy to a valid single digit
303                                                 numeric extension in the current context or the context
304                                                 specified by the <variable>SPY_EXIT_CONTEXT</variable> channel variable. The
305                                                 name of the last channel that was spied on will be stored
306                                                 in the <variable>SPY_CHANNEL</variable> variable.</para>
307                                         </option>
308                                 </optionlist>   
309                         </parameter>
310                 </syntax>
311                 <description>
312                         <para>This application is used to listen to the audio from an Asterisk channel. This includes 
313                         the audio coming in and out of the channel being spied on. Only channels created by outgoing calls for the
314                         specified extension will be selected for spying. If the optional context is not supplied, 
315                         the current channel's context will be used.</para>
316                         <para>While spying, the following actions may be performed:</para>
317                         <para> - Dialing <literal>#</literal> cycles the volume level.</para>
318                         <para> - Dialing <literal>*</literal> will stop spying and look for another channel to spy on.</para>
319                         <note><para>The <replaceable>X</replaceable> option supersedes the three features above in that if a valid
320                         single digit extension exists in the correct context ChanSpy will exit to it.
321                         This also disables choosing a channel based on <literal>chanprefix</literal> and a digit sequence.</para></note>
322                 </description>
323                 <see-also>
324                         <ref type="application">ChanSpy</ref>
325                 </see-also>
326         </application>
327         
328         <application name="DAHDIScan" language="en_US">
329                 <synopsis>
330                         Scan DAHDI channels to monitor calls.
331                 </synopsis>
332                 <syntax>
333                         <parameter name="group">
334                                 <para>Limit scanning to a channel <replaceable>group</replaceable> by setting this option.</para>
335                         </parameter>
336                 </syntax>
337                 <description>
338                         <para>Allows a call center manager to monitor DAHDI channels in a
339                         convenient way.  Use <literal>#</literal> to select the next channel and use <literal>*</literal> to exit.</para>
340                 </description>
341         </application>
342  ***/
343
344 static const char app_chan[] = "ChanSpy";
345
346 static const char app_ext[] = "ExtenSpy";
347
348 static const char app_dahdiscan[] = "DAHDIScan";
349
350 enum {
351         OPTION_QUIET             = (1 << 0),    /* Quiet, no announcement */
352         OPTION_BRIDGED           = (1 << 1),    /* Only look at bridged calls */
353         OPTION_VOLUME            = (1 << 2),    /* Specify initial volume */
354         OPTION_GROUP             = (1 << 3),    /* Only look at channels in group */
355         OPTION_RECORD            = (1 << 4),
356         OPTION_WHISPER           = (1 << 5),
357         OPTION_PRIVATE           = (1 << 6),    /* Private Whisper mode */
358         OPTION_READONLY          = (1 << 7),    /* Don't mix the two channels */
359         OPTION_EXIT              = (1 << 8),    /* Exit to a valid single digit extension */
360         OPTION_ENFORCED          = (1 << 9),    /* Enforced mode */
361         OPTION_NOTECH            = (1 << 10),   /* Skip technology name playback */
362         OPTION_BARGE             = (1 << 11),   /* Barge mode (whisper to both channels) */
363         OPTION_NAME              = (1 << 12),   /* Say the name of the person on whom we will spy */
364         OPTION_DTMF_SWITCH_MODES = (1 << 13),   /* Allow numeric DTMF to switch between chanspy modes */
365         OPTION_DTMF_EXIT         = (1 << 14),   /* Set DTMF to exit, added for DAHDIScan integration */
366         OPTION_DTMF_CYCLE        = (1 << 15),   /* Custom DTMF for cycling next avaliable channel, (default is '*') */
367         OPTION_DAHDI_SCAN        = (1 << 16),   /* Scan groups in DAHDIScan mode */
368         OPTION_STOP              = (1 << 17),
369         OPTION_EXITONHANGUP      = (1 << 18),   /* Hang up when the spied-on channel hangs up. */
370 };
371
372 enum {
373         OPT_ARG_VOLUME = 0,
374         OPT_ARG_GROUP,
375         OPT_ARG_RECORD,
376         OPT_ARG_ENFORCED,
377         OPT_ARG_NAME,
378         OPT_ARG_EXIT,
379         OPT_ARG_CYCLE,
380         OPT_ARG_ARRAY_SIZE,
381 };
382
383 AST_APP_OPTIONS(spy_opts, {
384         AST_APP_OPTION('b', OPTION_BRIDGED),
385         AST_APP_OPTION('B', OPTION_BARGE),
386         AST_APP_OPTION_ARG('c', OPTION_DTMF_CYCLE, OPT_ARG_CYCLE),
387         AST_APP_OPTION('d', OPTION_DTMF_SWITCH_MODES),
388         AST_APP_OPTION_ARG('e', OPTION_ENFORCED, OPT_ARG_ENFORCED),
389         AST_APP_OPTION('E', OPTION_EXITONHANGUP),
390         AST_APP_OPTION_ARG('g', OPTION_GROUP, OPT_ARG_GROUP),
391         AST_APP_OPTION_ARG('n', OPTION_NAME, OPT_ARG_NAME),
392         AST_APP_OPTION('o', OPTION_READONLY),
393         AST_APP_OPTION('q', OPTION_QUIET),
394         AST_APP_OPTION_ARG('r', OPTION_RECORD, OPT_ARG_RECORD),
395         AST_APP_OPTION('s', OPTION_NOTECH),
396         AST_APP_OPTION('S', OPTION_STOP),
397         AST_APP_OPTION_ARG('v', OPTION_VOLUME, OPT_ARG_VOLUME),
398         AST_APP_OPTION('w', OPTION_WHISPER),
399         AST_APP_OPTION('W', OPTION_PRIVATE),
400         AST_APP_OPTION_ARG('x', OPTION_DTMF_EXIT, OPT_ARG_EXIT),
401         AST_APP_OPTION('X', OPTION_EXIT),
402 });
403
404 struct chanspy_translation_helper {
405         /* spy data */
406         struct ast_audiohook spy_audiohook;
407         struct ast_audiohook whisper_audiohook;
408         struct ast_audiohook bridge_whisper_audiohook;
409         int fd;
410         int volfactor;
411         struct ast_flags flags;
412 };
413
414 struct spy_dtmf_options {
415         char exit;
416         char cycle;
417         char volume;
418 };
419
420 static void *spy_alloc(struct ast_channel *chan, void *data)
421 {
422         /* just store the data pointer in the channel structure */
423         return data;
424 }
425
426 static void spy_release(struct ast_channel *chan, void *data)
427 {
428         /* nothing to do */
429 }
430
431 static int spy_generate(struct ast_channel *chan, void *data, int len, int samples)
432 {
433         struct chanspy_translation_helper *csth = data;
434         struct ast_frame *f, *cur;
435         struct ast_format format_slin;
436
437         ast_format_set(&format_slin, AST_FORMAT_SLINEAR, 0);
438
439         ast_audiohook_lock(&csth->spy_audiohook);
440         if (csth->spy_audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
441                 /* Channel is already gone more than likely */
442                 ast_audiohook_unlock(&csth->spy_audiohook);
443                 return -1;
444         }
445
446         if (ast_test_flag(&csth->flags, OPTION_READONLY)) {
447                 /* Option 'o' was set, so don't mix channel audio */
448                 f = ast_audiohook_read_frame(&csth->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_READ, &format_slin);
449         } else {
450                 f = ast_audiohook_read_frame(&csth->spy_audiohook, samples, AST_AUDIOHOOK_DIRECTION_BOTH, &format_slin);
451         }
452
453         ast_audiohook_unlock(&csth->spy_audiohook);
454
455         if (!f)
456                 return 0;
457
458         for (cur = f; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
459                 if (ast_write(chan, cur)) {
460                         ast_frfree(f);
461                         return -1;
462                 }
463
464                 if (csth->fd) {
465                         if (write(csth->fd, cur->data.ptr, cur->datalen) < 0) {
466                                 ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
467                         }
468                 }
469         }
470
471         ast_frfree(f);
472
473         return 0;
474 }
475
476 static struct ast_generator spygen = {
477         .alloc = spy_alloc,
478         .release = spy_release,
479         .generate = spy_generate,
480 };
481
482 static int start_spying(struct ast_autochan *autochan, const char *spychan_name, struct ast_audiohook *audiohook)
483 {
484         int res = 0;
485         struct ast_channel *peer = NULL;
486
487         ast_log(LOG_NOTICE, "Attaching %s to %s\n", spychan_name, ast_channel_name(autochan->chan));
488
489         ast_set_flag(audiohook, AST_AUDIOHOOK_TRIGGER_SYNC | AST_AUDIOHOOK_SMALL_QUEUE);
490         res = ast_audiohook_attach(autochan->chan, audiohook);
491
492         if (!res && ast_test_flag(autochan->chan, AST_FLAG_NBRIDGE) && (peer = ast_bridged_channel(autochan->chan))) {
493                 ast_softhangup(peer, AST_SOFTHANGUP_UNBRIDGE);
494         }
495         return res;
496 }
497
498 static void change_spy_mode(const char digit, struct ast_flags *flags)
499 {
500         if (digit == '4') {
501                 ast_clear_flag(flags, OPTION_WHISPER);
502                 ast_clear_flag(flags, OPTION_BARGE);
503         } else if (digit == '5') {
504                 ast_clear_flag(flags, OPTION_BARGE);
505                 ast_set_flag(flags, OPTION_WHISPER);
506         } else if (digit == '6') {
507                 ast_clear_flag(flags, OPTION_WHISPER);
508                 ast_set_flag(flags, OPTION_BARGE);
509         }
510 }
511
512 static int channel_spy(struct ast_channel *chan, struct ast_autochan *spyee_autochan,
513         int *volfactor, int fd, struct spy_dtmf_options *user_options, struct ast_flags *flags,
514         char *exitcontext)
515 {
516         struct chanspy_translation_helper csth;
517         int running = 0, res, x = 0;
518         char inp[24] = {0};
519         char *name;
520         struct ast_frame *f;
521         struct ast_silence_generator *silgen = NULL;
522         struct ast_autochan *spyee_bridge_autochan = NULL;
523         const char *spyer_name;
524         struct ast_channel *chans[] = { chan, spyee_autochan->chan };
525
526         ast_channel_lock(chan);
527         spyer_name = ast_strdupa(ast_channel_name(chan));
528         ast_channel_unlock(chan);
529
530         /* We now hold the channel lock on spyee */
531
532         if (ast_check_hangup(chan) || ast_check_hangup(spyee_autochan->chan)) {
533                 return 0;
534         }
535
536         ast_channel_lock(spyee_autochan->chan);
537         name = ast_strdupa(ast_channel_name(spyee_autochan->chan));
538         ast_channel_unlock(spyee_autochan->chan);
539
540         ast_verb(2, "Spying on channel %s\n", name);
541         ast_manager_event_multichan(EVENT_FLAG_CALL, "ChanSpyStart", 2, chans,
542                         "SpyerChannel: %s\r\n"
543                         "SpyeeChannel: %s\r\n",
544                         spyer_name, name);
545
546         memset(&csth, 0, sizeof(csth));
547         ast_copy_flags(&csth.flags, flags, AST_FLAGS_ALL);
548
549         /* This is the audiohook which gives us the audio off the channel we are
550            spying on.
551         */
552         ast_audiohook_init(&csth.spy_audiohook, AST_AUDIOHOOK_TYPE_SPY, "ChanSpy", 0);
553
554         if (start_spying(spyee_autochan, spyer_name, &csth.spy_audiohook)) {
555                 ast_audiohook_destroy(&csth.spy_audiohook);
556                 return 0;
557         }
558
559         if (ast_test_flag(flags, OPTION_WHISPER | OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
560                 /* This audiohook will let us inject audio from our channel into the
561                    channel we are currently spying on.
562                 */
563                 ast_audiohook_init(&csth.whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "ChanSpy", 0);
564
565                 if (start_spying(spyee_autochan, spyer_name, &csth.whisper_audiohook)) {
566                         ast_log(LOG_WARNING, "Unable to attach whisper audiohook to spyee %s. Whisper mode disabled!\n", name);
567                 }
568         }
569
570         if (ast_test_flag(flags, OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
571                 /* And this hook lets us inject audio into the channel that the spied on
572                    channel is currently bridged with.
573                 */
574                 ast_audiohook_init(&csth.bridge_whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "Chanspy", 0);
575
576                 if ((spyee_bridge_autochan = ast_autochan_setup(ast_bridged_channel(spyee_autochan->chan)))) {
577                         ast_channel_lock(spyee_bridge_autochan->chan);
578                         if (start_spying(spyee_bridge_autochan, spyer_name, &csth.bridge_whisper_audiohook)) {
579                                 ast_log(LOG_WARNING, "Unable to attach barge audiohook on spyee %s. Barge mode disabled!\n", name);
580                         }
581                         ast_channel_unlock(spyee_bridge_autochan->chan);
582                 }
583         }
584
585         ast_channel_lock(chan);
586         ast_set_flag(chan, AST_FLAG_END_DTMF_ONLY);
587         ast_channel_unlock(chan);
588
589         csth.volfactor = *volfactor;
590
591         if (csth.volfactor) {
592                 csth.spy_audiohook.options.read_volume = csth.volfactor;
593                 csth.spy_audiohook.options.write_volume = csth.volfactor;
594         }
595
596         csth.fd = fd;
597
598         if (ast_test_flag(flags, OPTION_PRIVATE))
599                 silgen = ast_channel_start_silence_generator(chan);
600         else
601                 ast_activate_generator(chan, &spygen, &csth);
602
603         /* We can no longer rely on 'spyee' being an actual channel;
604            it can be hung up and freed out from under us. However, the
605            channel destructor will put NULL into our csth.spy.chan
606            field when that happens, so that is our signal that the spyee
607            channel has gone away.
608         */
609
610         /* Note: it is very important that the ast_waitfor() be the first
611            condition in this expression, so that if we wait for some period
612            of time before receiving a frame from our spying channel, we check
613            for hangup on the spied-on channel _after_ knowing that a frame
614            has arrived, since the spied-on channel could have gone away while
615            we were waiting
616         */
617         while (ast_waitfor(chan, -1) > -1 && csth.spy_audiohook.status == AST_AUDIOHOOK_STATUS_RUNNING) {
618                 if (!(f = ast_read(chan)) || ast_check_hangup(chan)) {
619                         running = -1;
620                         break;
621                 }
622
623                 if (ast_test_flag(flags, OPTION_BARGE) && f->frametype == AST_FRAME_VOICE) {
624                         ast_audiohook_lock(&csth.whisper_audiohook);
625                         ast_audiohook_lock(&csth.bridge_whisper_audiohook);
626                         ast_audiohook_write_frame(&csth.whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
627                         ast_audiohook_write_frame(&csth.bridge_whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
628                         ast_audiohook_unlock(&csth.whisper_audiohook);
629                         ast_audiohook_unlock(&csth.bridge_whisper_audiohook);
630                         ast_frfree(f);
631                         continue;
632                 } else if (ast_test_flag(flags, OPTION_WHISPER) && f->frametype == AST_FRAME_VOICE) {
633                         ast_audiohook_lock(&csth.whisper_audiohook);
634                         ast_audiohook_write_frame(&csth.whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
635                         ast_audiohook_unlock(&csth.whisper_audiohook);
636                         ast_frfree(f);
637                         continue;
638                 }
639                 
640                 res = (f->frametype == AST_FRAME_DTMF) ? f->subclass.integer : 0;
641                 ast_frfree(f);
642                 if (!res)
643                         continue;
644
645                 if (x == sizeof(inp))
646                         x = 0;
647
648                 if (res < 0) {
649                         running = -1;
650                         break;
651                 }
652
653                 if (ast_test_flag(flags, OPTION_EXIT)) {
654                         char tmp[2];
655                         tmp[0] = res;
656                         tmp[1] = '\0';
657                         if (!ast_goto_if_exists(chan, exitcontext, tmp, 1)) {
658                                 ast_debug(1, "Got DTMF %c, goto context %s\n", tmp[0], exitcontext);
659                                 pbx_builtin_setvar_helper(chan, "SPY_CHANNEL", name);
660                                 running = -2;
661                                 break;
662                         } else {
663                                 ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
664                         }
665                 } else if (res >= '0' && res <= '9') {
666                         if (ast_test_flag(flags, OPTION_DTMF_SWITCH_MODES)) {
667                                 change_spy_mode(res, flags);
668                         } else {
669                                 inp[x++] = res;
670                         }
671                 }
672
673                 if (res == user_options->cycle) {
674                         running = 0;
675                         break;
676                 } else if (res == user_options->exit) {
677                         running = -2;
678                         break;
679                 } else if (res == user_options->volume) {
680                         if (!ast_strlen_zero(inp)) {
681                                 running = atoi(inp);
682                                 break;
683                         }
684
685                         (*volfactor)++;
686                         if (*volfactor > 4)
687                                 *volfactor = -4;
688                         ast_verb(3, "Setting spy volume on %s to %d\n", ast_channel_name(chan), *volfactor);
689
690                         csth.volfactor = *volfactor;
691                         csth.spy_audiohook.options.read_volume = csth.volfactor;
692                         csth.spy_audiohook.options.write_volume = csth.volfactor;
693                 }
694         }
695
696         if (ast_test_flag(flags, OPTION_PRIVATE))
697                 ast_channel_stop_silence_generator(chan, silgen);
698         else
699                 ast_deactivate_generator(chan);
700
701         ast_channel_lock(chan);
702         ast_clear_flag(chan, AST_FLAG_END_DTMF_ONLY);
703         ast_channel_unlock(chan);
704
705         if (ast_test_flag(flags, OPTION_WHISPER | OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
706                 ast_audiohook_lock(&csth.whisper_audiohook);
707                 ast_audiohook_detach(&csth.whisper_audiohook);
708                 ast_audiohook_unlock(&csth.whisper_audiohook);
709                 ast_audiohook_destroy(&csth.whisper_audiohook);
710         }
711
712         if (ast_test_flag(flags, OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
713                 ast_audiohook_lock(&csth.bridge_whisper_audiohook);
714                 ast_audiohook_detach(&csth.bridge_whisper_audiohook);
715                 ast_audiohook_unlock(&csth.bridge_whisper_audiohook);
716                 ast_audiohook_destroy(&csth.bridge_whisper_audiohook);
717         }
718
719         ast_audiohook_lock(&csth.spy_audiohook);
720         ast_audiohook_detach(&csth.spy_audiohook);
721         ast_audiohook_unlock(&csth.spy_audiohook);
722         ast_audiohook_destroy(&csth.spy_audiohook);
723
724         if (spyee_bridge_autochan) {
725                 ast_autochan_destroy(spyee_bridge_autochan);
726         }
727
728         ast_verb(2, "Done Spying on channel %s\n", name);
729         ast_manager_event(chan, EVENT_FLAG_CALL, "ChanSpyStop", "SpyeeChannel: %s\r\n", name);
730
731         return running;
732 }
733
734 static struct ast_autochan *next_channel(struct ast_channel_iterator *iter,
735                 struct ast_autochan *autochan, struct ast_channel *chan)
736 {
737         struct ast_channel *next;
738         struct ast_autochan *autochan_store;
739         const size_t pseudo_len = strlen("DAHDI/pseudo");
740
741         if (!iter) {
742                 return NULL;
743         }
744
745 redo:
746         if (!(next = ast_channel_iterator_next(iter))) {
747                 return NULL;
748         }
749
750         if (!strncmp(ast_channel_name(next), "DAHDI/pseudo", pseudo_len)) {
751                 ast_channel_unref(next);
752                 goto redo;
753         } else if (next == chan) {
754                 ast_channel_unref(next);
755                 goto redo;
756         }
757
758         autochan_store = ast_autochan_setup(next);
759         ast_channel_unref(next);
760
761         return autochan_store;
762 }
763
764 static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
765         int volfactor, const int fd, struct spy_dtmf_options *user_options,
766         const char *mygroup, const char *myenforced, const char *spec, const char *exten,
767         const char *context, const char *mailbox, const char *name_context)
768 {
769         char nameprefix[AST_NAME_STRLEN];
770         char peer_name[AST_NAME_STRLEN + 5];
771         char exitcontext[AST_MAX_CONTEXT] = "";
772         signed char zero_volume = 0;
773         int waitms;
774         int res;
775         char *ptr;
776         int num_spyed_upon = 1;
777         struct ast_channel_iterator *iter = NULL;
778
779         if (ast_test_flag(flags, OPTION_EXIT)) {
780                 const char *c;
781                 ast_channel_lock(chan);
782                 if ((c = pbx_builtin_getvar_helper(chan, "SPY_EXIT_CONTEXT"))) {
783                         ast_copy_string(exitcontext, c, sizeof(exitcontext));
784                 } else if (!ast_strlen_zero(ast_channel_macrocontext(chan))) {
785                         ast_copy_string(exitcontext, ast_channel_macrocontext(chan), sizeof(exitcontext));
786                 } else {
787                         ast_copy_string(exitcontext, ast_channel_context(chan), sizeof(exitcontext));
788                 }
789                 ast_channel_unlock(chan);
790         }
791
792         if (ast_channel_state(chan) != AST_STATE_UP)
793                 ast_answer(chan);
794
795         ast_set_flag(chan, AST_FLAG_SPYING); /* so nobody can spy on us while we are spying */
796
797         waitms = 100;
798
799         for (;;) {
800                 struct ast_autochan *autochan = NULL, *next_autochan = NULL;
801                 struct ast_channel *prev = NULL;
802
803                 if (!ast_test_flag(flags, OPTION_QUIET) && num_spyed_upon) {
804                         res = ast_streamfile(chan, "beep", ast_channel_language(chan));
805                         if (!res)
806                                 res = ast_waitstream(chan, "");
807                         else if (res < 0) {
808                                 ast_clear_flag(chan, AST_FLAG_SPYING);
809                                 break;
810                         }
811                         if (!ast_strlen_zero(exitcontext)) {
812                                 char tmp[2];
813                                 tmp[0] = res;
814                                 tmp[1] = '\0';
815                                 if (!ast_goto_if_exists(chan, exitcontext, tmp, 1))
816                                         goto exit;
817                                 else
818                                         ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
819                         }
820                 }
821
822                 /* Set up the iterator we'll be using during this call */
823                 if (!ast_strlen_zero(spec)) {
824                         iter = ast_channel_iterator_by_name_new(spec, strlen(spec));
825                 } else if (!ast_strlen_zero(exten)) {
826                         iter = ast_channel_iterator_by_exten_new(exten, context);
827                 } else {
828                         iter = ast_channel_iterator_all_new();
829                 }
830
831                 if (!iter) {
832                         res = -1;
833                         goto exit;
834                 }
835
836                 res = ast_waitfordigit(chan, waitms);
837                 if (res < 0) {
838                         iter = ast_channel_iterator_destroy(iter);
839                         ast_clear_flag(chan, AST_FLAG_SPYING);
840                         break;
841                 }
842                 if (!ast_strlen_zero(exitcontext)) {
843                         char tmp[2];
844                         tmp[0] = res;
845                         tmp[1] = '\0';
846                         if (!ast_goto_if_exists(chan, exitcontext, tmp, 1)) {
847                                 iter = ast_channel_iterator_destroy(iter);
848                                 goto exit;
849                         } else {
850                                 ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
851                         }
852                 }
853
854                 /* reset for the next loop around, unless overridden later */
855                 waitms = 100;
856                 num_spyed_upon = 0;
857
858                 for (autochan = next_channel(iter, autochan, chan);
859                      autochan;
860                          prev = autochan->chan, ast_autochan_destroy(autochan),
861                      autochan = next_autochan ? next_autochan : 
862                                 next_channel(iter, autochan, chan), next_autochan = NULL) {
863                         int igrp = !mygroup;
864                         int ienf = !myenforced;
865                         char *s;
866
867                         if (autochan->chan == prev) {
868                                 ast_autochan_destroy(autochan);
869                                 break;
870                         }
871
872                         if (ast_check_hangup(chan)) {
873                                 ast_autochan_destroy(autochan);
874                                 break;
875                         }
876
877                         if (ast_test_flag(flags, OPTION_BRIDGED) && !ast_bridged_channel(autochan->chan)) {
878                                 continue;
879                         }
880
881                         if (ast_check_hangup(autochan->chan) || ast_test_flag(autochan->chan, AST_FLAG_SPYING)) {
882                                 continue;
883                         }
884
885                         if (mygroup) {
886                                 int num_groups = 0;
887                                 int num_mygroups = 0;
888                                 char dup_group[512];
889                                 char dup_mygroup[512];
890                                 char *groups[NUM_SPYGROUPS];
891                                 char *mygroups[NUM_SPYGROUPS];
892                                 const char *group = NULL;
893                                 int x;
894                                 int y;
895                                 ast_copy_string(dup_mygroup, mygroup, sizeof(dup_mygroup));
896                                 num_mygroups = ast_app_separate_args(dup_mygroup, ':', mygroups,
897                                         ARRAY_LEN(mygroups));
898
899                                 /* Before dahdi scan was part of chanspy, it would use the "GROUP" variable 
900                                  * rather than "SPYGROUP", this check is done to preserve expected behavior */
901                                 if (ast_test_flag(flags, OPTION_DAHDI_SCAN)) {
902                                         group = pbx_builtin_getvar_helper(autochan->chan, "GROUP");
903                                 } else {
904                                         group = pbx_builtin_getvar_helper(autochan->chan, "SPYGROUP");
905                                 }
906
907                                 if (!ast_strlen_zero(group)) {
908                                         ast_copy_string(dup_group, group, sizeof(dup_group));
909                                         num_groups = ast_app_separate_args(dup_group, ':', groups,
910                                                 ARRAY_LEN(groups));
911                                 }
912
913                                 for (y = 0; y < num_mygroups; y++) {
914                                         for (x = 0; x < num_groups; x++) {
915                                                 if (!strcmp(mygroups[y], groups[x])) {
916                                                         igrp = 1;
917                                                         break;
918                                                 }
919                                         }
920                                 }
921                         }
922
923                         if (!igrp) {
924                                 continue;
925                         }
926                         if (myenforced) {
927                                 char ext[AST_CHANNEL_NAME + 3];
928                                 char buffer[512];
929                                 char *end;
930
931                                 snprintf(buffer, sizeof(buffer) - 1, ":%s:", myenforced);
932
933                                 ast_copy_string(ext + 1, ast_channel_name(autochan->chan), sizeof(ext) - 1);
934                                 if ((end = strchr(ext, '-'))) {
935                                         *end++ = ':';
936                                         *end = '\0';
937                                 }
938
939                                 ext[0] = ':';
940
941                                 if (strcasestr(buffer, ext)) {
942                                         ienf = 1;
943                                 }
944                         }
945
946                         if (!ienf) {
947                                 continue;
948                         }
949
950                         strcpy(peer_name, "spy-");
951                         strncat(peer_name, ast_channel_name(autochan->chan), AST_NAME_STRLEN - 4 - 1);
952                         ptr = strchr(peer_name, '/');
953                         *ptr++ = '\0';
954                         ptr = strsep(&ptr, "-");
955
956                         for (s = peer_name; s < ptr; s++)
957                                 *s = tolower(*s);
958
959                         if (!ast_test_flag(flags, OPTION_QUIET)) {
960                                 if (ast_test_flag(flags, OPTION_NAME)) {
961                                         const char *local_context = S_OR(name_context, "default");
962                                         const char *local_mailbox = S_OR(mailbox, ptr);
963                                         res = ast_app_sayname(chan, local_mailbox, local_context);
964                                 }
965                                 if (!ast_test_flag(flags, OPTION_NAME) || res < 0) {
966                                         int num;
967                                         if (!ast_test_flag(flags, OPTION_NOTECH)) {
968                                                 if (ast_fileexists(peer_name, NULL, NULL) > 0) {
969                                                         res = ast_streamfile(chan, peer_name, ast_channel_language(chan));
970                                                         if (!res) {
971                                                                 res = ast_waitstream(chan, "");
972                                                         }
973                                                         if (res) {
974                                                                 ast_autochan_destroy(autochan);
975                                                                 break;
976                                                         }
977                                                 } else {
978                                                         res = ast_say_character_str(chan, peer_name, "", ast_channel_language(chan));
979                                                 }
980                                         }
981                                         if ((num = atoi(ptr))) {
982                                                 ast_say_digits(chan, num, "", ast_channel_language(chan));
983                                         }
984                                 }
985                         }
986
987                         res = channel_spy(chan, autochan, &volfactor, fd, user_options, flags, exitcontext);
988                         num_spyed_upon++;
989
990                         if (res == -1) {
991                                 ast_autochan_destroy(autochan);
992                                 iter = ast_channel_iterator_destroy(iter);
993                                 goto exit;
994                         } else if (res == -2) {
995                                 res = 0;
996                                 ast_autochan_destroy(autochan);
997                                 iter = ast_channel_iterator_destroy(iter);
998                                 goto exit;
999                         } else if (res > 1 && spec) {
1000                                 struct ast_channel *next;
1001
1002                                 snprintf(nameprefix, AST_NAME_STRLEN, "%s/%d", spec, res);
1003
1004                                 if ((next = ast_channel_get_by_name_prefix(nameprefix, strlen(nameprefix)))) {
1005                                         next_autochan = ast_autochan_setup(next);
1006                                         next = ast_channel_unref(next);
1007                                 } else {
1008                                         /* stay on this channel, if it is still valid */
1009                                         if (!ast_check_hangup(autochan->chan)) {
1010                                                 next_autochan = ast_autochan_setup(autochan->chan);
1011                                         } else {
1012                                                 /* the channel is gone */
1013                                                 next_autochan = NULL;
1014                                         }
1015                                 }
1016                         } else if (res == 0 && ast_test_flag(flags, OPTION_EXITONHANGUP)) {
1017                                 iter = ast_channel_iterator_destroy(iter);
1018                                 goto exit;
1019                         }
1020                 }
1021
1022                 iter = ast_channel_iterator_destroy(iter);
1023
1024                 if (res == -1 || ast_check_hangup(chan))
1025                         break;
1026                 if (ast_test_flag(flags, OPTION_STOP) && !next_autochan) {
1027                         break;
1028                 }
1029         }
1030 exit:
1031
1032         ast_clear_flag(chan, AST_FLAG_SPYING);
1033
1034         ast_channel_setoption(chan, AST_OPTION_TXGAIN, &zero_volume, sizeof(zero_volume), 0);
1035
1036         return res;
1037 }
1038
1039 static int chanspy_exec(struct ast_channel *chan, const char *data)
1040 {
1041         char *myenforced = NULL;
1042         char *mygroup = NULL;
1043         char *recbase = NULL;
1044         int fd = 0;
1045         struct ast_flags flags;
1046         struct spy_dtmf_options user_options = {
1047                 .cycle = '*',
1048                 .volume = '#',
1049                 .exit = '\0',
1050         };
1051         struct ast_format oldwf;
1052         int volfactor = 0;
1053         int res;
1054         char *mailbox = NULL;
1055         char *name_context = NULL;
1056         AST_DECLARE_APP_ARGS(args,
1057                 AST_APP_ARG(spec);
1058                 AST_APP_ARG(options);
1059         );
1060         char *opts[OPT_ARG_ARRAY_SIZE];
1061         char *parse = ast_strdupa(data);
1062
1063         AST_STANDARD_APP_ARGS(args, parse);
1064         ast_format_clear(&oldwf);
1065
1066         if (args.spec && !strcmp(args.spec, "all"))
1067                 args.spec = NULL;
1068
1069         if (args.options) {
1070                 char tmp;
1071                 ast_app_parse_options(spy_opts, &flags, opts, args.options);
1072                 if (ast_test_flag(&flags, OPTION_GROUP))
1073                         mygroup = opts[OPT_ARG_GROUP];
1074
1075                 if (ast_test_flag(&flags, OPTION_RECORD) &&
1076                         !(recbase = opts[OPT_ARG_RECORD]))
1077                         recbase = "chanspy";
1078
1079                 if (ast_test_flag(&flags, OPTION_DTMF_EXIT) && opts[OPT_ARG_EXIT]) {
1080                         tmp = opts[OPT_ARG_EXIT][0];
1081                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1082                                 user_options.exit = tmp;
1083                         } else {
1084                                 ast_log(LOG_NOTICE, "Argument for option 'x' must be a valid DTMF digit.");
1085                         }
1086                 }
1087
1088                 if (ast_test_flag(&flags, OPTION_DTMF_CYCLE) && opts[OPT_ARG_CYCLE]) {
1089                         tmp = opts[OPT_ARG_CYCLE][0];
1090                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1091                                 user_options.cycle = tmp;
1092                         } else {
1093                                 ast_log(LOG_NOTICE, "Argument for option 'c' must be a valid DTMF digit.");
1094                         }
1095                 }
1096
1097                 if (ast_test_flag(&flags, OPTION_VOLUME) && opts[OPT_ARG_VOLUME]) {
1098                         int vol;
1099
1100                         if ((sscanf(opts[OPT_ARG_VOLUME], "%30d", &vol) != 1) || (vol > 4) || (vol < -4))
1101                                 ast_log(LOG_NOTICE, "Volume factor must be a number between -4 and 4\n");
1102                         else
1103                                 volfactor = vol;
1104                 }
1105
1106                 if (ast_test_flag(&flags, OPTION_PRIVATE))
1107                         ast_set_flag(&flags, OPTION_WHISPER);
1108
1109                 if (ast_test_flag(&flags, OPTION_ENFORCED))
1110                         myenforced = opts[OPT_ARG_ENFORCED];
1111
1112                 if (ast_test_flag(&flags, OPTION_NAME)) {
1113                         if (!ast_strlen_zero(opts[OPT_ARG_NAME])) {
1114                                 char *delimiter;
1115                                 if ((delimiter = strchr(opts[OPT_ARG_NAME], '@'))) {
1116                                         mailbox = opts[OPT_ARG_NAME];
1117                                         *delimiter++ = '\0';
1118                                         name_context = delimiter;
1119                                 } else {
1120                                         mailbox = opts[OPT_ARG_NAME];
1121                                 }
1122                         }
1123                 }
1124         } else {
1125                 ast_clear_flag(&flags, AST_FLAGS_ALL);
1126         }
1127
1128         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1129         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1130                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1131                 return -1;
1132         }
1133
1134         if (recbase) {
1135                 char filename[PATH_MAX];
1136
1137                 snprintf(filename, sizeof(filename), "%s/%s.%d.raw", ast_config_AST_MONITOR_DIR, recbase, (int) time(NULL));
1138                 if ((fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, AST_FILE_MODE)) <= 0) {
1139                         ast_log(LOG_WARNING, "Cannot open '%s' for recording\n", filename);
1140                         fd = 0;
1141                 }
1142         }
1143
1144         res = common_exec(chan, &flags, volfactor, fd, &user_options, mygroup, myenforced, args.spec, NULL, NULL, mailbox, name_context);
1145
1146         if (fd)
1147                 close(fd);
1148
1149         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1150                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1151
1152         if (ast_test_flag(&flags, OPTION_EXITONHANGUP)) {
1153                 ast_verb(3, "Stopped spying due to the spied-on channel hanging up.\n");
1154         }
1155
1156         return res;
1157 }
1158
1159 static int extenspy_exec(struct ast_channel *chan, const char *data)
1160 {
1161         char *ptr, *exten = NULL;
1162         char *mygroup = NULL;
1163         char *recbase = NULL;
1164         int fd = 0;
1165         struct ast_flags flags;
1166         struct spy_dtmf_options user_options = {
1167                 .cycle = '*',
1168                 .volume = '#',
1169                 .exit = '\0',
1170         };
1171         struct ast_format oldwf;
1172         int volfactor = 0;
1173         int res;
1174         char *mailbox = NULL;
1175         char *name_context = NULL;
1176         AST_DECLARE_APP_ARGS(args,
1177                 AST_APP_ARG(context);
1178                 AST_APP_ARG(options);
1179         );
1180         char *parse = ast_strdupa(data);
1181
1182         AST_STANDARD_APP_ARGS(args, parse);
1183         ast_format_clear(&oldwf);
1184
1185         if (!ast_strlen_zero(args.context) && (ptr = strchr(args.context, '@'))) {
1186                 exten = args.context;
1187                 *ptr++ = '\0';
1188                 args.context = ptr;
1189         }
1190         if (ast_strlen_zero(args.context))
1191                 args.context = ast_strdupa(ast_channel_context(chan));
1192
1193         if (args.options) {
1194                 char *opts[OPT_ARG_ARRAY_SIZE];
1195                 char tmp;
1196
1197                 ast_app_parse_options(spy_opts, &flags, opts, args.options);
1198                 if (ast_test_flag(&flags, OPTION_GROUP))
1199                         mygroup = opts[OPT_ARG_GROUP];
1200
1201                 if (ast_test_flag(&flags, OPTION_RECORD) &&
1202                         !(recbase = opts[OPT_ARG_RECORD]))
1203                         recbase = "chanspy";
1204
1205                 if (ast_test_flag(&flags, OPTION_DTMF_EXIT) && opts[OPT_ARG_EXIT]) {
1206                         tmp = opts[OPT_ARG_EXIT][0];
1207                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1208                                 user_options.exit = tmp;
1209                         } else {
1210                                 ast_log(LOG_NOTICE, "Argument for option 'x' must be a valid DTMF digit.");
1211                         }
1212                 }
1213
1214                 if (ast_test_flag(&flags, OPTION_DTMF_CYCLE) && opts[OPT_ARG_CYCLE]) {
1215                         tmp = opts[OPT_ARG_CYCLE][0];
1216                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1217                                 user_options.cycle = tmp;
1218                         } else {
1219                                 ast_log(LOG_NOTICE, "Argument for option 'c' must be a valid DTMF digit.");
1220                         }
1221                 }
1222
1223                 if (ast_test_flag(&flags, OPTION_VOLUME) && opts[OPT_ARG_VOLUME]) {
1224                         int vol;
1225
1226                         if ((sscanf(opts[OPT_ARG_VOLUME], "%30d", &vol) != 1) || (vol > 4) || (vol < -4))
1227                                 ast_log(LOG_NOTICE, "Volume factor must be a number between -4 and 4\n");
1228                         else
1229                                 volfactor = vol;
1230                 }
1231
1232                 if (ast_test_flag(&flags, OPTION_PRIVATE))
1233                         ast_set_flag(&flags, OPTION_WHISPER);
1234
1235                 if (ast_test_flag(&flags, OPTION_NAME)) {
1236                         if (!ast_strlen_zero(opts[OPT_ARG_NAME])) {
1237                                 char *delimiter;
1238                                 if ((delimiter = strchr(opts[OPT_ARG_NAME], '@'))) {
1239                                         mailbox = opts[OPT_ARG_NAME];
1240                                         *delimiter++ = '\0';
1241                                         name_context = delimiter;
1242                                 } else {
1243                                         mailbox = opts[OPT_ARG_NAME];
1244                                 }
1245                         }
1246                 }
1247
1248         } else {
1249                 ast_clear_flag(&flags, AST_FLAGS_ALL);
1250         }
1251
1252         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1253         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1254                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1255                 return -1;
1256         }
1257
1258         if (recbase) {
1259                 char filename[PATH_MAX];
1260
1261                 snprintf(filename, sizeof(filename), "%s/%s.%d.raw", ast_config_AST_MONITOR_DIR, recbase, (int) time(NULL));
1262                 if ((fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, AST_FILE_MODE)) <= 0) {
1263                         ast_log(LOG_WARNING, "Cannot open '%s' for recording\n", filename);
1264                         fd = 0;
1265                 }
1266         }
1267
1268
1269         res = common_exec(chan, &flags, volfactor, fd, &user_options, mygroup, NULL, NULL, exten, args.context, mailbox, name_context);
1270
1271         if (fd)
1272                 close(fd);
1273
1274         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1275                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1276
1277         return res;
1278 }
1279
1280 static int dahdiscan_exec(struct ast_channel *chan, const char *data)
1281 {
1282         const char *spec = "DAHDI";
1283         struct ast_flags flags;
1284         struct spy_dtmf_options user_options = {
1285                 .cycle = '#',
1286                 .volume = '\0',
1287                 .exit = '*',
1288         };
1289         struct ast_format oldwf;
1290         int res;
1291         char *mygroup = NULL;
1292
1293         ast_clear_flag(&flags, AST_FLAGS_ALL);
1294         ast_format_clear(&oldwf);
1295         if (!ast_strlen_zero(data)) {
1296                 mygroup = ast_strdupa(data);
1297         }
1298         ast_set_flag(&flags, OPTION_DTMF_EXIT);
1299         ast_set_flag(&flags, OPTION_DTMF_CYCLE);
1300         ast_set_flag(&flags, OPTION_DAHDI_SCAN);
1301
1302         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1303         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1304                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1305                 return -1;
1306         }
1307
1308         res = common_exec(chan, &flags, 0, 0, &user_options, mygroup, NULL, spec, NULL, NULL, NULL, NULL);
1309
1310         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1311                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1312
1313         return res;
1314 }
1315
1316 static int unload_module(void)
1317 {
1318         int res = 0;
1319
1320         res |= ast_unregister_application(app_chan);
1321         res |= ast_unregister_application(app_ext);
1322         res |= ast_unregister_application(app_dahdiscan);
1323
1324         return res;
1325 }
1326
1327 static int load_module(void)
1328 {
1329         int res = 0;
1330
1331         res |= ast_register_application_xml(app_chan, chanspy_exec);
1332         res |= ast_register_application_xml(app_ext, extenspy_exec);
1333         res |= ast_register_application_xml(app_dahdiscan, dahdiscan_exec);
1334
1335         return res;
1336 }
1337
1338 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Listen to the audio of an active channel");