app_mf.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2021, Naveen Albert
 *
 * Naveen Albert <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief MF sender and receiver applications
 *
 * \author Naveen Albert <[email protected]>
 *
 * \ingroup applications
 */

/*** MODULEINFO
   <support_level>extended</support_level>
 ***/

#include "asterisk.h"

#include "asterisk/file.h"
#include "asterisk/pbx.h"
#include "asterisk/channel.h"
#include "asterisk/dsp.h"
#include "asterisk/app.h"
#include "asterisk/module.h"
#include "asterisk/indications.h"
#include "asterisk/conversions.h"

/*** DOCUMENTATION
   <application name="ReceiveSF" language="en_US">
      <synopsis>
         Detects SF digits on a channel and saves them to a variable.
      </synopsis>
      <syntax>
         <parameter name="variable" required="true">
            <para>The input digits will be stored in the given
            <replaceable>variable</replaceable> name.</para>
         </parameter>
         <parameter name="digits" required="false">
            <para>Maximum number of digits to read. Default is unlimited.</para>
         </parameter>
         <parameter name="timeout">
            <para>The number of seconds to wait for all digits, if greater
            than <literal>0</literal>. Can be floating point. Default
            is no timeout.</para>
         </parameter>
         <parameter name="frequency">
            <para>The frequency for which to detect pulsed digits.
            Default is 2600 Hz.</para>
         </parameter>
         <parameter name="options">
            <optionlist>
               <option name="d">
                  <para>Delay audio by a frame to try to extra quelch.</para>
               </option>
               <option name="e">
                  <para>Allow receiving extra pulses 11 through 16.</para>
               </option>
               <option name="m">
                  <para>Mute conference.</para>
               </option>
               <option name="q">
                  <para>Quelch SF from in-band.</para>
               </option>
               <option name="r">
                  <para>"Radio" mode (relaxed SF).</para>
               </option>
            </optionlist>
         </parameter>
      </syntax>
      <description>
         <para>Reads SF digits from the user in to the given
         <replaceable>variable</replaceable>.</para>
         <para>This application does not automatically answer the channel and
         should be preceded with <literal>Answer</literal> or
         <literal>Progress</literal> as needed.</para>
         <variablelist>
            <variable name="RECEIVESFSTATUS">
               <para>This is the status of the read operation.</para>
               <value name="START" />
               <value name="ERROR" />
               <value name="HANGUP" />
               <value name="TIMEOUT" />
            </variable>
         </variablelist>
      </description>
      <see-also>
         <ref type="application">ReceiveMF</ref>
         <ref type="application">SendMF</ref>
         <ref type="application">Read</ref>
      </see-also>
   </application>
   <application name="ReceiveMF" language="en_US">
      <synopsis>
         Detects MF digits on a channel and saves them to a variable.
      </synopsis>
      <syntax>
         <parameter name="variable" required="true">
            <para>The input digits will be stored in the given
            <replaceable>variable</replaceable> name.</para>
         </parameter>
         <parameter name="timeout">
            <para>The number of seconds to wait for all digits, if greater
            than <literal>0</literal>. Can be floating point. Default
            is no timeout.</para>
         </parameter>
         <parameter name="options">
            <optionlist>
               <option name="d">
                  <para>Delay audio by a frame to try to extra quelch.</para>
               </option>
               <option name="l">
                  <para>Receive digits even if a key pulse (KP) has not yet
                  been received. By default, this application will ignore
                  all other digits until a KP has been received.</para>
               </option>
               <option name="k">
                  <para>Do not return a character for the KP digit.</para>
               </option>
               <option name="m">
                  <para>Mute conference.</para>
               </option>
               <option name="o">
                  <para>Enable override. Repeated KPs will clear all previous digits.</para>
               </option>
               <option name="q">
                  <para>Quelch MF from in-band.</para>
               </option>
               <option name="r">
                  <para>"Radio" mode (relaxed MF).</para>
               </option>
               <option name="s">
                  <para>Do not return a character for ST digits.</para>
               </option>
            </optionlist>
         </parameter>
      </syntax>
      <description>
         <para>Reads a ST, STP, ST2P, or ST3P-terminated string of MF digits from
         the user in to the given <replaceable>variable</replaceable>.</para>
         <para>This application does not automatically answer the channel and
         should be preceded with <literal>Answer</literal> or
         <literal>Progress</literal> as needed.</para>
         <variablelist>
            <variable name="RECEIVEMFSTATUS">
               <para>This is the status of the read operation.</para>
               <value name="START" />
               <value name="ERROR" />
               <value name="HANGUP" />
               <value name="TIMEOUT" />
            </variable>
         </variablelist>
      </description>
      <see-also>
         <ref type="application">ReceiveSF</ref>
         <ref type="application">SendMF</ref>
         <ref type="application">Read</ref>
      </see-also>
   </application>
   <application name="SendMF" language="en_US">
      <synopsis>
         Sends arbitrary MF digits on the current or specified channel.
      </synopsis>
      <syntax>
         <parameter name="digits" required="true">
            <para>List of digits 0-9,*#ABC to send; also f or F for a flash-hook
            if the channel supports flash-hook, and w or W for a wink if the channel
            supports wink.</para>
            <para>Key pulse and start digits are not included automatically.
            * is used for KP, # for ST, A for STP, B for ST2P, and C for ST3P.</para>
         </parameter>
         <parameter name="timeout_ms" required="false">
            <para>Amount of time to wait in ms between tones. (defaults to 50ms).</para>
         </parameter>
         <parameter name="duration_ms" required="false">
            <para>Duration of each numeric digit (defaults to 55ms).</para>
         </parameter>
         <parameter name="duration_ms_kp" required="false">
            <para>Duration of KP digits (defaults to 120ms).</para>
         </parameter>
         <parameter name="duration_ms_st" required="false">
            <para>Duration of ST, STP, ST2P, and ST3P digits (defaults to 65ms).</para>
         </parameter>
         <parameter name="channel" required="false">
            <para>Channel where digits will be played</para>
         </parameter>
      </syntax>
      <description>
         <para>It will send all digits or terminate if it encounters an error.</para>
      </description>
      <see-also>
         <ref type="application">ReceiveMF</ref>
         <ref type="application">SendDTMF</ref>
      </see-also>
   </application>
   <manager name="PlayMF" language="en_US">
      <synopsis>
         Play MF digit on a specific channel.
      </synopsis>
      <syntax>
         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
         <parameter name="Channel" required="true">
            <para>Channel name to send digit to.</para>
         </parameter>
         <parameter name="Digit" required="true">
            <para>The MF digit to play.</para>
         </parameter>
         <parameter name="Duration" required="false">
            <para>The duration, in milliseconds, of the digit to be played.</para>
         </parameter>
      </syntax>
      <description>
         <para>Plays an MF digit on the specified channel.</para>
      </description>
   </manager>
 ***/

