app_mf.c File Reference

MF sender and receiver applications. More...

#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"

Include dependency graph for app_mf.c:

Go to the source code of this file.

Macros
#define	BUFFER_SIZE   256
#define	MF_BETWEEN_MS   50
#define	MF_DURATION   55
#define	MF_KP_DURATION   120
#define	MF_ST_DURATION   65

Enumerations
enum	{ OPT_ARG_MAXDIGITS , OPT_ARG_ARRAY_SIZE }
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_MAXDIGITS = (1 << 9) , OPT_SKIP = (1 << 0) , OPT_INDICATION = (1 << 1) ,   OPT_NOANSWER = (1 << 2) , OPT_TERMINATOR = (1 << 3) , OPT_KEEP_TERMINATOR = (1 << 4) , OPT_ANSWER = (1 << 0) ,   OPT_DELAY = (1 << 0) , OPT_MUTE = (1 << 1) , OPT_QUELCH = (1 << 2) , OPT_RELAXED = (1 << 3) ,   OPT_EXTRAPULSES = (1 << 4) }

Functions
	AST_MODULE_INFO_STANDARD_EXTENDED (ASTERISK_GPL_KEY, "MF Sender and Receiver Applications")
static int	load_module (void)
static int	manager_play_mf (struct mansession *s, const struct message *m)
static int	read_mf_digits (struct ast_channel *chan, char *buf, int buflen, int timeout, int features, int laxkp, int override, int no_kp, int no_st, int maxdigits)
	Detects MF digits on channel using DSP, terminated by ST, STP, ST2P, or ST3P. More...
static int	read_mf_exec (struct ast_channel *chan, const char *data)
static int	sendmf_exec (struct ast_channel *chan, const char *vdata)
static int	unload_module (void)

Variables
static const struct ast_app_option	read_app_options [128] = { [ 'd' ] = { .flag = OPT_DELAY }, [ 'l' ] = { .flag = OPT_LAX_KP }, [ 'k' ] = { .flag = OPT_NO_KP }, [ 'm' ] = { .flag = OPT_MUTE }, [ 'n' ] = { .flag = OPT_MAXDIGITS , .arg_index = OPT_ARG_MAXDIGITS + 1 }, [ 'o' ] = { .flag = OPT_KP_OVERRIDE }, [ 'p' ] = { .flag = OPT_PROCESS }, [ 'q' ] = { .flag = OPT_QUELCH }, [ 'r' ] = { .flag = OPT_RELAXED }, [ 's' ] = { .flag = OPT_NO_ST }, }
static const char *	readmf_name = "ReceiveMF"
static const char	sendmf_name [] = "SendMF"

Detailed Description

MF sender and receiver applications.

Author

Naveen Albert aster.nosp@m.isk@.nosp@m.phrea.nosp@m.knet.nosp@m..org

Definition in file app_mf.c.

Macro Definition Documentation

BUFFER_SIZE

#define BUFFER_SIZE   256

MF_BETWEEN_MS

#define MF_BETWEEN_MS   50

Definition at line 225 of file app_mf.c.

MF_DURATION

#define MF_DURATION   55

Definition at line 226 of file app_mf.c.

MF_KP_DURATION

#define MF_KP_DURATION   120

Definition at line 227 of file app_mf.c.

MF_ST_DURATION

#define MF_ST_DURATION   65

Definition at line 228 of file app_mf.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
OPT_ARG_MAXDIGITS
OPT_ARG_ARRAY_SIZE

Definition at line 203 of file app_mf.c.

     {
    OPT_ARG_MAXDIGITS,
    /* Must be the last element */
    OPT_ARG_ARRAY_SIZE,
};

read_option_flags

enum read_option_flags

Enumerator
OPT_DELAY
OPT_MUTE
OPT_QUELCH
OPT_RELAXED
OPT_LAX_KP
OPT_PROCESS
OPT_NO_KP
OPT_NO_ST
OPT_KP_OVERRIDE
OPT_MAXDIGITS
OPT_SKIP
OPT_INDICATION
OPT_NOANSWER
OPT_TERMINATOR
OPT_KEEP_TERMINATOR
OPT_ANSWER
OPT_DELAY
OPT_MUTE
OPT_QUELCH
OPT_RELAXED
OPT_EXTRAPULSES

