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(ast_channel_flags(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                         ast_test_flag(ast_channel_flags(spyee_autochan->chan), AST_FLAG_ZOMBIE)) {
 534                 return 0;
 535         }
 536
 537         ast_channel_lock(spyee_autochan->chan);
 538         name = ast_strdupa(ast_channel_name(spyee_autochan->chan));
 539         ast_channel_unlock(spyee_autochan->chan);
 540
 541         ast_verb(2, "Spying on channel %s\n", name);
 542         ast_manager_event_multichan(EVENT_FLAG_CALL, "ChanSpyStart", 2, chans,
 543                         "SpyerChannel: %s\r\n"
 544                         "SpyeeChannel: %s\r\n",
 545                         spyer_name, name);
 546
 547         memset(&csth, 0, sizeof(csth));
 548         ast_copy_flags(&csth.flags, flags, AST_FLAGS_ALL);
 549
 550         /* This is the audiohook which gives us the audio off the channel we are
 551            spying on.
 552         */
 553         ast_audiohook_init(&csth.spy_audiohook, AST_AUDIOHOOK_TYPE_SPY, "ChanSpy", 0);
 554
 555         if (start_spying(spyee_autochan, spyer_name, &csth.spy_audiohook)) {
 556                 ast_audiohook_destroy(&csth.spy_audiohook);
 557                 return 0;
 558         }
 559
 560         if (ast_test_flag(flags, OPTION_WHISPER | OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
 561                 /* This audiohook will let us inject audio from our channel into the
 562                    channel we are currently spying on.
 563                 */
 564                 ast_audiohook_init(&csth.whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "ChanSpy", 0);
 565
 566                 if (start_spying(spyee_autochan, spyer_name, &csth.whisper_audiohook)) {
 567                         ast_log(LOG_WARNING, "Unable to attach whisper audiohook to spyee %s. Whisper mode disabled!\n", name);
 568                 }
 569         }
 570
 571         if (ast_test_flag(flags, OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
 572                 /* And this hook lets us inject audio into the channel that the spied on
 573                    channel is currently bridged with.
 574                 */
 575                 ast_audiohook_init(&csth.bridge_whisper_audiohook, AST_AUDIOHOOK_TYPE_WHISPER, "Chanspy", 0);
 576
 577                 if ((spyee_bridge_autochan = ast_autochan_setup(ast_bridged_channel(spyee_autochan->chan)))) {
 578                         ast_channel_lock(spyee_bridge_autochan->chan);
 579                         if (start_spying(spyee_bridge_autochan, spyer_name, &csth.bridge_whisper_audiohook)) {
 580                                 ast_log(LOG_WARNING, "Unable to attach barge audiohook on spyee %s. Barge mode disabled!\n", name);
 581                         }
 582                         ast_channel_unlock(spyee_bridge_autochan->chan);
 583                 }
 584         }
 585
 586         ast_channel_lock(chan);
 587         ast_set_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
 588         ast_channel_unlock(chan);
 589
 590         csth.volfactor = *volfactor;
 591
 592         if (csth.volfactor) {
 593                 csth.spy_audiohook.options.read_volume = csth.volfactor;
 594                 csth.spy_audiohook.options.write_volume = csth.volfactor;
 595         }
 596
 597         csth.fd = fd;
 598
 599         if (ast_test_flag(flags, OPTION_PRIVATE))
 600                 silgen = ast_channel_start_silence_generator(chan);
 601         else
 602                 ast_activate_generator(chan, &spygen, &csth);
 603
 604         /* We can no longer rely on 'spyee' being an actual channel;
 605            it can be hung up and freed out from under us. However, the
 606            channel destructor will put NULL into our csth.spy.chan
 607            field when that happens, so that is our signal that the spyee
 608            channel has gone away.
 609         */
 610
 611         /* Note: it is very important that the ast_waitfor() be the first
 612            condition in this expression, so that if we wait for some period
 613            of time before receiving a frame from our spying channel, we check
 614            for hangup on the spied-on channel _after_ knowing that a frame
 615            has arrived, since the spied-on channel could have gone away while
 616            we were waiting
 617         */
 618         while (ast_waitfor(chan, -1) > -1 && csth.spy_audiohook.status == AST_AUDIOHOOK_STATUS_RUNNING) {
 619                 if (!(f = ast_read(chan)) || ast_check_hangup(chan)) {
 620                         running = -1;
 621                         break;
 622                 }
 623
 624                 if (ast_test_flag(flags, OPTION_BARGE) && f->frametype == AST_FRAME_VOICE) {
 625                         ast_audiohook_lock(&csth.whisper_audiohook);
 626                         ast_audiohook_lock(&csth.bridge_whisper_audiohook);
 627                         ast_audiohook_write_frame(&csth.whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
 628                         ast_audiohook_write_frame(&csth.bridge_whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
 629                         ast_audiohook_unlock(&csth.whisper_audiohook);
 630                         ast_audiohook_unlock(&csth.bridge_whisper_audiohook);
 631                         ast_frfree(f);
 632                         continue;
 633                 } else if (ast_test_flag(flags, OPTION_WHISPER) && f->frametype == AST_FRAME_VOICE) {
 634                         ast_audiohook_lock(&csth.whisper_audiohook);
 635                         ast_audiohook_write_frame(&csth.whisper_audiohook, AST_AUDIOHOOK_DIRECTION_WRITE, f);
 636                         ast_audiohook_unlock(&csth.whisper_audiohook);
 637                         ast_frfree(f);
 638                         continue;
 639                 }
 640
 641                 res = (f->frametype == AST_FRAME_DTMF) ? f->subclass.integer : 0;
 642                 ast_frfree(f);
 643                 if (!res)
 644                         continue;
 645
 646                 if (x == sizeof(inp))
 647                         x = 0;
 648
 649                 if (res < 0) {
 650                         running = -1;
 651                         break;
 652                 }
 653
 654                 if (ast_test_flag(flags, OPTION_EXIT)) {
 655                         char tmp[2];
 656                         tmp[0] = res;
 657                         tmp[1] = '\0';
 658                         if (!ast_goto_if_exists(chan, exitcontext, tmp, 1)) {
 659                                 ast_debug(1, "Got DTMF %c, goto context %s\n", tmp[0], exitcontext);
 660                                 pbx_builtin_setvar_helper(chan, "SPY_CHANNEL", name);
 661                                 running = -2;
 662                                 break;
 663                         } else {
 664                                 ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
 665                         }
 666                 } else if (res >= '0' && res <= '9') {
 667                         if (ast_test_flag(flags, OPTION_DTMF_SWITCH_MODES)) {
 668                                 change_spy_mode(res, flags);
 669                         } else {
 670                                 inp[x++] = res;
 671                         }
 672                 }
 673
 674                 if (res == user_options->cycle) {
 675                         running = 0;
 676                         break;
 677                 } else if (res == user_options->exit) {
 678                         running = -2;
 679                         break;
 680                 } else if (res == user_options->volume) {
 681                         if (!ast_strlen_zero(inp)) {
 682                                 running = atoi(inp);
 683                                 break;
 684                         }
 685
 686                         (*volfactor)++;
 687                         if (*volfactor > 4)
 688                                 *volfactor = -4;
 689                         ast_verb(3, "Setting spy volume on %s to %d\n", ast_channel_name(chan), *volfactor);
 690
 691                         csth.volfactor = *volfactor;
 692                         csth.spy_audiohook.options.read_volume = csth.volfactor;
 693                         csth.spy_audiohook.options.write_volume = csth.volfactor;
 694                 }
 695         }
 696
 697         if (ast_test_flag(flags, OPTION_PRIVATE))
 698                 ast_channel_stop_silence_generator(chan, silgen);
 699         else
 700                 ast_deactivate_generator(chan);
 701
 702         ast_channel_lock(chan);
 703         ast_clear_flag(ast_channel_flags(chan), AST_FLAG_END_DTMF_ONLY);
 704         ast_channel_unlock(chan);
 705
 706         if (ast_test_flag(flags, OPTION_WHISPER | OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
 707                 ast_audiohook_lock(&csth.whisper_audiohook);
 708                 ast_audiohook_detach(&csth.whisper_audiohook);
 709                 ast_audiohook_unlock(&csth.whisper_audiohook);
 710                 ast_audiohook_destroy(&csth.whisper_audiohook);
 711         }
 712
 713         if (ast_test_flag(flags, OPTION_BARGE | OPTION_DTMF_SWITCH_MODES)) {
 714                 ast_audiohook_lock(&csth.bridge_whisper_audiohook);
 715                 ast_audiohook_detach(&csth.bridge_whisper_audiohook);
 716                 ast_audiohook_unlock(&csth.bridge_whisper_audiohook);
 717                 ast_audiohook_destroy(&csth.bridge_whisper_audiohook);
 718         }
 719
 720         ast_audiohook_lock(&csth.spy_audiohook);
 721         ast_audiohook_detach(&csth.spy_audiohook);
 722         ast_audiohook_unlock(&csth.spy_audiohook);
 723         ast_audiohook_destroy(&csth.spy_audiohook);
 724
 725         if (spyee_bridge_autochan) {
 726                 ast_autochan_destroy(spyee_bridge_autochan);
 727         }
 728
 729         ast_verb(2, "Done Spying on channel %s\n", name);
 730         ast_manager_event(chan, EVENT_FLAG_CALL, "ChanSpyStop", "SpyeeChannel: %s\r\n", name);
 731
 732         return running;
 733 }
 734
 735 static struct ast_autochan *next_channel(struct ast_channel_iterator *iter,
 736                 struct ast_autochan *autochan, struct ast_channel *chan)
 737 {
 738         struct ast_channel *next;
 739         struct ast_autochan *autochan_store;
 740         const size_t pseudo_len = strlen("DAHDI/pseudo");
 741
 742         if (!iter) {
 743                 return NULL;
 744         }
 745
 746         for (; (next = ast_channel_iterator_next(iter)); ast_channel_unref(next)) {
 747                 if (!strncmp(ast_channel_name(next), "DAHDI/pseudo", pseudo_len)
 748                         || next == chan) {
 749                         continue;
 750                 }
 751
 752                 autochan_store = ast_autochan_setup(next);
 753                 ast_channel_unref(next);
 754
 755                 return autochan_store;
 756         }
 757         return NULL;
 758 }
 759
 760 static int common_exec(struct ast_channel *chan, struct ast_flags *flags,
 761         int volfactor, const int fd, struct spy_dtmf_options *user_options,
 762         const char *mygroup, const char *myenforced, const char *spec, const char *exten,
 763         const char *context, const char *mailbox, const char *name_context)
 764 {
 765         char nameprefix[AST_NAME_STRLEN];
 766         char peer_name[AST_NAME_STRLEN + 5];
 767         char exitcontext[AST_MAX_CONTEXT] = "";
 768         signed char zero_volume = 0;
 769         int waitms;
 770         int res;
 771         char *ptr;
 772         int num_spyed_upon = 1;
 773         struct ast_channel_iterator *iter = NULL;
 774
 775         if (ast_test_flag(flags, OPTION_EXIT)) {
 776                 const char *c;
 777                 ast_channel_lock(chan);
 778                 if ((c = pbx_builtin_getvar_helper(chan, "SPY_EXIT_CONTEXT"))) {
 779                         ast_copy_string(exitcontext, c, sizeof(exitcontext));
 780                 } else if (!ast_strlen_zero(ast_channel_macrocontext(chan))) {
 781                         ast_copy_string(exitcontext, ast_channel_macrocontext(chan), sizeof(exitcontext));
 782                 } else {
 783                         ast_copy_string(exitcontext, ast_channel_context(chan), sizeof(exitcontext));
 784                 }
 785                 ast_channel_unlock(chan);
 786         }
 787
 788         if (ast_channel_state(chan) != AST_STATE_UP)
 789                 ast_answer(chan);
 790
 791         ast_set_flag(ast_channel_flags(chan), AST_FLAG_SPYING); /* so nobody can spy on us while we are spying */
 792
 793         waitms = 100;
 794
 795         for (;;) {
 796                 struct ast_autochan *autochan = NULL, *next_autochan = NULL;
 797                 struct ast_channel *prev = NULL;
 798
 799                 if (!ast_test_flag(flags, OPTION_QUIET) && num_spyed_upon) {
 800                         res = ast_streamfile(chan, "beep", ast_channel_language(chan));
 801                         if (!res)
 802                                 res = ast_waitstream(chan, "");
 803                         else if (res < 0) {
 804                                 ast_clear_flag(ast_channel_flags(chan), AST_FLAG_SPYING);
 805                                 break;
 806                         }
 807                         if (!ast_strlen_zero(exitcontext)) {
 808                                 char tmp[2];
 809                                 tmp[0] = res;
 810                                 tmp[1] = '\0';
 811                                 if (!ast_goto_if_exists(chan, exitcontext, tmp, 1))
 812                                         goto exit;
 813                                 else
 814                                         ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
 815                         }
 816                 }
 817
 818                 /* Set up the iterator we'll be using during this call */
 819                 if (!ast_strlen_zero(spec)) {
 820                         iter = ast_channel_iterator_by_name_new(spec, strlen(spec));
 821                 } else if (!ast_strlen_zero(exten)) {
 822                         iter = ast_channel_iterator_by_exten_new(exten, context);
 823                 } else {
 824                         iter = ast_channel_iterator_all_new();
 825                 }
 826
 827                 if (!iter) {
 828                         res = -1;
 829                         goto exit;
 830                 }
 831
 832                 res = ast_waitfordigit(chan, waitms);
 833                 if (res < 0) {
 834                         iter = ast_channel_iterator_destroy(iter);
 835                         ast_clear_flag(ast_channel_flags(chan), AST_FLAG_SPYING);
 836                         break;
 837                 }
 838                 if (!ast_strlen_zero(exitcontext)) {
 839                         char tmp[2];
 840                         tmp[0] = res;
 841                         tmp[1] = '\0';
 842                         if (!ast_goto_if_exists(chan, exitcontext, tmp, 1)) {
 843                                 iter = ast_channel_iterator_destroy(iter);
 844                                 goto exit;
 845                         } else {
 846                                 ast_debug(2, "Exit by single digit did not work in chanspy. Extension %s does not exist in context %s\n", tmp, exitcontext);
 847                         }
 848                 }
 849
 850                 /* reset for the next loop around, unless overridden later */
 851                 waitms = 100;
 852                 num_spyed_upon = 0;
 853
 854                 for (autochan = next_channel(iter, autochan, chan);
 855                      autochan;
 856                          prev = autochan->chan, ast_autochan_destroy(autochan),
 857                      autochan = next_autochan ? next_autochan :
 858                                 next_channel(iter, autochan, chan), next_autochan = NULL) {
 859                         int igrp = !mygroup;
 860                         int ienf = !myenforced;
 861                         char *s;
 862
 863                         if (autochan->chan == prev) {
 864                                 ast_autochan_destroy(autochan);
 865                                 break;
 866                         }
 867
 868                         if (ast_check_hangup(chan)) {
 869                                 ast_autochan_destroy(autochan);
 870                                 break;
 871                         }
 872
 873                         if (ast_test_flag(flags, OPTION_BRIDGED) && !ast_bridged_channel(autochan->chan)) {
 874                                 continue;
 875                         }
 876
 877                         if (ast_check_hangup(autochan->chan) || ast_test_flag(ast_channel_flags(autochan->chan), AST_FLAG_SPYING)) {
 878                                 continue;
 879                         }
 880
 881                         if (mygroup) {
 882                                 int num_groups = 0;
 883                                 int num_mygroups = 0;
 884                                 char dup_group[512];
 885                                 char dup_mygroup[512];
 886                                 char *groups[NUM_SPYGROUPS];
 887                                 char *mygroups[NUM_SPYGROUPS];
 888                                 const char *group = NULL;
 889                                 int x;
 890                                 int y;
 891                                 ast_copy_string(dup_mygroup, mygroup, sizeof(dup_mygroup));
 892                                 num_mygroups = ast_app_separate_args(dup_mygroup, ':', mygroups,
 893                                         ARRAY_LEN(mygroups));
 894
 895                                 /* Before dahdi scan was part of chanspy, it would use the "GROUP" variable
 896                                  * rather than "SPYGROUP", this check is done to preserve expected behavior */
 897                                 if (ast_test_flag(flags, OPTION_DAHDI_SCAN)) {
 898                                         group = pbx_builtin_getvar_helper(autochan->chan, "GROUP");
 899                                 } else {
 900                                         group = pbx_builtin_getvar_helper(autochan->chan, "SPYGROUP");
 901                                 }
 902
 903                                 if (!ast_strlen_zero(group)) {
 904                                         ast_copy_string(dup_group, group, sizeof(dup_group));
 905                                         num_groups = ast_app_separate_args(dup_group, ':', groups,
 906                                                 ARRAY_LEN(groups));
 907                                 }
 908
 909                                 for (y = 0; y < num_mygroups; y++) {
 910                                         for (x = 0; x < num_groups; x++) {
 911                                                 if (!strcmp(mygroups[y], groups[x])) {
 912                                                         igrp = 1;
 913                                                         break;
 914                                                 }
 915                                         }
 916                                 }
 917                         }
 918
 919                         if (!igrp) {
 920                                 continue;
 921                         }
 922                         if (myenforced) {
 923                                 char ext[AST_CHANNEL_NAME + 3];
 924                                 char buffer[512];
 925                                 char *end;
 926
 927                                 snprintf(buffer, sizeof(buffer) - 1, ":%s:", myenforced);
 928
 929                                 ast_copy_string(ext + 1, ast_channel_name(autochan->chan), sizeof(ext) - 1);
 930                                 if ((end = strchr(ext, '-'))) {
 931                                         *end++ = ':';
 932                                         *end = '\0';
 933                                 }
 934
 935                                 ext[0] = ':';
 936
 937                                 if (strcasestr(buffer, ext)) {
 938                                         ienf = 1;
 939                                 }
 940                         }
 941
 942                         if (!ienf) {
 943                                 continue;
 944                         }
 945
 946                         strcpy(peer_name, "spy-");
 947                         strncat(peer_name, ast_channel_name(autochan->chan), AST_NAME_STRLEN - 4 - 1);
 948                         ptr = strchr(peer_name, '/');
 949                         *ptr++ = '\0';
 950                         ptr = strsep(&ptr, "-");
 951
 952                         for (s = peer_name; s < ptr; s++)
 953                                 *s = tolower(*s);
 954
 955                         if (!ast_test_flag(flags, OPTION_QUIET)) {
 956                                 if (ast_test_flag(flags, OPTION_NAME)) {
 957                                         const char *local_context = S_OR(name_context, "default");
 958                                         const char *local_mailbox = S_OR(mailbox, ptr);
 959                                         res = ast_app_sayname(chan, local_mailbox, local_context);
 960                                 }
 961                                 if (!ast_test_flag(flags, OPTION_NAME) || res < 0) {
 962                                         int num;
 963                                         if (!ast_test_flag(flags, OPTION_NOTECH)) {
 964                                                 if (ast_fileexists(peer_name, NULL, NULL) > 0) {
 965                                                         res = ast_streamfile(chan, peer_name, ast_channel_language(chan));
 966                                                         if (!res) {
 967                                                                 res = ast_waitstream(chan, "");
 968                                                         }
 969                                                         if (res) {
 970                                                                 ast_autochan_destroy(autochan);
 971                                                                 break;
 972                                                         }
 973                                                 } else {
 974                                                         res = ast_say_character_str(chan, peer_name, "", ast_channel_language(chan));
 975                                                 }
 976                                         }
 977                                         if ((num = atoi(ptr))) {
 978                                                 ast_say_digits(chan, num, "", ast_channel_language(chan));
 979                                         }
 980                                 }
 981                         }
 982
 983                         res = channel_spy(chan, autochan, &volfactor, fd, user_options, flags, exitcontext);
 984                         num_spyed_upon++;
 985
 986                         if (res == -1) {
 987                                 ast_autochan_destroy(autochan);
 988                                 iter = ast_channel_iterator_destroy(iter);
 989                                 goto exit;
 990                         } else if (res == -2) {
 991                                 res = 0;
 992                                 ast_autochan_destroy(autochan);
 993                                 iter = ast_channel_iterator_destroy(iter);
 994                                 goto exit;
 995                         } else if (res > 1 && spec) {
 996                                 struct ast_channel *next;
 997
 998                                 snprintf(nameprefix, AST_NAME_STRLEN, "%s/%d", spec, res);
 999
1000                                 if ((next = ast_channel_get_by_name_prefix(nameprefix, strlen(nameprefix)))) {
1001                                         next_autochan = ast_autochan_setup(next);
1002                                         next = ast_channel_unref(next);
1003                                 } else {
1004                                         /* stay on this channel, if it is still valid */
1005                                         if (!ast_check_hangup(autochan->chan)) {
1006                                                 next_autochan = ast_autochan_setup(autochan->chan);
1007                                         } else {
1008                                                 /* the channel is gone */
1009                                                 next_autochan = NULL;
1010                                         }
1011                                 }
1012                         } else if (res == 0 && ast_test_flag(flags, OPTION_EXITONHANGUP)) {
1013                                 iter = ast_channel_iterator_destroy(iter);
1014                                 goto exit;
1015                         }
1016                 }
1017
1018                 iter = ast_channel_iterator_destroy(iter);
1019
1020                 if (res == -1 || ast_check_hangup(chan))
1021                         break;
1022                 if (ast_test_flag(flags, OPTION_STOP) && !next_autochan) {
1023                         break;
1024                 }
1025         }
1026 exit:
1027
1028         ast_clear_flag(ast_channel_flags(chan), AST_FLAG_SPYING);
1029
1030         ast_channel_setoption(chan, AST_OPTION_TXGAIN, &zero_volume, sizeof(zero_volume), 0);
1031
1032         return res;
1033 }
1034
1035 static int chanspy_exec(struct ast_channel *chan, const char *data)
1036 {
1037         char *myenforced = NULL;
1038         char *mygroup = NULL;
1039         char *recbase = NULL;
1040         int fd = 0;
1041         struct ast_flags flags;
1042         struct spy_dtmf_options user_options = {
1043                 .cycle = '*',
1044                 .volume = '#',
1045                 .exit = '\0',
1046         };
1047         struct ast_format oldwf;
1048         int volfactor = 0;
1049         int res;
1050         char *mailbox = NULL;
1051         char *name_context = NULL;
1052         AST_DECLARE_APP_ARGS(args,
1053                 AST_APP_ARG(spec);
1054                 AST_APP_ARG(options);
1055         );
1056         char *opts[OPT_ARG_ARRAY_SIZE];
1057         char *parse = ast_strdupa(data);
1058
1059         AST_STANDARD_APP_ARGS(args, parse);
1060         ast_format_clear(&oldwf);
1061
1062         if (args.spec && !strcmp(args.spec, "all"))
1063                 args.spec = NULL;
1064
1065         if (args.options) {
1066                 char tmp;
1067                 ast_app_parse_options(spy_opts, &flags, opts, args.options);
1068                 if (ast_test_flag(&flags, OPTION_GROUP))
1069                         mygroup = opts[OPT_ARG_GROUP];
1070
1071                 if (ast_test_flag(&flags, OPTION_RECORD) &&
1072                         !(recbase = opts[OPT_ARG_RECORD]))
1073                         recbase = "chanspy";
1074
1075                 if (ast_test_flag(&flags, OPTION_DTMF_EXIT) && opts[OPT_ARG_EXIT]) {
1076                         tmp = opts[OPT_ARG_EXIT][0];
1077                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1078                                 user_options.exit = tmp;
1079                         } else {
1080                                 ast_log(LOG_NOTICE, "Argument for option 'x' must be a valid DTMF digit.");
1081                         }
1082                 }
1083
1084                 if (ast_test_flag(&flags, OPTION_DTMF_CYCLE) && opts[OPT_ARG_CYCLE]) {
1085                         tmp = opts[OPT_ARG_CYCLE][0];
1086                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1087                                 user_options.cycle = tmp;
1088                         } else {
1089                                 ast_log(LOG_NOTICE, "Argument for option 'c' must be a valid DTMF digit.");
1090                         }
1091                 }
1092
1093                 if (ast_test_flag(&flags, OPTION_VOLUME) && opts[OPT_ARG_VOLUME]) {
1094                         int vol;
1095
1096                         if ((sscanf(opts[OPT_ARG_VOLUME], "%30d", &vol) != 1) || (vol > 4) || (vol < -4))
1097                                 ast_log(LOG_NOTICE, "Volume factor must be a number between -4 and 4\n");
1098                         else
1099                                 volfactor = vol;
1100                 }
1101
1102                 if (ast_test_flag(&flags, OPTION_PRIVATE))
1103                         ast_set_flag(&flags, OPTION_WHISPER);
1104
1105                 if (ast_test_flag(&flags, OPTION_ENFORCED))
1106                         myenforced = opts[OPT_ARG_ENFORCED];
1107
1108                 if (ast_test_flag(&flags, OPTION_NAME)) {
1109                         if (!ast_strlen_zero(opts[OPT_ARG_NAME])) {
1110                                 char *delimiter;
1111                                 if ((delimiter = strchr(opts[OPT_ARG_NAME], '@'))) {
1112                                         mailbox = opts[OPT_ARG_NAME];
1113                                         *delimiter++ = '\0';
1114                                         name_context = delimiter;
1115                                 } else {
1116                                         mailbox = opts[OPT_ARG_NAME];
1117                                 }
1118                         }
1119                 }
1120         } else {
1121                 ast_clear_flag(&flags, AST_FLAGS_ALL);
1122         }
1123
1124         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1125         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1126                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1127                 return -1;
1128         }
1129
1130         if (recbase) {
1131                 char filename[PATH_MAX];
1132
1133                 snprintf(filename, sizeof(filename), "%s/%s.%d.raw", ast_config_AST_MONITOR_DIR, recbase, (int) time(NULL));
1134                 if ((fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, AST_FILE_MODE)) <= 0) {
1135                         ast_log(LOG_WARNING, "Cannot open '%s' for recording\n", filename);
1136                         fd = 0;
1137                 }
1138         }
1139
1140         res = common_exec(chan, &flags, volfactor, fd, &user_options, mygroup, myenforced, args.spec, NULL, NULL, mailbox, name_context);
1141
1142         if (fd)
1143                 close(fd);
1144
1145         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1146                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1147
1148         if (ast_test_flag(&flags, OPTION_EXITONHANGUP)) {
1149                 ast_verb(3, "Stopped spying due to the spied-on channel hanging up.\n");
1150         }
1151
1152         return res;
1153 }
1154
1155 static int extenspy_exec(struct ast_channel *chan, const char *data)
1156 {
1157         char *ptr, *exten = NULL;
1158         char *mygroup = NULL;
1159         char *recbase = NULL;
1160         int fd = 0;
1161         struct ast_flags flags;
1162         struct spy_dtmf_options user_options = {
1163                 .cycle = '*',
1164                 .volume = '#',
1165                 .exit = '\0',
1166         };
1167         struct ast_format oldwf;
1168         int volfactor = 0;
1169         int res;
1170         char *mailbox = NULL;
1171         char *name_context = NULL;
1172         AST_DECLARE_APP_ARGS(args,
1173                 AST_APP_ARG(context);
1174                 AST_APP_ARG(options);
1175         );
1176         char *parse = ast_strdupa(data);
1177
1178         AST_STANDARD_APP_ARGS(args, parse);
1179         ast_format_clear(&oldwf);
1180
1181         if (!ast_strlen_zero(args.context) && (ptr = strchr(args.context, '@'))) {
1182                 exten = args.context;
1183                 *ptr++ = '\0';
1184                 args.context = ptr;
1185         }
1186         if (ast_strlen_zero(args.context))
1187                 args.context = ast_strdupa(ast_channel_context(chan));
1188
1189         if (args.options) {
1190                 char *opts[OPT_ARG_ARRAY_SIZE];
1191                 char tmp;
1192
1193                 ast_app_parse_options(spy_opts, &flags, opts, args.options);
1194                 if (ast_test_flag(&flags, OPTION_GROUP))
1195                         mygroup = opts[OPT_ARG_GROUP];
1196
1197                 if (ast_test_flag(&flags, OPTION_RECORD) &&
1198                         !(recbase = opts[OPT_ARG_RECORD]))
1199                         recbase = "chanspy";
1200
1201                 if (ast_test_flag(&flags, OPTION_DTMF_EXIT) && opts[OPT_ARG_EXIT]) {
1202                         tmp = opts[OPT_ARG_EXIT][0];
1203                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1204                                 user_options.exit = tmp;
1205                         } else {
1206                                 ast_log(LOG_NOTICE, "Argument for option 'x' must be a valid DTMF digit.");
1207                         }
1208                 }
1209
1210                 if (ast_test_flag(&flags, OPTION_DTMF_CYCLE) && opts[OPT_ARG_CYCLE]) {
1211                         tmp = opts[OPT_ARG_CYCLE][0];
1212                         if (strchr("0123456789*#", tmp) && tmp != '\0') {
1213                                 user_options.cycle = tmp;
1214                         } else {
1215                                 ast_log(LOG_NOTICE, "Argument for option 'c' must be a valid DTMF digit.");
1216                         }
1217                 }
1218
1219                 if (ast_test_flag(&flags, OPTION_VOLUME) && opts[OPT_ARG_VOLUME]) {
1220                         int vol;
1221
1222                         if ((sscanf(opts[OPT_ARG_VOLUME], "%30d", &vol) != 1) || (vol > 4) || (vol < -4))
1223                                 ast_log(LOG_NOTICE, "Volume factor must be a number between -4 and 4\n");
1224                         else
1225                                 volfactor = vol;
1226                 }
1227
1228                 if (ast_test_flag(&flags, OPTION_PRIVATE))
1229                         ast_set_flag(&flags, OPTION_WHISPER);
1230
1231                 if (ast_test_flag(&flags, OPTION_NAME)) {
1232                         if (!ast_strlen_zero(opts[OPT_ARG_NAME])) {
1233                                 char *delimiter;
1234                                 if ((delimiter = strchr(opts[OPT_ARG_NAME], '@'))) {
1235                                         mailbox = opts[OPT_ARG_NAME];
1236                                         *delimiter++ = '\0';
1237                                         name_context = delimiter;
1238                                 } else {
1239                                         mailbox = opts[OPT_ARG_NAME];
1240                                 }
1241                         }
1242                 }
1243
1244         } else {
1245                 ast_clear_flag(&flags, AST_FLAGS_ALL);
1246         }
1247
1248         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1249         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1250                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1251                 return -1;
1252         }
1253
1254         if (recbase) {
1255                 char filename[PATH_MAX];
1256
1257                 snprintf(filename, sizeof(filename), "%s/%s.%d.raw", ast_config_AST_MONITOR_DIR, recbase, (int) time(NULL));
1258                 if ((fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, AST_FILE_MODE)) <= 0) {
1259                         ast_log(LOG_WARNING, "Cannot open '%s' for recording\n", filename);
1260                         fd = 0;
1261                 }
1262         }
1263
1264
1265         res = common_exec(chan, &flags, volfactor, fd, &user_options, mygroup, NULL, NULL, exten, args.context, mailbox, name_context);
1266
1267         if (fd)
1268                 close(fd);
1269
1270         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1271                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1272
1273         return res;
1274 }
1275
1276 static int dahdiscan_exec(struct ast_channel *chan, const char *data)
1277 {
1278         const char *spec = "DAHDI";
1279         struct ast_flags flags;
1280         struct spy_dtmf_options user_options = {
1281                 .cycle = '#',
1282                 .volume = '\0',
1283                 .exit = '*',
1284         };
1285         struct ast_format oldwf;
1286         int res;
1287         char *mygroup = NULL;
1288
1289         ast_clear_flag(&flags, AST_FLAGS_ALL);
1290         ast_format_clear(&oldwf);
1291         if (!ast_strlen_zero(data)) {
1292                 mygroup = ast_strdupa(data);
1293         }
1294         ast_set_flag(&flags, OPTION_DTMF_EXIT);
1295         ast_set_flag(&flags, OPTION_DTMF_CYCLE);
1296         ast_set_flag(&flags, OPTION_DAHDI_SCAN);
1297
1298         ast_format_copy(&oldwf, ast_channel_writeformat(chan));
1299         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR) < 0) {
1300                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1301                 return -1;
1302         }
1303
1304         res = common_exec(chan, &flags, 0, 0, &user_options, mygroup, NULL, spec, NULL, NULL, NULL, NULL);
1305
1306         if (oldwf.id && ast_set_write_format(chan, &oldwf) < 0)
1307                 ast_log(LOG_ERROR, "Could Not Set Write Format.\n");
1308
1309         return res;
1310 }
1311
1312 static int unload_module(void)
1313 {
1314         int res = 0;
1315
1316         res |= ast_unregister_application(app_chan);
1317         res |= ast_unregister_application(app_ext);
1318         res |= ast_unregister_application(app_dahdiscan);
1319
1320         return res;
1321 }
1322
1323 static int load_module(void)
1324 {
1325         int res = 0;
1326
1327         res |= ast_register_application_xml(app_chan, chanspy_exec);
1328         res |= ast_register_application_xml(app_ext, extenspy_exec);
1329         res |= ast_register_application_xml(app_dahdiscan, dahdiscan_exec);
1330
1331         return res;
1332 }
1333
1334 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Listen to the audio of an active channel");