enum read_option_flags {
   OPT_DELAY = (1 << 0),
   OPT_MUTE = (1 << 1),
   OPT_QUELCH = (1 << 2),
   OPT_RELAXED = (1 << 3),
   OPT_LAX_KP = (1 << 4),
   OPT_PROCESS = (1 << 5),
   OPT_NO_KP = (1 << 6),
   OPT_NO_ST = (1 << 7),
   OPT_KP_OVERRIDE = (1 << 8),
   OPT_EXTRAPULSES = (1 << 9),
};

AST_APP_OPTIONS(read_app_options, {
   AST_APP_OPTION('d', OPT_DELAY),
   AST_APP_OPTION('e', OPT_EXTRAPULSES), /* SF only */
   AST_APP_OPTION('l', OPT_LAX_KP), /* MF only */
   AST_APP_OPTION('k', OPT_NO_KP), /* MF only */
   AST_APP_OPTION('m', OPT_MUTE),
   AST_APP_OPTION('o', OPT_KP_OVERRIDE), /* MF only */
   AST_APP_OPTION('p', OPT_PROCESS), /* MF only */
   AST_APP_OPTION('q', OPT_QUELCH),
   AST_APP_OPTION('r', OPT_RELAXED),
   AST_APP_OPTION('s', OPT_NO_ST), /* MF only */
});

static char *readmf_name = "ReceiveMF";
static char *readsf_name = "ReceiveSF";
static const char sendmf_name[] = "SendMF";

#define MF_BETWEEN_MS 50
#define MF_DURATION 55
#define MF_KP_DURATION 120
#define MF_ST_DURATION 65

/*!
 * \brief Detects MF digits on channel using DSP, terminated by ST, STP, ST2P, or ST3P
 * \return 0 if successful, -1 if unsuccessful.
 * \param chan channel on which to read digits
 * \param str buffer in which to store digits
 * \param timeout ms to wait for all digits before giving up
 */