Definition at line 190 of file app_mf.c.

                       {
    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_MAXDIGITS = (1 << 9),
};

Function Documentation

AST_MODULE_INFO_STANDARD_EXTENDED()

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

load_module()

static int load_module ( void  )

static

Definition at line 536 of file app_mf.c.

{
    int res;
 
    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;
}

References ast_manager_register_xml, ast_register_application_xml, EVENT_FLAG_CALL, manager_play_mf(), read_mf_exec(), readmf_name, sendmf_exec(), and sendmf_name.

manager_play_mf()

static int manager_play_mf ( struct mansession *  s, const struct message *  m  )

static

Definition at line 484 of file app_mf.c.

{
    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, 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;
}

References ast_channel_get_by_name(), ast_channel_unref, ast_mf_stream(), ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), digit, MF_DURATION, MF_KP_DURATION, MF_ST_DURATION, and NULL.

Referenced by load_module().

read_mf_digits()

static int read_mf_digits ( struct ast_channel *  chan, char *  buf, int  buflen, int  timeout, int  features, int  laxkp, int  override, int  no_kp, int  no_st, int  maxdigits  )

static

Detects MF digits on channel using DSP, terminated by ST, STP, ST2P, or ST3P.

Parameters

chan	channel on which to read digits
buf	Buffer in which to store digits
buflen	Size of buffer
timeout	ms to wait for all digits before giving up
features	Any additional DSP features to use
laxkp	Receive digits even if KP not received
override	Start over if we receive additional KPs
no_kp	Don't include KP in the output
no_st	Don't include start digits in the output
maxdigits	If greater than 0, only read this many digits no matter what

Return values

0	if successful
-1	if unsuccessful (including hangup).

Definition at line 247 of file app_mf.c.

                                                                                                                                                                    {
    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;
    int res = 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_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;
            }
        }
        if ((maxdigits && digits_read >= maxdigits) || digits_read >= (buflen - 1)) { /* we don't have room to store any more digits (very unlikely to happen for a legitimate reason) */
            /* This result will probably not be usable, so status should not be START */
            pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "MAXDIGITS");
            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);
                        ast_frfree(frame);
                        continue;
                    }
                    ast_debug(1, "Received MF digit: %c\n", result);
                    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 */
                        } else {
                            digits_read++;
                        }
                        /* if we were told not to include the KP digit in the output string, then skip it */
                        if (no_kp) {
                            ast_frfree(frame);
                            continue;
                        }
                    } else {
                        digits_read++;
                    }
                    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; /* won't write past allotted memory, because of buffer check at top of loop */
                        *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");
                        ast_frfree(frame);
                        break;
                    }
                    /* only free frame if it was a DSP match. The MF itself should not be muted. */
                    ast_frfree(frame);
                }
            }
        } else {
            pbx_builtin_setvar_helper(chan, "RECEIVEMFSTATUS", "HANGUP");
            res = -1;
        }
    }
    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 res;
}

References ast_channel_name(), ast_debug, ast_dsp_free(), ast_dsp_new(), ast_dsp_process(), ast_dsp_set_digitmode(), ast_dsp_set_features(), AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree, ast_log, ast_read(), ast_remaining_ms(), ast_tvnow(), ast_waitfor(), buf, DSP_DIGITMODE_MF, DSP_FEATURE_DIGIT_DETECT, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, NULL, pbx_builtin_setvar_helper(), result, str, and ast_frame::subclass.

Referenced by read_mf_exec().

read_mf_exec()

static int read_mf_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 346 of file app_mf.c.