static int read_mf_digits(struct ast_channel *chan, char *buf, int timeout, int features, int laxkp, int override, int no_kp, int no_st) {
   struct ast_dsp *dsp;
   struct ast_frame *frame = NULL;
   struct timeval start;
   int remaining_time = timeout;
   int digits_read = 0;
   int is_start_digit = 0;
   char *str = buf;

   if (!(dsp = ast_dsp_new())) {
      ast_log(LOG_WARNING, "Unable to allocate DSP!\n");
      pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "ERROR");
      return -1;
   }
   ast_dsp_set_features(dsp, DSP_FEATURE_DIGIT_DETECT);
   ast_dsp_set_digitmode(dsp, DSP_DIGITMODE_MF | features);

   start = ast_tvnow();
   *str = 0; /* start with empty output buffer */

   /* based on app_read and generic_fax_exec from res_fax */
   while (timeout == 0 || remaining_time > 0) {
      if (timeout > 0) {
         remaining_time = ast_remaining_ms(start, timeout);
         if (remaining_time <= 0) {
            pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "TIMEOUT");
            break;
         }
      }
      /* ast_waitfordigit only waits for DTMF frames, we need to do DSP on voice frames */
      if (ast_waitfor(chan, 1000) > 0) {
         frame = ast_read(chan);
         if (!frame) {
            ast_debug(1, "Channel '%s' did not return a frame; probably hung up.\n", ast_channel_name(chan));
            pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "HANGUP");
            break;
         } else if (frame->frametype == AST_FRAME_VOICE) {
            frame = ast_dsp_process(chan, dsp, frame);
            /* AST_FRAME_DTMF is used all over the DSP code for DTMF, MF, fax, etc.
               It's used because we can use the frame to store the digit detected.
               All this means is that we received something we care about. */
            if (frame->frametype == AST_FRAME_DTMF) {
               char result = frame->subclass.integer;
               if (digits_read == 0 && !laxkp && result != '*') {
                  ast_debug(1, "Received MF digit, but no KP yet, ignoring: %c\n", result);
                  continue;
               }
               ast_debug(1, "Received MF digit: %c\n", result);
               digits_read++;
               if (result == '*') {
                  /* We received an additional KP, start over? */
                  if (override && digits_read > 0) {
                     ast_debug(1, "Received another KP, starting over\n");
                     str = buf;
                     *str = 0;
                     digits_read = 1; /* we just detected a KP */
                  }
                  /* if we were told not to include the ST digit in the output string, then skip it */
                  if (no_kp) {
                     continue;
                  }
               }
               is_start_digit = (strchr("#", result) || strchr("A", result) || strchr("B", result) || strchr("C", result));
               /* if we were told not to include the ST digit in the output string, then skip it */
               if (!no_st || !is_start_digit) {
                  *str++ = result;
                  *str = 0;
               }
               /* we received a ST digit (ST, STP, ST2P, or ST3P), so we're done */
               if (is_start_digit) {
                  pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "START");
                  break;
               }
            }
         }
      } else {
         pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "HANGUP");
      }
   }
   ast_dsp_free(dsp);
   ast_debug(3, "channel '%s' - event loop stopped { timeout: %d, remaining_time: %d }\n", ast_channel_name(chan), timeout, remaining_time);
   return 0;
}

static int read_sf_digits(struct ast_channel *chan, char *buf, int timeout, int maxdigits, int freq, int features, int extrapulses) {
   struct ast_dsp *dsp;
   struct ast_frame *frame = NULL;
   struct timeval start, pulsetimer, digittimer;
   int remaining_time = timeout;
   char *str = buf;
   int hits = 0, digits_read = 0;
   unsigned short int sf_on = 0;

   if (!(dsp = ast_dsp_new())) {
      ast_log(LOG_WARNING, "Unable to allocate DSP!\n");
      pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "ERROR");
      return -1;
   }
   ast_dsp_set_features(dsp, DSP_FEATURE_FREQ_DETECT);
   ast_dsp_set_freqmode(dsp, freq, 60, 16, 0);

   start = ast_tvnow();
   *str = 0; /* start with empty output buffer */

   while (timeout == 0 || remaining_time > 0) {
      if (timeout > 0) {
         remaining_time = ast_remaining_ms(start, timeout);
         if (remaining_time <= 0) {
            pbx_builtin_setvar_helper(chan, "RECEIVESFSTATUS", "TIMEOUT");
            break;
         }
      }
      if (ast_waitfor(chan, 1000) > 0) {
         frame = ast_read(chan);
         if (!frame) {
            ast_debug(1, "Channel '%s' did not return a frame; probably hung up.\n", ast_channel_name(chan));
            pbx_builtin_setvar_helper(chan, "RECEIVESFSTATUS", "HANGUP");
            break;
         } else if (frame->frametype == AST_FRAME_VOICE) {
            frame = ast_dsp_process(chan, dsp, frame);
            if (frame->frametype == AST_FRAME_DTMF) {
               char result = frame->subclass.integer;
               if (result == 'q') {
                  sf_on = 1;
                  pulsetimer = ast_tvnow(); /* reset the pulse timer */
                  /* now, we need at least a 40ms pause to register the pulse */
               }
            } else {
               if (sf_on) {
                  int timeleft = ast_remaining_ms(pulsetimer, 40);
                  if (timeleft <= 0) {
                     sf_on = 0;
                     /* The pulse needs to end no more than 75ms after we detected it */
                     if (timeleft > -75) {
                        hits++;
                        digittimer = ast_tvnow(); /* reset the digit timer */
                        ast_debug(5, "Detected SF pulse (pulse #%d)\n", hits);
                     } else {
                        ast_debug(5, "SF noise, ignoring, time elapsed was %d ms\n", timeleft);
                     }
                  }
               } else if (hits > 0 && ast_remaining_ms(digittimer, 100) <= 0) {
                  /* has the digit finished? */
                  ast_debug(2, "Received SF digit: %d\n", hits);
                  digits_read++;
                  if (hits > 10) {
                     if (extrapulses) {
                        /* dahdi-base.c translates 11 to * and 12 to # */
                        if (hits == 11)
                           hits = '*';
                        else if (hits == 12)
                           hits = '#';
                        else if (hits == 13)
                           hits = 'D';
                        else if (hits == 14)
                           hits = 'C';
                        else if (hits == 15)
                           hits = 'B';
                        else if (hits == 16)
                           hits = 'A';
                        else {
                           ast_debug(3, "Got SF pulse digit %d, is someone playing with the phone?\n", hits);
                           hits = 'A';
                        }
                        *str++ = hits;
                     } else {
                        ast_debug(2, "Got more than 10 pulses, truncating to 10\n");
                        hits = 0; /* 10 dial pulses = digit 0 */
                        *str++ = hits + '0';
                     }
                  } else {
                     if (hits == 10) {
                        hits = 0; /* 10 dial pulses = digit 0 */
                     }
                     *str++ = hits + '0';
                  }
                  *str = 0;
                  hits = 0;
                  if (maxdigits > 0 && digits_read >= maxdigits) {
                     pbx_builtin_setvar_helper(chan, "RECEIVESFSTATUS", "START");
                     break;
                  }
               }
            }
         }
      } else {
         pbx_builtin_setvar_helper(chan, "RECEIVESFSTATUS", "HANGUP");
      }
   }
   ast_dsp_free(dsp);
   ast_debug(3, "channel '%s' - event loop stopped { timeout: %d, remaining_time: %d }\n", ast_channel_name(chan), timeout, remaining_time);
   return 0;
}

/*
add SendSF application here
*/