{
#define BUFFER_SIZE 256
    char tmp[BUFFER_SIZE] = "";
    int to = 0;
    double tosec;
    struct ast_flags flags = {0};
    char *optargs[OPT_ARG_ARRAY_SIZE];
    char *argcopy = NULL;
    int res, features = 0, maxdigits = 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, optargs, 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_MAXDIGITS) && !ast_strlen_zero(optargs[OPT_ARG_MAXDIGITS])) {
        maxdigits = atoi(optargs[OPT_ARG_MAXDIGITS]);
        if (maxdigits <= 0) {
            ast_log(LOG_WARNING, "Invalid maximum number of digits, ignoring: '%s'\n", optargs[OPT_ARG_MAXDIGITS]);
            maxdigits = 0;
        }
    }
 
    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;
    }
 
    res = read_mf_digits(chan, tmp, BUFFER_SIZE, 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)), maxdigits);
    pbx_builtin_setvar_helper(chan, arglist.variable, tmp);
    if (!ast_strlen_zero(tmp)) {
        ast_verb(3, "MF digits received: '%s'\n", tmp);
    } else if (!res) { /* if channel hung up, don't print anything out */
        ast_verb(3, "No MF digits received.\n");
    }
    return res;
}

References AST_APP_ARG, ast_app_parse_options(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_verb, BUFFER_SIZE, DSP_DIGITMODE_MUTECONF, DSP_DIGITMODE_MUTEMAX, DSP_DIGITMODE_NOQUELCH, DSP_DIGITMODE_RELAXDTMF, ast_flags::flags, LOG_WARNING, NULL, OPT_ARG_ARRAY_SIZE, OPT_ARG_MAXDIGITS, OPT_DELAY, OPT_KP_OVERRIDE, OPT_LAX_KP, OPT_MAXDIGITS, OPT_MUTE, OPT_NO_KP, OPT_NO_ST, OPT_QUELCH, OPT_RELAXED, options, pbx_builtin_setvar_helper(), read_app_options, read_mf_digits(), and tmp().

Referenced by load_module().

sendmf_exec()

static int sendmf_exec ( struct ast_channel *  chan, const char *  vdata  )

static

Definition at line 424 of file app_mf.c.

{
    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, NULL, 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);
    ast_channel_cleanup(chan_found);
 
    return chan_autoservice ? 0 : res;
}

References args, AST_APP_ARG, ast_app_parse_timelen(), ast_channel_cleanup, ast_channel_get_by_name(), AST_DECLARE_APP_ARGS, ast_log, ast_mf_stream(), AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_channel::data, LOG_WARNING, MF_BETWEEN_MS, MF_DURATION, MF_KP_DURATION, MF_ST_DURATION, NULL, and TIMELEN_MILLISECONDS.

Referenced by load_module().

unload_module()

static int unload_module ( void  )

static

Definition at line 525 of file app_mf.c.

{
    int res;
 
    res = ast_unregister_application(readmf_name);
    res |= ast_unregister_application(sendmf_name);
    res |= ast_manager_unregister("PlayMF");
 
    return res;
}

References ast_manager_unregister(), ast_unregister_application(), readmf_name, and sendmf_name.

Variable Documentation

read_app_options

const struct ast_app_option read_app_options[128] = { [ 'd' ] = { .flag = OPT_DELAY }, [ 'l' ] = { .flag = OPT_LAX_KP }, [ 'k' ] = { .flag = OPT_NO_KP }, [ 'm' ] = { .flag = OPT_MUTE }, [ 'n' ] = { .flag = OPT_MAXDIGITS , .arg_index = OPT_ARG_MAXDIGITS + 1 }, [ 'o' ] = { .flag = OPT_KP_OVERRIDE }, [ 'p' ] = { .flag = OPT_PROCESS }, [ 'q' ] = { .flag = OPT_QUELCH }, [ 'r' ] = { .flag = OPT_RELAXED }, [ 's' ] = { .flag = OPT_NO_ST }, }

static

Definition at line 220 of file app_mf.c.

Referenced by read_mf_exec().

readmf_name

const char* readmf_name = "ReceiveMF"

static

Definition at line 222 of file app_mf.c.

Referenced by load_module(), and unload_module().

sendmf_name

const char sendmf_name[] = "SendMF"

static

Definition at line 223 of file app_mf.c.

Referenced by load_module(), and unload_module().