static int read_sf_exec(struct ast_channel *chan, const char *data)
{
   char tmp[256] = "";
   double tosec;
   struct ast_flags flags = {0};
   char *argcopy = NULL;
   int features = 0, digits = 0, to = 0, freq = 2600;

   AST_DECLARE_APP_ARGS(arglist,
      AST_APP_ARG(variable);
      AST_APP_ARG(digits);
      AST_APP_ARG(timeout);
      AST_APP_ARG(freq);
      AST_APP_ARG(options);
   );

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "ReceiveSF requires an argument (variable)\n");
      return -1;
   }

   argcopy = ast_strdupa(data);

   AST_STANDARD_APP_ARGS(arglist, argcopy);

   if (!ast_strlen_zero(arglist.options)) {
      ast_app_parse_options(read_app_options, &flags, NULL, arglist.options);
   }

   if (!ast_strlen_zero(arglist.timeout)) {
      tosec = atof(arglist.timeout);
      if (tosec <= 0) {
         to = 0;
      } else {
         to = tosec * 1000.0;
      }
   }

   if (!ast_strlen_zero(arglist.digits) && (ast_str_to_int(arglist.digits, &digits) || digits <= 0)) {
      ast_log(LOG_WARNING, "Invalid number of digits: %s\n", arglist.digits);
      return -1;
   }

   if (!ast_strlen_zero(arglist.freq) && (ast_str_to_int(arglist.freq, &freq) || freq <= 0)) {
      ast_log(LOG_WARNING, "Invalid freq: %s\n", arglist.freq);
      return -1;
   }

   if (ast_strlen_zero(arglist.variable)) {
      ast_log(LOG_WARNING, "Invalid! Usage: ReceiveSF(variable[,timeout][,option])\n");
      return -1;
   }

   if (ast_test_flag(&flags, OPT_DELAY)) {
      features |= DSP_DIGITMODE_MUTEMAX;
   }

   if (ast_test_flag(&flags, OPT_MUTE)) {
      features |= DSP_DIGITMODE_MUTECONF;
   }

   if (!ast_test_flag(&flags, OPT_QUELCH)) {
      features |= DSP_DIGITMODE_NOQUELCH;
   }

   if (ast_test_flag(&flags, OPT_RELAXED)) {
      features |= DSP_DIGITMODE_RELAXDTMF;
   }

   read_sf_digits(chan, tmp, to, digits, freq, features, ast_test_flag(&flags, OPT_EXTRAPULSES));
   pbx_builtin_setvar_helper(chan, arglist.variable, tmp);
   if (!ast_strlen_zero(tmp)) {
      ast_verb(3, "MF digits received: '%s'\n", tmp);
   } else {
      ast_verb(3, "No MF digits received.\n");
   }
   return 0;
}

static int read_mf_exec(struct ast_channel *chan, const char *data)
{
   char tmp[256] = "";
   int to = 0;
   double tosec;
   struct ast_flags flags = {0};
   char *argcopy = NULL;
   int features = 0;

   AST_DECLARE_APP_ARGS(arglist,
      AST_APP_ARG(variable);
      AST_APP_ARG(timeout);
      AST_APP_ARG(options);
   );

   if (ast_strlen_zero(data)) {
      ast_log(LOG_WARNING, "ReceiveMF requires an argument (variable)\n");
      return -1;
   }

   argcopy = ast_strdupa(data);

   AST_STANDARD_APP_ARGS(arglist, argcopy);

   if (!ast_strlen_zero(arglist.options)) {
      ast_app_parse_options(read_app_options, &flags, NULL, arglist.options);
   }

   if (!ast_strlen_zero(arglist.timeout)) {
      tosec = atof(arglist.timeout);
      if (tosec <= 0) {
         to = 0;
      } else {
         to = tosec * 1000.0;
      }
   }

   if (ast_strlen_zero(arglist.variable)) {
      ast_log(LOG_WARNING, "Invalid! Usage: ReceiveMF(variable[,timeout][,option])\n");
      return -1;
   }

   if (ast_test_flag(&flags, OPT_DELAY)) {
      features |= DSP_DIGITMODE_MUTEMAX;
   }

   if (ast_test_flag(&flags, OPT_MUTE)) {
      features |= DSP_DIGITMODE_MUTECONF;
   }

   if (!ast_test_flag(&flags, OPT_QUELCH)) {
      features |= DSP_DIGITMODE_NOQUELCH;
   }

   if (ast_test_flag(&flags, OPT_RELAXED)) {
      features |= DSP_DIGITMODE_RELAXDTMF;
   }

   read_mf_digits(chan, tmp, to, features, (ast_test_flag(&flags, OPT_LAX_KP)),
      (ast_test_flag(&flags, OPT_KP_OVERRIDE)), (ast_test_flag(&flags, OPT_NO_KP)), (ast_test_flag(&flags, OPT_NO_ST)));
   pbx_builtin_setvar_helper(chan, arglist.variable, tmp);
   if (!ast_strlen_zero(tmp)) {
      ast_verb(3, "MF digits received: '%s'\n", tmp);
   } else {
      ast_verb(3, "No MF digits received.\n");
   }
   return 0;
}

static int sendmf_exec(struct ast_channel *chan, const char *vdata)
{
   int res;
   char *data;
   int dinterval = 0, duration = 0, durationkp = 0, durationst = 0;
   struct ast_channel *chan_found = NULL;
   struct ast_channel *chan_dest = chan;
   struct ast_channel *chan_autoservice = NULL;
   AST_DECLARE_APP_ARGS(args,
      AST_APP_ARG(digits);
      AST_APP_ARG(dinterval);
      AST_APP_ARG(duration);
      AST_APP_ARG(durationkp);
      AST_APP_ARG(durationst);
      AST_APP_ARG(channel);
   );

   if (ast_strlen_zero(vdata)) {
      ast_log(LOG_WARNING, "SendMF requires an argument\n");
      return 0;
   }

   data = ast_strdupa(vdata);
   AST_STANDARD_APP_ARGS(args, data);

   if (ast_strlen_zero(args.digits)) {
      ast_log(LOG_WARNING, "The digits argument is required (0-9,*#ABC,wf)\n");
      return 0;
   }
   if (!ast_strlen_zero(args.dinterval)) {
      ast_app_parse_timelen(args.dinterval, &dinterval, TIMELEN_MILLISECONDS);
   }
   if (!ast_strlen_zero(args.duration)) {
      ast_app_parse_timelen(args.duration, &duration, TIMELEN_MILLISECONDS);
   }
   if (!ast_strlen_zero(args.durationkp)) {
      ast_app_parse_timelen(args.durationkp, &durationkp, TIMELEN_MILLISECONDS);
   }
   if (!ast_strlen_zero(args.durationst)) {
      ast_app_parse_timelen(args.durationst, &durationst, TIMELEN_MILLISECONDS);
   }
   if (!ast_strlen_zero(args.channel)) {
      chan_found = ast_channel_get_by_name(args.channel);
      if (!chan_found) {
         ast_log(LOG_WARNING, "No such channel: %s\n", args.channel);
         return 0;
      }
      chan_dest = chan_found;
      if (chan_found != chan) {
         chan_autoservice = chan;
      }
   }
   res = ast_mf_stream(chan_dest, chan_autoservice, args.digits, dinterval <= 0 ? MF_BETWEEN_MS : dinterval,
      duration <= 0 ? MF_DURATION : duration, durationkp <= 0 ? MF_KP_DURATION : durationkp,
      durationst <= 0 ? MF_ST_DURATION : durationst, 0);
   if (chan_found) {
      ast_channel_unref(chan_found);
   }

   return chan_autoservice ? 0 : res;
}

static int manager_play_mf(struct mansession *s, const struct message *m)
{
   const char *channel = astman_get_header(m, "Channel");
   const char *digit = astman_get_header(m, "Digit");
   const char *duration = astman_get_header(m, "Duration");
   struct ast_channel *chan;
   unsigned int duration_ms = MF_DURATION;

   if (!(chan = ast_channel_get_by_name(channel))) {
      astman_send_error(s, m, "Channel not found");
      return 0;
   }

   if (ast_strlen_zero(digit)) {
      astman_send_error(s, m, "No digit specified");
      chan = ast_channel_unref(chan);
      return 0;
   }

   /* Override default duration with KP or ST-specific default durations */
   if (!strcmp(digit, "*"))
      duration_ms = MF_KP_DURATION;

   if (!strcmp(digit, "#") || !strcmp(digit, "A") || !strcmp(digit, "B") || !strcmp(digit, "C"))
      duration_ms = MF_ST_DURATION;

   if (!ast_strlen_zero(duration) && (sscanf(duration, "%30u", &duration_ms) != 1)) {
      astman_send_error(s, m, "Could not convert Duration parameter");
      chan = ast_channel_unref(chan);
      return 0;
   }

   ast_mf_stream(chan, NULL, digit, 0, duration_ms, duration_ms, duration_ms, 1);

   chan = ast_channel_unref(chan);

   astman_send_ack(s, m, "MF successfully queued");

   return 0;
}

static int unload_module(void)
{
   int res;

   res = ast_unregister_application(readsf_name);
   res |= ast_unregister_application(readmf_name);
   res |= ast_unregister_application(sendmf_name);
   res |= ast_manager_unregister("PlayMF");

   return res;
}

static int load_module(void)
{
   int res;

   res = ast_register_application_xml(readsf_name, read_sf_exec);
   res |= ast_register_application_xml(readmf_name, read_mf_exec);
   res |= ast_register_application_xml(sendmf_name, sendmf_exec);
   res |= ast_manager_register_xml("PlayMF", EVENT_FLAG_CALL, manager_play_mf);

   return res;
}

AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "MF Sender and Receiver Applications");