MixMonitor() - Record a call and mix the audio during the recording. More...

#include "asterisk.h"
#include "asterisk/paths.h"
#include "asterisk/stringfields.h"
#include "asterisk/file.h"
#include "asterisk/audiohook.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/channel.h"
#include "asterisk/autochan.h"
#include "asterisk/manager.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/callerid.h"
#include "asterisk/mod_format.h"
#include "asterisk/linkedlists.h"
#include "asterisk/test.h"
#include "asterisk/mixmonitor.h"
#include "asterisk/format_cache.h"
#include "asterisk/beep.h"

Include dependency graph for app_mixmonitor.c:

Go to the source code of this file.

Data Structures
struct	mixmonitor

struct	mixmonitor_ds

struct	vm_recipient

Macros
#define	get_volfactor(x) x ? ((x > 0) ? (1 << x) : ((1 << abs(x)) * -1)) : 0

#define	SAMPLES_PER_FRAME 160

Enumerations
enum	mixmonitor_args { OPT_ARG_READVOLUME = 0 , OPT_ARG_WRITEVOLUME , OPT_ARG_VOLUME , OPT_ARG_WRITENAME , OPT_ARG_READNAME , OPT_ARG_UID , OPT_ARG_VMRECIPIENTS , OPT_ARG_BEEP_INTERVAL , OPT_ARG_DEPRECATED_RWSYNC , OPT_ARG_NO_RWSYNC , OPT_ARG_ARRAY_SIZE }

enum	mixmonitor_flags { MUXFLAG_APPEND = (1 << 1) , MUXFLAG_BRIDGED = (1 << 2) , MUXFLAG_VOLUME = (1 << 3) , MUXFLAG_READVOLUME = (1 << 4) , MUXFLAG_WRITEVOLUME = (1 << 5) , MUXFLAG_READ = (1 << 6) , MUXFLAG_WRITE = (1 << 7) , MUXFLAG_COMBINED = (1 << 8) , MUXFLAG_UID = (1 << 9) , MUXFLAG_VMRECIPIENTS = (1 << 10) , MUXFLAG_BEEP = (1 << 11) , MUXFLAG_BEEP_START = (1 << 12) , MUXFLAG_BEEP_STOP = (1 << 13) , MUXFLAG_DEPRECATED_RWSYNC = (1 << 14) , MUXFLAG_NO_RWSYNC = (1 << 15) , MUXFLAG_AUTO_DELETE = (1 << 16) , MUXFLAG_REAL_CALLERID = (1 << 17) , MUXFLAG_INTERLEAVED = (1 << 18) }

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

static void	add_vm_recipients_from_string (struct mixmonitor mixmonitor, const char vm_recipients)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static int	clear_mixmonitor_methods (void)

static void	clear_mixmonitor_recipient_list (struct mixmonitor *mixmonitor)

static void	copy_to_voicemail (struct mixmonitor mixmonitor, const char ext, const char *filename)

static void	destroy_monitor_audiohook (struct mixmonitor *mixmonitor)

static char *	filename_parse (char filename, char buffer, size_t len)

static int	func_mixmonitor_read (struct ast_channel chan, const char cmd, char data, char buf, size_t len)

static char *	handle_cli_mixmonitor (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static int	launch_monitor_thread (struct ast_channel chan, const char filename, unsigned int flags, int readvol, int writevol, const char post_process, const char filename_write, char filename_read, const char uid_channel_var, const char recipients, const char beep_id)

static int	load_module (void)

static int	manager_mixmonitor (struct mansession s, const struct message m)

static int	manager_mute_mixmonitor (struct mansession s, const struct message m)
	Mute / unmute a MixMonitor channel.

static int	manager_stop_mixmonitor (struct mansession s, const struct message m)

static int	mixmonitor_autochan_is_bridged (struct ast_autochan *autochan)

static void	mixmonitor_ds_close_fs (struct mixmonitor_ds *mixmonitor_ds)

static void	mixmonitor_ds_destroy (void *data)

static void	mixmonitor_ds_remove_and_free (struct ast_channel chan, const char datastore_id)

static int	mixmonitor_exec (struct ast_channel chan, const char data)

static void	mixmonitor_free (struct mixmonitor *mixmonitor)

static void	mixmonitor_save_prep (struct mixmonitor mixmonitor, char filename, struct ast_filestream *fs, unsigned int oflags, int errflag, char *ext)

static void *	mixmonitor_thread (void *obj)

static int	mute_mixmonitor_instance (struct ast_channel chan, const char data, enum ast_audiohook_flags flag, int clearmute)
	Mute / unmute an individual MixMonitor by id.

static int	set_mixmonitor_methods (void)

static int	setup_mixmonitor_ds (struct mixmonitor mixmonitor, struct ast_channel chan, char *datastore_id, const char beep_id)

static int	start_mixmonitor_callback (struct ast_channel chan, const char filename, const char *options)

static int	startmon (struct ast_channel chan, struct ast_audiohook audiohook)

static int	stop_mixmonitor_callback (struct ast_channel chan, const char mixmonitor_id)

static int	stop_mixmonitor_exec (struct ast_channel chan, const char data)

static int	stop_mixmonitor_full (struct ast_channel chan, const char data)

static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Mixed Audio Monitoring Application" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .optional_modules = "func_periodic_hook", }

static const char *const	app = "MixMonitor"

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct ast_cli_entry	cli_mixmonitor []

static const struct ast_datastore_info	mixmonitor_ds_info

static struct ast_custom_function	mixmonitor_function

static const struct ast_app_option	mixmonitor_opts [128] = { [ 'a' ] = { .flag = MUXFLAG_APPEND }, [ 'b' ] = { .flag = MUXFLAG_BRIDGED }, [ 'B' ] = { .flag = MUXFLAG_BEEP , .arg_index = OPT_ARG_BEEP_INTERVAL + 1 }, [ 'c' ] = { .flag = MUXFLAG_REAL_CALLERID }, [ 'd' ] = { .flag = MUXFLAG_AUTO_DELETE }, [ 'p' ] = { .flag = MUXFLAG_BEEP_START }, [ 'P' ] = { .flag = MUXFLAG_BEEP_STOP }, [ 'v' ] = { .flag = MUXFLAG_READVOLUME , .arg_index = OPT_ARG_READVOLUME + 1 }, [ 'V' ] = { .flag = MUXFLAG_WRITEVOLUME , .arg_index = OPT_ARG_WRITEVOLUME + 1 }, [ 'W' ] = { .flag = MUXFLAG_VOLUME , .arg_index = OPT_ARG_VOLUME + 1 }, [ 'r' ] = { .flag = MUXFLAG_READ , .arg_index = OPT_ARG_READNAME + 1 }, [ 't' ] = { .flag = MUXFLAG_WRITE , .arg_index = OPT_ARG_WRITENAME + 1 }, [ 'D' ] = { .flag = MUXFLAG_INTERLEAVED }, [ 'i' ] = { .flag = MUXFLAG_UID , .arg_index = OPT_ARG_UID + 1 }, [ 'm' ] = { .flag = MUXFLAG_VMRECIPIENTS , .arg_index = OPT_ARG_VMRECIPIENTS + 1 }, [ 'S' ] = { .flag = MUXFLAG_DEPRECATED_RWSYNC , .arg_index = OPT_ARG_DEPRECATED_RWSYNC + 1 }, [ 'n' ] = { .flag = MUXFLAG_NO_RWSYNC , .arg_index = OPT_ARG_NO_RWSYNC + 1 }, }

static const char *const	mixmonitor_spy_type = "MixMonitor"

static const char *const	stop_app = "StopMixMonitor"

Detailed Description

MixMonitor() - Record a call and mix the audio during the recording.

Author: Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m; Kevin P. Fleming kpfle.nosp@m.ming.nosp@m.@digi.nosp@m.um.c.nosp@m.om

Note: Based on app_muxmon.c provided by Anthony Minessale II anthm.nosp@m.ct@y.nosp@m.ahoo..nosp@m.com

Definition in file app_mixmonitor.c.

Macro Definition Documentation

◆ get_volfactor

#define get_volfactor ( x ) x ? ((x > 0) ? (1 << x) : ((1 << abs(x)) * -1)) : 0

Definition at line 394 of file app_mixmonitor.c.

◆ SAMPLES_PER_FRAME

#define SAMPLES_PER_FRAME 160

Definition at line 653 of file app_mixmonitor.c.

Enumeration Type Documentation

◆ mixmonitor_args

enum mixmonitor_args

Enumerator
OPT_ARG_READVOLUME
OPT_ARG_WRITEVOLUME
OPT_ARG_VOLUME
OPT_ARG_WRITENAME
OPT_ARG_READNAME
OPT_ARG_UID
OPT_ARG_VMRECIPIENTS
OPT_ARG_BEEP_INTERVAL
OPT_ARG_DEPRECATED_RWSYNC
OPT_ARG_NO_RWSYNC
OPT_ARG_ARRAY_SIZE

Definition at line 460 of file app_mixmonitor.c.

                     {
    OPT_ARG_READVOLUME = 0,
    OPT_ARG_WRITEVOLUME,
    OPT_ARG_VOLUME,
    OPT_ARG_WRITENAME,
    OPT_ARG_READNAME,
    OPT_ARG_UID,
    OPT_ARG_VMRECIPIENTS,
    OPT_ARG_BEEP_INTERVAL,
    OPT_ARG_DEPRECATED_RWSYNC,
    OPT_ARG_NO_RWSYNC,
    OPT_ARG_ARRAY_SIZE, /* Always last element of the enum */
};

◆ mixmonitor_flags

enum mixmonitor_flags

Enumerator
MUXFLAG_APPEND
MUXFLAG_BRIDGED
MUXFLAG_VOLUME
MUXFLAG_READVOLUME
MUXFLAG_WRITEVOLUME
MUXFLAG_READ
MUXFLAG_WRITE
MUXFLAG_COMBINED
MUXFLAG_UID
MUXFLAG_VMRECIPIENTS
MUXFLAG_BEEP
MUXFLAG_BEEP_START
MUXFLAG_BEEP_STOP
MUXFLAG_DEPRECATED_RWSYNC
MUXFLAG_NO_RWSYNC
MUXFLAG_AUTO_DELETE
MUXFLAG_REAL_CALLERID
MUXFLAG_INTERLEAVED

Definition at line 439 of file app_mixmonitor.c.

                      {
    MUXFLAG_APPEND = (1 << 1),
    MUXFLAG_BRIDGED = (1 << 2),
    MUXFLAG_VOLUME = (1 << 3),
    MUXFLAG_READVOLUME = (1 << 4),
    MUXFLAG_WRITEVOLUME = (1 << 5),
    MUXFLAG_READ = (1 << 6),
    MUXFLAG_WRITE = (1 << 7),
    MUXFLAG_COMBINED = (1 << 8),
    MUXFLAG_UID = (1 << 9),
    MUXFLAG_VMRECIPIENTS = (1 << 10),
    MUXFLAG_BEEP = (1 << 11),
    MUXFLAG_BEEP_START = (1 << 12),
    MUXFLAG_BEEP_STOP = (1 << 13),
    MUXFLAG_DEPRECATED_RWSYNC = (1 << 14),
    MUXFLAG_NO_RWSYNC = (1 << 15),
    MUXFLAG_AUTO_DELETE = (1 << 16),
    MUXFLAG_REAL_CALLERID = (1 << 17),
    MUXFLAG_INTERLEAVED = (1 << 18),
};

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 1881 of file app_mixmonitor.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 1881 of file app_mixmonitor.c.

◆ add_vm_recipients_from_string()

static void add_vm_recipients_from_string	(	struct mixmonitor *	mixmonitor,
		const char *	vm_recipients
	)

static

Definition at line 595 of file app_mixmonitor.c.

{
    /* recipients are in a single string with a format format resembling "mailbox@context/INBOX,mailbox2@context2,mailbox3@context3/Work" */
    char *cur_mailbox = ast_strdupa(vm_recipients);
    char *cur_context;
    char *cur_folder;
    char *next;
    int elements_processed = 0;
 
    while (!ast_strlen_zero(cur_mailbox)) {
        ast_debug(3, "attempting to add next element %d from %s\n", elements_processed, cur_mailbox);
        if ((next = strchr(cur_mailbox, ',')) || (next = strchr(cur_mailbox, '&'))) {
            *(next++) = '\0';
        }
 
        if ((cur_folder = strchr(cur_mailbox, '/'))) {
            *(cur_folder++) = '\0';
        } else {
            cur_folder = "INBOX";
        }
 
        if ((cur_context = strchr(cur_mailbox, '@'))) {
            *(cur_context++) = '\0';
        } else {
            cur_context = "default";
        }
 
        if (!ast_strlen_zero(cur_mailbox) && !ast_strlen_zero(cur_context)) {
            struct vm_recipient *recipient;
            if (!(recipient = ast_malloc(sizeof(*recipient)))) {
                ast_log(LOG_ERROR, "Failed to allocate recipient. Aborting function.\n");
                return;
            }
            ast_copy_string(recipient->context, cur_context, sizeof(recipient->context));
            ast_copy_string(recipient->mailbox, cur_mailbox, sizeof(recipient->mailbox));
            ast_copy_string(recipient->folder, cur_folder, sizeof(recipient->folder));
 
            /* Add to list */
            ast_verb(4, "Adding %s@%s to recipient list\n", recipient->mailbox, recipient->context);
            AST_LIST_INSERT_HEAD(&mixmonitor->recipient_list, recipient, list);
        } else {
            ast_log(LOG_ERROR, "Failed to properly parse extension and/or context from element %d of recipient string: %s\n", elements_processed, vm_recipients);
        }
 
        cur_mailbox = next;
        elements_processed++;
    }
}

References ast_copy_string(), ast_debug, AST_LIST_INSERT_HEAD, ast_log, ast_malloc, ast_strdupa, ast_strlen_zero(), ast_verb, vm_recipient::context, vm_recipient::folder, vm_recipient::list, LOG_ERROR, vm_recipient::mailbox, vm_recipient::next, and mixmonitor::recipient_list.

Referenced by launch_monitor_thread().

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 1881 of file app_mixmonitor.c.

◆ clear_mixmonitor_methods()

static int clear_mixmonitor_methods ( void )

static

Definition at line 1839 of file app_mixmonitor.c.

{
    return ast_clear_mixmonitor_methods();
}

References ast_clear_mixmonitor_methods().

Referenced by unload_module().

◆ clear_mixmonitor_recipient_list()

static void clear_mixmonitor_recipient_list ( struct mixmonitor * mixmonitor )

static

Definition at line 644 of file app_mixmonitor.c.

{
    struct vm_recipient *current;
    while ((current = AST_LIST_REMOVE_HEAD(&mixmonitor->recipient_list, list))) {
        /* Clear list element data */
        ast_free(current);
    }
}

References ast_free, AST_LIST_REMOVE_HEAD, current, vm_recipient::list, and mixmonitor::recipient_list.

Referenced by mixmonitor_free().

◆ copy_to_voicemail()

static void copy_to_voicemail	(	struct mixmonitor *	mixmonitor,
		const char *	ext,
		const char *	filename
	)

static

Definition at line 687 of file app_mixmonitor.c.

{
    struct vm_recipient *recipient = NULL;
    struct ast_vm_recording_data recording_data;
    if (ast_string_field_init(&recording_data, 512)) {
        ast_log(LOG_ERROR, "Failed to string_field_init, skipping copy_to_voicemail\n");
        return;
    }
 
    /* Copy strings to stringfields that will be used for all recipients */
    ast_string_field_set(&recording_data, recording_file, filename);
    ast_string_field_set(&recording_data, recording_ext, ext);
    ast_string_field_set(&recording_data, call_context, mixmonitor->call_context);
    ast_string_field_set(&recording_data, call_extension, mixmonitor->call_extension);
    ast_string_field_set(&recording_data, call_callerchan, mixmonitor->call_callerchan);
    ast_string_field_set(&recording_data, call_callerid, mixmonitor->call_callerid);
    /* and call_priority gets copied too */
    recording_data.call_priority = mixmonitor->call_priority;
 
    AST_LIST_TRAVERSE(&mixmonitor->recipient_list, recipient, list) {
        /* context, mailbox, and folder need to be set per recipient */
        ast_string_field_set(&recording_data, context, recipient->context);
        ast_string_field_set(&recording_data, mailbox, recipient->mailbox);
        ast_string_field_set(&recording_data, folder, recipient->folder);
 
        ast_verb(4, "MixMonitor attempting to send voicemail copy to %s@%s\n", recording_data.mailbox,
            recording_data.context);
        ast_app_copy_recording_to_vm(&recording_data);
    }
 
    /* Free the string fields for recording_data before exiting the function. */
    ast_string_field_free_memory(&recording_data);
}

Referenced by mixmonitor_thread().

◆ destroy_monitor_audiohook()

static void destroy_monitor_audiohook ( struct mixmonitor * mixmonitor )

static

Definition at line 566 of file app_mixmonitor.c.

{
    if (mixmonitor->mixmonitor_ds) {
        ast_mutex_lock(&mixmonitor->mixmonitor_ds->lock);
        mixmonitor->mixmonitor_ds->audiohook = NULL;
        ast_mutex_unlock(&mixmonitor->mixmonitor_ds->lock);
    }
    /* kill the audiohook.*/
    ast_audiohook_lock(&mixmonitor->audiohook);
    ast_audiohook_detach(&mixmonitor->audiohook);
    ast_audiohook_unlock(&mixmonitor->audiohook);
    ast_audiohook_destroy(&mixmonitor->audiohook);
}

References ast_audiohook_destroy(), ast_audiohook_detach(), ast_audiohook_lock, ast_audiohook_unlock, ast_mutex_lock, ast_mutex_unlock, mixmonitor::audiohook, mixmonitor_ds::audiohook, mixmonitor_ds::lock, mixmonitor::mixmonitor_ds, and NULL.

Referenced by mixmonitor_thread().

◆ filename_parse()

static char * filename_parse	(	char *	filename,
		char *	buffer,
		size_t	len
	)

static

Definition at line 1195 of file app_mixmonitor.c.

{
    char *slash;
    char *ext;
 
    ast_assert(len > 0);
 
    if (ast_strlen_zero(filename)) {
        ast_log(LOG_WARNING, "No file name was provided for a file save option.\n");
        buffer[0] = 0;
        return buffer;
    }
 
    /* If we don't have an absolute path, make one */
    if (*filename != '/') {
        char *build = ast_alloca(strlen(ast_config_AST_MONITOR_DIR) + strlen(filename) + 3);
        sprintf(build, "%s/%s", ast_config_AST_MONITOR_DIR, filename);
        filename = build;
    }
 
    ast_copy_string(buffer, filename, len);
 
    /* If the provided filename has a .wav49 extension, we need to convert it to .WAV to
       match the behavior of build_filename in main/file.c. Otherwise MIXMONITOR_FILENAME
       ends up referring to a file that does not/will not exist */
    ext = strrchr(buffer, '.');
    if (ext && !strcmp(ext, ".wav49")) {
        /* Change to WAV - we know we have at least 6 writeable bytes where 'ext' points,
         * so this is safe */
        memcpy(ext, ".WAV", sizeof(".WAV"));
    }
 
    if ((slash = strrchr(filename, '/'))) {
        *slash = '\0';
    }
    ast_mkdir(filename, 0777);
 
    return buffer;
}

References ast_alloca, ast_assert, ast_config_AST_MONITOR_DIR, ast_copy_string(), ast_log, ast_mkdir(), ast_strlen_zero(), ext, len(), and LOG_WARNING.

Referenced by mixmonitor_exec().

◆ func_mixmonitor_read()

static int func_mixmonitor_read	(	struct ast_channel *	chan,
		const char *	cmd,
		char *	data,
		char *	buf,
		size_t	len
	)

static

Definition at line 1782 of file app_mixmonitor.c.

{
    struct ast_datastore *datastore;
    struct mixmonitor_ds *ds_data;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(id);
        AST_APP_ARG(key);
    );
 
    AST_STANDARD_APP_ARGS(args, data);
 
    if (ast_strlen_zero(args.id) || ast_strlen_zero(args.key)) {
        ast_log(LOG_WARNING, "Not enough arguments provided to %s. "
                "An ID and key must be provided\n", cmd);
        return -1;
    }
 
    ast_channel_lock(chan);
    datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, args.id);
    ast_channel_unlock(chan);
 
    if (!datastore) {
        ast_log(LOG_WARNING, "Could not find MixMonitor with ID %s\n", args.id);
        return -1;
    }
 
    ds_data = datastore->data;
 
    if (!strcasecmp(args.key, "filename")) {
        ast_copy_string(buf, ds_data->filename, len);
    } else {
        ast_log(LOG_WARNING, "Unrecognized %s option %s\n", cmd, args.key);
        return -1;
    }
    return 0;
}

References args, AST_APP_ARG, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_copy_string(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), buf, ast_datastore::data, mixmonitor_ds::filename, len(), LOG_WARNING, and mixmonitor_ds_info.

◆ handle_cli_mixmonitor()

static char * handle_cli_mixmonitor	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 1457 of file app_mixmonitor.c.

{
    struct ast_channel *chan;
    struct ast_datastore *datastore = NULL;
    struct mixmonitor_ds *mixmonitor_ds = NULL;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "mixmonitor {start|stop|list}";
        e->usage =
            "Usage: mixmonitor start <chan_name> [args]\n"
            "         The optional arguments are passed to the MixMonitor application.\n"
            "       mixmonitor stop <chan_name> [args]\n"
            "         The optional arguments are passed to the StopMixMonitor application.\n"
            "       mixmonitor list <chan_name>\n";
        return NULL;
    case CLI_GENERATE:
        return ast_complete_channels(a->line, a->word, a->pos, a->n, 2);
    }
 
    if (a->argc < 3) {
        return CLI_SHOWUSAGE;
    }
 
    if (!(chan = ast_channel_get_by_name_prefix(a->argv[2], strlen(a->argv[2])))) {
        ast_cli(a->fd, "No channel matching '%s' found.\n", a->argv[2]);
        /* Technically this is a failure, but we don't want 2 errors printing out */
        return CLI_SUCCESS;
    }
 
    if (!strcasecmp(a->argv[1], "start")) {
        mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
    } else if (!strcasecmp(a->argv[1], "stop")){
        stop_mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
    } else if (!strcasecmp(a->argv[1], "list")) {
        ast_cli(a->fd, "MixMonitor ID\tFile\tReceive File\tTransmit File\n");
        ast_cli(a->fd, "=========================================================================\n");
        ast_channel_lock(chan);
        AST_LIST_TRAVERSE(ast_channel_datastores(chan), datastore, entry) {
            if (datastore->info == &mixmonitor_ds_info) {
                char *filename = "";
                char *filename_read = "";
                char *filename_write = "";
 
                mixmonitor_ds = datastore->data;
                if (mixmonitor_ds->fs) {
                    filename = mixmonitor_ds->fs->filename;
                }
                if (mixmonitor_ds->fs_read) {
                    filename_read = mixmonitor_ds->fs_read->filename;
                }
                if (mixmonitor_ds->fs_write) {
                    filename_write = mixmonitor_ds->fs_write->filename;
                }
                ast_cli(a->fd, "%p\t%s\t%s\t%s\n", mixmonitor_ds, filename, filename_read, filename_write);
            }
        }
        ast_channel_unlock(chan);
    } else {
        chan = ast_channel_unref(chan);
        return CLI_SHOWUSAGE;
    }
 
    chan = ast_channel_unref(chan);
 
    return CLI_SUCCESS;
}

References a, ast_channel_datastores(), ast_channel_get_by_name_prefix(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_cli(), ast_complete_channels(), AST_LIST_TRAVERSE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_datastore::data, mixmonitor_ds::filename, ast_filestream::filename, mixmonitor_ds::fs, mixmonitor_ds::fs_read, mixmonitor_ds::fs_write, ast_datastore::info, mixmonitor_ds_info, mixmonitor_exec(), NULL, stop_mixmonitor_exec(), and ast_cli_entry::usage.

◆ launch_monitor_thread()

static int launch_monitor_thread	(	struct ast_channel *	chan,
		const char *	filename,
		unsigned int	flags,
		int	readvol,
		int	writevol,
		const char *	post_process,
		const char *	filename_write,
		char *	filename_read,
		const char *	uid_channel_var,
		const char *	recipients,
		const char *	beep_id
	)

static

Definition at line 1037 of file app_mixmonitor.c.

{
    pthread_t thread;
    struct mixmonitor *mixmonitor;
    char postprocess2[1024] = "";
    char *datastore_id = NULL;
 
    postprocess2[0] = 0;
    /* If a post process system command is given attach it to the structure */
    if (!ast_strlen_zero(post_process)) {
        char *p1, *p2;
 
        p1 = ast_strdupa(post_process);
        for (p2 = p1; *p2; p2++) {
            if (*p2 == '^' && *(p2+1) == '{') {
                *p2 = '$';
            }
        }
        ast_channel_lock(chan);
        pbx_substitute_variables_helper(chan, p1, postprocess2, sizeof(postprocess2) - 1);
        ast_channel_unlock(chan);
    }
 
    /* Pre-allocate mixmonitor structure and spy */
    if (!(mixmonitor = ast_calloc(1, sizeof(*mixmonitor)))) {
        return -1;
    }
 
    /* Now that the struct has been calloced, go ahead and initialize the string fields. */
    if (ast_string_field_init(mixmonitor, 512)) {
        mixmonitor_free(mixmonitor);
        return -1;
    }
 
    /* Setup the actual spy before creating our thread */
    if (ast_audiohook_init(&mixmonitor->audiohook, AST_AUDIOHOOK_TYPE_SPY, mixmonitor_spy_type, 0)) {
        mixmonitor_free(mixmonitor);
        return -1;
    }
 
    /* Copy over flags and channel name */
    mixmonitor->flags = flags;
    if (!(mixmonitor->autochan = ast_autochan_setup(chan))) {
        mixmonitor_free(mixmonitor);
        return -1;
    }
 
    if (!ast_strlen_zero(filename)) {
        mixmonitor->filename = ast_strdup(filename);
    }
 
    if (!ast_strlen_zero(filename_write)) {
        mixmonitor->filename_write = ast_strdup(filename_write);
    }
 
    if (!ast_strlen_zero(filename_read)) {
        mixmonitor->filename_read = ast_strdup(filename_read);
    }
 
    if (setup_mixmonitor_ds(mixmonitor, chan, &datastore_id, beep_id)) {
        ast_autochan_destroy(mixmonitor->autochan);
        mixmonitor_free(mixmonitor);
        ast_free(datastore_id);
        return -1;
    }
 
    if (!ast_strlen_zero(uid_channel_var)) {
        if (datastore_id) {
            pbx_builtin_setvar_helper(chan, uid_channel_var, datastore_id);
        }
    }
 
    mixmonitor->name = ast_strdup(ast_channel_name(chan));
 
    if (!ast_strlen_zero(postprocess2)) {
        mixmonitor->post_process = ast_strdup(postprocess2);
    }
 
    if (!ast_strlen_zero(recipients)) {
        char callerid[256];
 
        ast_channel_lock(chan);
 
        /* We use the connected line of the invoking channel for caller ID,
         * unless we've been told to use the Caller ID.
         * The initial use for this relied on Connected Line to get the
         * actual number for recording with Digium phones,
         * but in generic use the Caller ID is likely what people want.
         */
 
        if (ast_test_flag(mixmonitor, MUXFLAG_REAL_CALLERID)) {
            struct ast_party_caller *caller;
            caller = ast_channel_caller(chan);
            ast_debug(3, "Caller ID = %d - %s : %d - %s\n", caller->id.name.valid,
                caller->id.name.str, caller->id.number.valid,
                caller->id.number.str);
            ast_callerid_merge(callerid, sizeof(callerid),
                S_COR(caller->id.name.valid, caller->id.name.str, NULL),
                S_COR(caller->id.number.valid, caller->id.number.str, NULL),
                "Unknown");
        } else {
            struct ast_party_connected_line *connected;
            connected = ast_channel_connected(chan);
            ast_debug(3, "Connected Line CID = %d - %s : %d - %s\n", connected->id.name.valid,
                connected->id.name.str, connected->id.number.valid,
                connected->id.number.str);
            ast_callerid_merge(callerid, sizeof(callerid),
                S_COR(connected->id.name.valid, connected->id.name.str, NULL),
                S_COR(connected->id.number.valid, connected->id.number.str, NULL),
                "Unknown");
        }
 
        ast_string_field_set(mixmonitor, call_context, ast_channel_context(chan));
        ast_string_field_set(mixmonitor, call_extension, ast_channel_exten(chan));
        ast_string_field_set(mixmonitor, call_callerchan, ast_channel_name(chan));
        ast_string_field_set(mixmonitor, call_callerid, callerid);
        mixmonitor->call_priority = ast_channel_priority(chan);
 
        ast_channel_unlock(chan);
 
        add_vm_recipients_from_string(mixmonitor, recipients);
    }
 
    ast_set_flag(&mixmonitor->audiohook, AST_AUDIOHOOK_TRIGGER_SYNC);
    if (!ast_test_flag(mixmonitor, MUXFLAG_NO_RWSYNC)) {
        ast_set_flag(&mixmonitor->audiohook, AST_AUDIOHOOK_SUBSTITUTE_SILENCE);
    }
 
    if (readvol)
        mixmonitor->audiohook.options.read_volume = readvol;
    if (writevol)
        mixmonitor->audiohook.options.write_volume = writevol;
 
    if (startmon(chan, &mixmonitor->audiohook)) {
        ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
            mixmonitor_spy_type, ast_channel_name(chan));
        mixmonitor_ds_remove_and_free(chan, datastore_id);
        ast_free(datastore_id);
        ast_autochan_destroy(mixmonitor->autochan);
        ast_audiohook_destroy(&mixmonitor->audiohook);
        mixmonitor_free(mixmonitor);
        return -1;
    }
 
    ast_free(datastore_id);
 
    /* reference be released at mixmonitor destruction */
    mixmonitor->callid = ast_read_threadstorage_callid();
 
    return ast_pthread_create_detached_background(&thread, NULL, mixmonitor_thread, mixmonitor);
}

References add_vm_recipients_from_string(), ast_audiohook_destroy(), ast_audiohook_init(), AST_AUDIOHOOK_SUBSTITUTE_SILENCE, AST_AUDIOHOOK_TRIGGER_SYNC, AST_AUDIOHOOK_TYPE_SPY, ast_autochan_destroy(), ast_autochan_setup(), ast_callerid_merge(), ast_calloc, ast_channel_caller(), ast_channel_connected(), ast_channel_context(), ast_channel_exten(), ast_channel_lock, ast_channel_name(), ast_channel_priority(), ast_channel_unlock, ast_debug, ast_free, ast_log, ast_pthread_create_detached_background, ast_read_threadstorage_callid(), ast_set_flag, ast_strdup, ast_strdupa, ast_string_field_init, ast_string_field_set, ast_strlen_zero(), ast_test_flag, mixmonitor::audiohook, mixmonitor::autochan, mixmonitor::call_priority, mixmonitor::callid, connected, mixmonitor::filename, mixmonitor::filename_read, mixmonitor::filename_write, mixmonitor::flags, ast_party_caller::id, LOG_WARNING, mixmonitor_ds_remove_and_free(), mixmonitor_free(), mixmonitor_spy_type, mixmonitor_thread(), MUXFLAG_NO_RWSYNC, MUXFLAG_REAL_CALLERID, mixmonitor::name, ast_party_id::name, NULL, ast_party_id::number, ast_audiohook::options, pbx_builtin_setvar_helper(), pbx_substitute_variables_helper(), mixmonitor::post_process, ast_audiohook_options::read_volume, S_COR, setup_mixmonitor_ds(), startmon(), ast_party_name::str, ast_party_number::str, thread, ast_party_name::valid, ast_party_number::valid, and ast_audiohook_options::write_volume.

Referenced by mixmonitor_exec().

◆ load_module()

static int load_module ( void )

static

Definition at line 1860 of file app_mixmonitor.c.

{
    int res;
 
    ast_cli_register_multiple(cli_mixmonitor, ARRAY_LEN(cli_mixmonitor));
    res = ast_register_application_xml(app, mixmonitor_exec);
    res |= ast_register_application_xml(stop_app, stop_mixmonitor_exec);
    res |= ast_manager_register_xml("MixMonitorMute", EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL, manager_mute_mixmonitor);
    res |= ast_manager_register_xml("MixMonitor", EVENT_FLAG_SYSTEM, manager_mixmonitor);
    res |= ast_manager_register_xml("StopMixMonitor", EVENT_FLAG_SYSTEM | EVENT_FLAG_CALL, manager_stop_mixmonitor);
    res |= ast_custom_function_register(&mixmonitor_function);
    res |= set_mixmonitor_methods();
 
    return res;
}

References app, ARRAY_LEN, ast_cli_register_multiple, ast_custom_function_register, ast_manager_register_xml, ast_register_application_xml, cli_mixmonitor, EVENT_FLAG_CALL, EVENT_FLAG_SYSTEM, manager_mixmonitor(), manager_mute_mixmonitor(), manager_stop_mixmonitor(), mixmonitor_exec(), mixmonitor_function, set_mixmonitor_methods(), ast_mixmonitor_methods::start, stop_app, and stop_mixmonitor_exec().

◆ manager_mixmonitor()

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

static

Definition at line 1678 of file app_mixmonitor.c.

{
    struct ast_channel *c;
    const char *name = astman_get_header(m, "Channel");
    const char *id = astman_get_header(m, "ActionID");
    const char *file = astman_get_header(m, "File");
    const char *options = astman_get_header(m, "Options");
    const char *command = astman_get_header(m, "Command");
    char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
    struct ast_flags flags = { 0 };
    char *uid_channel_var = NULL;
    const char *mixmonitor_id = NULL;
    int res;
    char args[PATH_MAX];
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return AMI_SUCCESS;
    }
 
    c = ast_channel_get_by_name(name);
    if (!c) {
        astman_send_error(s, m, "No such channel");
        return AMI_SUCCESS;
    }
 
    if (!ast_strlen_zero(options)) {
        ast_app_parse_options(mixmonitor_opts, &flags, opts, ast_strdupa(options));
    }
 
    snprintf(args, sizeof(args), "%s,%s,%s", file, options, command);
 
    res = mixmonitor_exec(c, args);
 
    if (ast_test_flag(&flags, MUXFLAG_UID)) {
        uid_channel_var = opts[OPT_ARG_UID];
        ast_channel_lock(c);
        mixmonitor_id = pbx_builtin_getvar_helper(c, uid_channel_var);
        mixmonitor_id = ast_strdupa(S_OR(mixmonitor_id, ""));
        ast_channel_unlock(c);
    }
 
    if (res) {
        ast_channel_unref(c);
        astman_send_error(s, m, "Could not start monitoring channel");
        return AMI_SUCCESS;
    }
 
    astman_append(s, "Response: Success\r\n");
 
    if (!ast_strlen_zero(id)) {
        astman_append(s, "ActionID: %s\r\n", id);
    }
 
    if (!ast_strlen_zero(mixmonitor_id)) {
        astman_append(s, "MixMonitorID: %s\r\n", mixmonitor_id);
    }
 
    astman_append(s, "\r\n");
 
    ast_channel_unref(c);
 
    return AMI_SUCCESS;
}

References AMI_SUCCESS, args, ast_app_parse_options(), ast_channel_get_by_name(), ast_channel_lock, ast_channel_unlock, ast_channel_unref, ast_strdupa, ast_strlen_zero(), ast_test_flag, astman_append(), astman_get_header(), astman_send_error(), c, ast_flags::flags, mixmonitor_exec(), mixmonitor_opts, MUXFLAG_UID, name, NULL, OPT_ARG_ARRAY_SIZE, OPT_ARG_UID, options, PATH_MAX, pbx_builtin_getvar_helper(), and S_OR.

Referenced by load_module().

◆ manager_mute_mixmonitor()

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

static

Mute / unmute a MixMonitor channel.

Definition at line 1570 of file app_mixmonitor.c.

{
    struct ast_channel *c;
    const char *name = astman_get_header(m, "Channel");
    const char *id = astman_get_header(m, "ActionID");
    const char *state = astman_get_header(m, "State");
    const char *direction = astman_get_header(m,"Direction");
    const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
    int clearmute = 1, mutedcount = 0;
    enum ast_audiohook_flags flag;
    RAII_VAR(struct stasis_message *, stasis_message, NULL, ao2_cleanup);
    RAII_VAR(struct ast_json *, stasis_message_blob, NULL, ast_json_unref);
 
    if (ast_strlen_zero(direction)) {
        astman_send_error(s, m, "No direction specified. Must be read, write or both");
        return AMI_SUCCESS;
    }
 
    if (!strcasecmp(direction, "read")) {
        flag = AST_AUDIOHOOK_MUTE_READ;
    } else  if (!strcasecmp(direction, "write")) {
        flag = AST_AUDIOHOOK_MUTE_WRITE;
    } else  if (!strcasecmp(direction, "both")) {
        flag = AST_AUDIOHOOK_MUTE_READ | AST_AUDIOHOOK_MUTE_WRITE;
    } else {
        astman_send_error(s, m, "Invalid direction specified. Must be read, write or both");
        return AMI_SUCCESS;
    }
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return AMI_SUCCESS;
    }
 
    if (ast_strlen_zero(state)) {
        astman_send_error(s, m, "No state specified");
        return AMI_SUCCESS;
    }
 
    clearmute = ast_false(state);
 
    c = ast_channel_get_by_name(name);
    if (!c) {
        astman_send_error(s, m, "No such channel");
        return AMI_SUCCESS;
    }
 
    if (ast_strlen_zero(mixmonitor_id)) {
        mutedcount = ast_audiohook_set_mute_all(c, mixmonitor_spy_type, flag, clearmute);
        if (mutedcount < 0) {
            ast_channel_unref(c);
            astman_send_error(s, m, "Cannot set mute flag");
            return AMI_SUCCESS;
        }
    } else {
        if (mute_mixmonitor_instance(c, mixmonitor_id, flag, clearmute)) {
            ast_channel_unref(c);
            astman_send_error(s, m, "Cannot set mute flag");
            return AMI_SUCCESS;
        }
        mutedcount = 1;
    }
 
 
    stasis_message_blob = ast_json_pack("{s: s, s: b, s: s, s: i}",
        "direction", direction,
        "state", ast_true(state),
        "mixmonitorid", mixmonitor_id,
        "count", mutedcount);
 
    stasis_message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(c),
        ast_channel_mixmonitor_mute_type(), stasis_message_blob);
 
    if (stasis_message) {
        stasis_publish(ast_channel_topic(c), stasis_message);
    }
 
    astman_append(s, "Response: Success\r\n");
 
    if (!ast_strlen_zero(id)) {
        astman_append(s, "ActionID: %s\r\n", id);
    }
 
    astman_append(s, "\r\n");
 
    ast_channel_unref(c);
 
    return AMI_SUCCESS;
}

References AMI_SUCCESS, ao2_cleanup, AST_AUDIOHOOK_MUTE_READ, AST_AUDIOHOOK_MUTE_WRITE, ast_audiohook_set_mute_all(), ast_channel_blob_create_from_cache(), ast_channel_get_by_name(), ast_channel_mixmonitor_mute_type(), ast_channel_topic(), ast_channel_uniqueid(), ast_channel_unref, ast_false(), ast_json_pack(), ast_json_unref(), ast_strlen_zero(), ast_true(), astman_append(), astman_get_header(), astman_send_error(), c, mixmonitor_spy_type, mute_mixmonitor_instance(), name, NULL, RAII_VAR, and stasis_publish().

Referenced by load_module().

◆ manager_stop_mixmonitor()

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

static

Definition at line 1743 of file app_mixmonitor.c.

{
    struct ast_channel *c;
    const char *name = astman_get_header(m, "Channel");
    const char *id = astman_get_header(m, "ActionID");
    const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
    int res;
 
    if (ast_strlen_zero(name)) {
        astman_send_error(s, m, "No channel specified");
        return AMI_SUCCESS;
    }
 
    c = ast_channel_get_by_name(name);
    if (!c) {
        astman_send_error(s, m, "No such channel");
        return AMI_SUCCESS;
    }
 
    res = stop_mixmonitor_full(c, mixmonitor_id);
    if (res) {
        ast_channel_unref(c);
        astman_send_error(s, m, "Could not stop monitoring channel");
        return AMI_SUCCESS;
    }
 
    astman_append(s, "Response: Success\r\n");
 
    if (!ast_strlen_zero(id)) {
        astman_append(s, "ActionID: %s\r\n", id);
    }
 
    astman_append(s, "\r\n");
 
    ast_channel_unref(c);
 
    return AMI_SUCCESS;
}

References AMI_SUCCESS, ast_channel_get_by_name(), ast_channel_unref, ast_strlen_zero(), astman_append(), astman_get_header(), astman_send_error(), c, name, and stop_mixmonitor_full().

Referenced by load_module().

◆ mixmonitor_autochan_is_bridged()

static int mixmonitor_autochan_is_bridged ( struct ast_autochan * autochan )

static

Definition at line 750 of file app_mixmonitor.c.

{
    int is_bridged;
 
    ast_autochan_channel_lock(autochan);
    is_bridged = ast_channel_is_bridged(autochan->chan);
    ast_autochan_channel_unlock(autochan);
    return is_bridged;
}

References ast_autochan_channel_lock, ast_autochan_channel_unlock, ast_channel_is_bridged(), and ast_autochan::chan.

Referenced by mixmonitor_thread().

◆ mixmonitor_ds_close_fs()

static void mixmonitor_ds_close_fs ( struct mixmonitor_ds * mixmonitor_ds )

static

Definition at line 518 of file app_mixmonitor.c.

{
    unsigned char quitting = 0;
 
    if (mixmonitor_ds->fs) {
        quitting = 1;
        ast_closestream(mixmonitor_ds->fs);
        mixmonitor_ds->fs = NULL;
        ast_verb(2, "MixMonitor close filestream (mixed)\n");
    }
 
    if (mixmonitor_ds->fs_read) {
        quitting = 1;
        ast_closestream(mixmonitor_ds->fs_read);
        mixmonitor_ds->fs_read = NULL;
        ast_verb(2, "MixMonitor close filestream (read)\n");
    }
 
    if (mixmonitor_ds->fs_write) {
        quitting = 1;
        ast_closestream(mixmonitor_ds->fs_write);
        mixmonitor_ds->fs_write = NULL;
        ast_verb(2, "MixMonitor close filestream (write)\n");
    }
 
    if (quitting) {
        mixmonitor_ds->fs_quit = 1;
    }
}

References ast_closestream(), ast_verb, mixmonitor_ds::fs, mixmonitor_ds::fs_quit, mixmonitor_ds::fs_read, mixmonitor_ds::fs_write, and NULL.

Referenced by mixmonitor_thread(), and stop_mixmonitor_full().

◆ mixmonitor_ds_destroy()

static void mixmonitor_ds_destroy ( void * data )

static

Definition at line 548 of file app_mixmonitor.c.

{
    struct mixmonitor_ds *mixmonitor_ds = data;
 
    ast_mutex_lock(&mixmonitor_ds->lock);
    mixmonitor_ds->audiohook = NULL;
    mixmonitor_ds->destruction_ok = 1;
    ast_free(mixmonitor_ds->filename);
    ast_free(mixmonitor_ds->beep_id);
    ast_cond_signal(&mixmonitor_ds->destruction_condition);
    ast_mutex_unlock(&mixmonitor_ds->lock);
}

References ast_cond_signal, ast_free, ast_mutex_lock, ast_mutex_unlock, mixmonitor_ds::audiohook, mixmonitor_ds::beep_id, mixmonitor_ds::destruction_condition, mixmonitor_ds::destruction_ok, mixmonitor_ds::filename, mixmonitor_ds::lock, and NULL.

◆ mixmonitor_ds_remove_and_free()

static void mixmonitor_ds_remove_and_free	(	struct ast_channel *	chan,
		const char *	datastore_id
	)

static

Definition at line 1019 of file app_mixmonitor.c.

{
    struct ast_datastore *datastore;
 
    ast_channel_lock(chan);
 
    datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, datastore_id);
 
    /*
     * Currently the one place this function is called from guarantees a
     * datastore is present, thus return checks can be avoided here.
     */
    ast_channel_datastore_remove(chan, datastore);
    ast_datastore_free(datastore);
 
    ast_channel_unlock(chan);
}

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_unlock, ast_datastore_free(), and mixmonitor_ds_info.

Referenced by launch_monitor_thread().

◆ mixmonitor_exec()

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

static

Definition at line 1235 of file app_mixmonitor.c.

{
    int x, readvol = 0, writevol = 0;
    char *filename_read = NULL;
    char *filename_write = NULL;
    char filename_buffer[1024] = "";
    char *uid_channel_var = NULL;
    char beep_id[64] = "";
 
    struct ast_flags flags = { 0 };
    char *recipients = NULL;
    char *parse;
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(filename);
        AST_APP_ARG(options);
        AST_APP_ARG(post_process);
    );
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "MixMonitor requires an argument (filename or ,t(filename) and/or r(filename)\n");
        return -1;
    }
 
    parse = ast_strdupa(data);
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (args.options) {
        char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
 
        ast_app_parse_options(mixmonitor_opts, &flags, opts, args.options);
 
        if (ast_test_flag(&flags, MUXFLAG_DEPRECATED_RWSYNC)) {
            ast_log(LOG_NOTICE, "The synchronization behavior enabled by the 'S' option is now the default"
                " and does not need to be specified.\n");
        }
 
        if (ast_test_flag(&flags, MUXFLAG_READVOLUME)) {
            if (ast_strlen_zero(opts[OPT_ARG_READVOLUME])) {
                ast_log(LOG_WARNING, "No volume level was provided for the heard volume ('v') option.\n");
            } else if ((sscanf(opts[OPT_ARG_READVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
                ast_log(LOG_NOTICE, "Heard volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_READVOLUME]);
            } else {
                readvol = get_volfactor(x);
            }
        }
 
        if (ast_test_flag(&flags, MUXFLAG_WRITEVOLUME)) {
            if (ast_strlen_zero(opts[OPT_ARG_WRITEVOLUME])) {
                ast_log(LOG_WARNING, "No volume level was provided for the spoken volume ('V') option.\n");
            } else if ((sscanf(opts[OPT_ARG_WRITEVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
                ast_log(LOG_NOTICE, "Spoken volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_WRITEVOLUME]);
            } else {
                writevol = get_volfactor(x);
            }
        }
 
        if (ast_test_flag(&flags, MUXFLAG_VOLUME)) {
            if (ast_strlen_zero(opts[OPT_ARG_VOLUME])) {
                ast_log(LOG_WARNING, "No volume level was provided for the combined volume ('W') option.\n");
            } else if ((sscanf(opts[OPT_ARG_VOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
                ast_log(LOG_NOTICE, "Combined volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_VOLUME]);
            } else {
                readvol = writevol = get_volfactor(x);
            }
        }
 
        if (ast_test_flag(&flags, MUXFLAG_VMRECIPIENTS)) {
            if (ast_strlen_zero(opts[OPT_ARG_VMRECIPIENTS])) {
                ast_log(LOG_WARNING, "No voicemail recipients were specified for the vm copy ('m') option.\n");
            } else {
                recipients = ast_strdupa(opts[OPT_ARG_VMRECIPIENTS]);
            }
        }
 
        if (ast_test_flag(&flags, MUXFLAG_WRITE)) {
            filename_write = ast_strdupa(filename_parse(opts[OPT_ARG_WRITENAME], filename_buffer, sizeof(filename_buffer)));
        }
 
        if (ast_test_flag(&flags, MUXFLAG_READ)) {
            filename_read = ast_strdupa(filename_parse(opts[OPT_ARG_READNAME], filename_buffer, sizeof(filename_buffer)));
        }
 
        if (ast_test_flag(&flags, MUXFLAG_UID)) {
            uid_channel_var = opts[OPT_ARG_UID];
        }
 
        if (ast_test_flag(&flags, MUXFLAG_BEEP)) {
            const char *interval_str = S_OR(opts[OPT_ARG_BEEP_INTERVAL], "15");
            unsigned int interval = 15;
 
            if (sscanf(interval_str, "%30u", &interval) != 1) {
                ast_log(LOG_WARNING, "Invalid interval '%s' for periodic beep. Using default of %u\n",
                        interval_str, interval);
            }
 
            if (ast_beep_start(chan, interval, beep_id, sizeof(beep_id))) {
                ast_log(LOG_WARNING, "Unable to enable periodic beep, please ensure func_periodic_hook is loaded.\n");
                return -1;
            }
        }
    }
    /* If there are no file writing arguments/options for the mix monitor, send a warning message and return -1 */
 
    if (!ast_test_flag(&flags, MUXFLAG_WRITE) && !ast_test_flag(&flags, MUXFLAG_READ) && ast_strlen_zero(args.filename)) {
        ast_log(LOG_WARNING, "MixMonitor requires an argument (filename)\n");
        return -1;
    }
 
    /* If filename exists, try to create directories for it */
    if (!(ast_strlen_zero(args.filename))) {
        args.filename = ast_strdupa(filename_parse(args.filename, filename_buffer, sizeof(filename_buffer)));
    }
 
    pbx_builtin_setvar_helper(chan, "MIXMONITOR_FILENAME", args.filename);
 
    /* If launch_monitor_thread works, the module reference must not be released until it is finished. */
    ast_module_ref(ast_module_info->self);
    if (launch_monitor_thread(chan,
            args.filename,
            flags.flags,
            readvol,
            writevol,
            args.post_process,
            filename_write,
            filename_read,
            uid_channel_var,
            recipients,
            beep_id)) {
        ast_module_unref(ast_module_info->self);
    }
 
    message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
        ast_channel_mixmonitor_start_type(), NULL);
    if (message) {
        stasis_publish(ast_channel_topic(chan), message);
    }
 
    return 0;
}

References ao2_cleanup, args, AST_APP_ARG, ast_app_parse_options(), ast_beep_start(), ast_channel_blob_create_from_cache(), ast_channel_mixmonitor_start_type(), ast_channel_topic(), ast_channel_uniqueid(), AST_DECLARE_APP_ARGS, ast_log, ast_module_ref, ast_module_unref, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_test_flag, filename_parse(), ast_flags::flags, ast_channel::flags, get_volfactor, launch_monitor_thread(), LOG_NOTICE, LOG_WARNING, mixmonitor_opts, MUXFLAG_BEEP, MUXFLAG_DEPRECATED_RWSYNC, MUXFLAG_READ, MUXFLAG_READVOLUME, MUXFLAG_UID, MUXFLAG_VMRECIPIENTS, MUXFLAG_VOLUME, MUXFLAG_WRITE, MUXFLAG_WRITEVOLUME, NULL, OPT_ARG_ARRAY_SIZE, OPT_ARG_BEEP_INTERVAL, OPT_ARG_READNAME, OPT_ARG_READVOLUME, OPT_ARG_UID, OPT_ARG_VMRECIPIENTS, OPT_ARG_VOLUME, OPT_ARG_WRITENAME, OPT_ARG_WRITEVOLUME, options, pbx_builtin_setvar_helper(), RAII_VAR, S_OR, ast_module_info::self, and stasis_publish().

Referenced by handle_cli_mixmonitor(), load_module(), manager_mixmonitor(), and start_mixmonitor_callback().

◆ mixmonitor_free()

static void mixmonitor_free ( struct mixmonitor * mixmonitor )

static

Definition at line 655 of file app_mixmonitor.c.

{
    if (mixmonitor) {
        if (mixmonitor->mixmonitor_ds) {
            ast_mutex_destroy(&mixmonitor->mixmonitor_ds->lock);
            ast_cond_destroy(&mixmonitor->mixmonitor_ds->destruction_condition);
            ast_free(mixmonitor->mixmonitor_ds);
        }
 
        ast_free(mixmonitor->name);
        ast_free(mixmonitor->post_process);
        ast_free(mixmonitor->filename);
        ast_free(mixmonitor->filename_write);
        ast_free(mixmonitor->filename_read);
 
        /* Free everything in the recipient list */
        clear_mixmonitor_recipient_list(mixmonitor);
 
        /* clean stringfields */
        ast_string_field_free_memory(mixmonitor);
 
        ast_free(mixmonitor);
    }
}

References ast_cond_destroy, ast_free, ast_mutex_destroy, ast_string_field_free_memory, clear_mixmonitor_recipient_list(), mixmonitor_ds::destruction_condition, mixmonitor::filename, mixmonitor::filename_read, mixmonitor::filename_write, mixmonitor_ds::lock, mixmonitor::mixmonitor_ds, mixmonitor::name, and mixmonitor::post_process.

Referenced by launch_monitor_thread(), and mixmonitor_thread().

◆ mixmonitor_save_prep()

static void mixmonitor_save_prep	(	struct mixmonitor *	mixmonitor,
		char *	filename,
		struct ast_filestream **	fs,
		unsigned int *	oflags,
		int *	errflag,
		char **	ext
	)

static

Definition at line 721 of file app_mixmonitor.c.

{
    /* Initialize the file if not already done so */
    char *last_slash = NULL;
    if (!ast_strlen_zero(filename)) {
        if (!*fs && !*errflag && !mixmonitor->mixmonitor_ds->fs_quit) {
            *oflags = O_CREAT | O_WRONLY;
            *oflags |= ast_test_flag(mixmonitor, MUXFLAG_APPEND) ? O_APPEND : O_TRUNC;
 
            last_slash = strrchr(filename, '/');
 
            if ((*ext = strrchr(filename, '.')) && (*ext > last_slash)) {
                **ext = '\0';
                *ext = *ext + 1;
            } else {
                *ext = "raw";
            }
 
            if (!(*fs = ast_writefile(filename, *ext, NULL, *oflags, 0, 0666))) {
                ast_log(LOG_ERROR, "Cannot open %s.%s\n", filename, *ext);
                *errflag = 1;
            } else {
                struct ast_filestream *tmp = *fs;
                mixmonitor->mixmonitor_ds->samp_rate = MAX(mixmonitor->mixmonitor_ds->samp_rate, ast_format_get_sample_rate(tmp->fmt->format));
            }
        }
    }
}

References ast_format_get_sample_rate(), ast_log, ast_strlen_zero(), ast_test_flag, ast_writefile(), ext, ast_filestream::fmt, ast_format_def::format, mixmonitor_ds::fs_quit, LOG_ERROR, MAX, mixmonitor::mixmonitor_ds, MUXFLAG_APPEND, NULL, and mixmonitor_ds::samp_rate.

Referenced by mixmonitor_thread().

◆ mixmonitor_thread()

static void * mixmonitor_thread ( void * obj )

static

Definition at line 760 of file app_mixmonitor.c.

{
    struct mixmonitor *mixmonitor = obj;
    char *fs_ext = "";
    char *fs_read_ext = "";
    char *fs_write_ext = "";
 
    struct ast_filestream **fs = NULL;
    struct ast_filestream **fs_read = NULL;
    struct ast_filestream **fs_write = NULL;
 
    unsigned int oflags;
    int errflag = 0;
    struct ast_format *format_slin;
 
    /* Keep callid association before any log messages */
    if (mixmonitor->callid) {
        ast_callid_threadassoc_add(mixmonitor->callid);
    }
 
    ast_verb(2, "Begin MixMonitor Recording %s\n", mixmonitor->name);
 
    fs = &mixmonitor->mixmonitor_ds->fs;
    fs_read = &mixmonitor->mixmonitor_ds->fs_read;
    fs_write = &mixmonitor->mixmonitor_ds->fs_write;
 
    ast_mutex_lock(&mixmonitor->mixmonitor_ds->lock);
    mixmonitor_save_prep(mixmonitor, mixmonitor->filename, fs, &oflags, &errflag, &fs_ext);
    mixmonitor_save_prep(mixmonitor, mixmonitor->filename_read, fs_read, &oflags, &errflag, &fs_read_ext);
    mixmonitor_save_prep(mixmonitor, mixmonitor->filename_write, fs_write, &oflags, &errflag, &fs_write_ext);
 
    format_slin = ast_format_cache_get_slin_by_rate(mixmonitor->mixmonitor_ds->samp_rate);
 
    ast_mutex_unlock(&mixmonitor->mixmonitor_ds->lock);
 
    /* The audiohook must enter and exit the loop locked */
    ast_audiohook_lock(&mixmonitor->audiohook);
    while (mixmonitor->audiohook.status == AST_AUDIOHOOK_STATUS_RUNNING && !mixmonitor->mixmonitor_ds->fs_quit) {
        struct ast_frame *fr = NULL;
        struct ast_frame *fr_read = NULL;
        struct ast_frame *fr_write = NULL;
 
        if (!(fr = ast_audiohook_read_frame_all(&mixmonitor->audiohook, SAMPLES_PER_FRAME, format_slin,
                        &fr_read, &fr_write))) {
            ast_audiohook_trigger_wait(&mixmonitor->audiohook);
 
            if (mixmonitor->audiohook.status != AST_AUDIOHOOK_STATUS_RUNNING) {
                break;
            }
            continue;
        }
 
        /* audiohook lock is not required for the next block.
         * Unlock it, but remember to lock it before looping or exiting */
        ast_audiohook_unlock(&mixmonitor->audiohook);
 
        if (!ast_test_flag(mixmonitor, MUXFLAG_BRIDGED)
            || mixmonitor_autochan_is_bridged(mixmonitor->autochan)) {
            ast_mutex_lock(&mixmonitor->mixmonitor_ds->lock);
 
            /* Write out the frame(s) */
            if ((*fs_read) && (fr_read)) {
                struct ast_frame *cur;
 
                for (cur = fr_read; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
                    ast_writestream(*fs_read, cur);
                }
            }
 
            if ((*fs_write) && (fr_write)) {
                struct ast_frame *cur;
 
                for (cur = fr_write; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
                    ast_writestream(*fs_write, cur);
                }
            }
 
            if (ast_test_flag(mixmonitor, MUXFLAG_INTERLEAVED)) {
                /* The 'D' option is set, so mix the frame as an interleaved dual channel frame */
                int i;
                short read_buf[SAMPLES_PER_FRAME];
                short write_buf[SAMPLES_PER_FRAME];
                short stereo_buf[SAMPLES_PER_FRAME * 2];
                struct ast_frame stereo_frame = {
                    .frametype = AST_FRAME_VOICE,
                    .datalen = sizeof(stereo_buf),
                    .samples = SAMPLES_PER_FRAME,
                };
 
                if (fr) {
                    ast_frame_free(fr, 0);
                    fr = NULL;
                }
 
                if (fr_read) {
                    memcpy(read_buf, fr_read->data.ptr, sizeof(read_buf));
                } else {
                    memset(read_buf, 0, sizeof(read_buf));
                }
 
                if (fr_write) {
                    memcpy(write_buf, fr_write->data.ptr, sizeof(write_buf));
                } else {
                    memset(write_buf, 0, sizeof(write_buf));
                }
 
                for (i = 0; i < SAMPLES_PER_FRAME; i++) {
                    stereo_buf[i * 2] = read_buf[i];
                    stereo_buf[i * 2 + 1] = write_buf[i];
                }
 
                stereo_frame.data.ptr = stereo_buf;
                stereo_frame.subclass.format = ast_format_cache_get_slin_by_rate(SAMPLES_PER_FRAME);
 
                fr = ast_frdup(&stereo_frame);
            }
 
            if ((*fs) && (fr)) {
                struct ast_frame *cur;
 
                for (cur = fr; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
                    ast_writestream(*fs, cur);
                }
            }
            ast_mutex_unlock(&mixmonitor->mixmonitor_ds->lock);
        }
        /* All done! free it. */
        if (fr) {
            ast_frame_free(fr, 0);
        }
        if (fr_read) {
            ast_frame_free(fr_read, 0);
        }
        if (fr_write) {
            ast_frame_free(fr_write, 0);
        }
 
        fr = NULL;
        fr_write = NULL;
        fr_read = NULL;
 
        ast_audiohook_lock(&mixmonitor->audiohook);
    }
 
    ast_audiohook_unlock(&mixmonitor->audiohook);
 
    if (ast_test_flag(mixmonitor, MUXFLAG_BEEP_STOP)) {
        ast_autochan_channel_lock(mixmonitor->autochan);
        ast_stream_and_wait(mixmonitor->autochan->chan, "beep", "");
        ast_autochan_channel_unlock(mixmonitor->autochan);
    }
 
    ast_autochan_destroy(mixmonitor->autochan);
 
    /* Datastore cleanup.  close the filestream and wait for ds destruction */
    ast_mutex_lock(&mixmonitor->mixmonitor_ds->lock);
    mixmonitor_ds_close_fs(mixmonitor->mixmonitor_ds);
    if (!mixmonitor->mixmonitor_ds->destruction_ok) {
        ast_cond_wait(&mixmonitor->mixmonitor_ds->destruction_condition, &mixmonitor->mixmonitor_ds->lock);
    }
    ast_mutex_unlock(&mixmonitor->mixmonitor_ds->lock);
 
    /* kill the audiohook */
    destroy_monitor_audiohook(mixmonitor);
 
    if (mixmonitor->post_process) {
        ast_verb(2, "Executing [%s]\n", mixmonitor->post_process);
        ast_safe_system(mixmonitor->post_process);
    }
 
    ast_verb(2, "End MixMonitor Recording %s\n", mixmonitor->name);
    ast_test_suite_event_notify("MIXMONITOR_END", "File: %s\r\n", mixmonitor->filename);
 
    if (!AST_LIST_EMPTY(&mixmonitor->recipient_list)) {
        if (ast_strlen_zero(fs_ext)) {
            ast_log(LOG_ERROR, "No file extension set for Mixmonitor %s. Skipping copy to voicemail.\n",
                mixmonitor -> name);
        } else {
            ast_verb(3, "Copying recordings for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
            copy_to_voicemail(mixmonitor, fs_ext, mixmonitor->filename);
        }
        if (!ast_strlen_zero(fs_read_ext)) {
            ast_verb(3, "Copying read recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
            copy_to_voicemail(mixmonitor, fs_read_ext, mixmonitor->filename_read);
        }
        if (!ast_strlen_zero(fs_write_ext)) {
            ast_verb(3, "Copying write recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
            copy_to_voicemail(mixmonitor, fs_write_ext, mixmonitor->filename_write);
        }
    } else {
        ast_debug(3, "No recipients to forward monitor to, moving on.\n");
    }
 
    if (ast_test_flag(mixmonitor, MUXFLAG_AUTO_DELETE)) {
        ast_debug(3, "Deleting our copies of recording files\n");
        if (!ast_strlen_zero(fs_ext)) {
            ast_filedelete(mixmonitor->filename, fs_ext);
        }
        if (!ast_strlen_zero(fs_read_ext)) {
            ast_filedelete(mixmonitor->filename_read, fs_ext);
        }
        if (!ast_strlen_zero(fs_write_ext)) {
            ast_filedelete(mixmonitor->filename_write, fs_ext);
        }
    }
 
    mixmonitor_free(mixmonitor);
 
    ast_module_unref(ast_module_info->self);
    return NULL;
}

References ast_audiohook_lock, ast_audiohook_read_frame_all(), AST_AUDIOHOOK_STATUS_RUNNING, ast_audiohook_trigger_wait(), ast_audiohook_unlock, ast_autochan_channel_lock, ast_autochan_channel_unlock, ast_autochan_destroy(), ast_callid_threadassoc_add(), ast_cond_wait, ast_debug, ast_filedelete(), ast_format_cache_get_slin_by_rate(), ast_frame_free(), AST_FRAME_VOICE, ast_frdup, AST_LIST_EMPTY, AST_LIST_NEXT, ast_log, ast_module_unref, ast_mutex_lock, ast_mutex_unlock, ast_safe_system(), ast_stream_and_wait(), ast_strlen_zero(), ast_test_flag, ast_test_suite_event_notify, ast_verb, ast_writestream(), mixmonitor::audiohook, mixmonitor::autochan, mixmonitor::callid, ast_autochan::chan, copy_to_voicemail(), ast_frame::data, destroy_monitor_audiohook(), mixmonitor_ds::destruction_condition, mixmonitor_ds::destruction_ok, mixmonitor::filename, mixmonitor::filename_read, mixmonitor::filename_write, ast_frame_subclass::format, ast_frame::frametype, mixmonitor_ds::fs, mixmonitor_ds::fs_quit, mixmonitor_ds::fs_read, mixmonitor_ds::fs_write, mixmonitor_ds::lock, LOG_ERROR, mixmonitor_autochan_is_bridged(), mixmonitor::mixmonitor_ds, mixmonitor_ds_close_fs(), mixmonitor_free(), mixmonitor_save_prep(), MUXFLAG_AUTO_DELETE, MUXFLAG_BEEP_STOP, MUXFLAG_BRIDGED, MUXFLAG_INTERLEAVED, name, mixmonitor::name, NULL, mixmonitor::post_process, ast_frame::ptr, mixmonitor::recipient_list, mixmonitor_ds::samp_rate, ast_frame::samples, SAMPLES_PER_FRAME, ast_module_info::self, ast_audiohook::status, ast_frame::subclass, and write_buf().

Referenced by launch_monitor_thread().

◆ mute_mixmonitor_instance()

static int mute_mixmonitor_instance	(	struct ast_channel *	chan,
		const char *	data,
		enum ast_audiohook_flags	flag,
		int	clearmute
	)

static

Mute / unmute an individual MixMonitor by id.

Definition at line 1526 of file app_mixmonitor.c.

{
    struct ast_datastore *datastore = NULL;
    char *parse = "";
    struct mixmonitor_ds *mixmonitor_ds;
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(mixmonid);
    );
 
    if (!ast_strlen_zero(data)) {
        parse = ast_strdupa(data);
    }
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    ast_channel_lock(chan);
 
    datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info,
        S_OR(args.mixmonid, NULL));
    if (!datastore) {
        ast_channel_unlock(chan);
        return -1;
    }
    mixmonitor_ds = datastore->data;
 
    ast_mutex_lock(&mixmonitor_ds->lock);
 
    if (mixmonitor_ds->audiohook) {
        if (clearmute) {
            ast_clear_flag(mixmonitor_ds->audiohook, flag);
        } else {
            ast_set_flag(mixmonitor_ds->audiohook, flag);
        }
    }
 
    ast_mutex_unlock(&mixmonitor_ds->lock);
    ast_channel_unlock(chan);
 
    return 0;
}

References args, AST_APP_ARG, ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_clear_flag, AST_DECLARE_APP_ARGS, ast_mutex_lock, ast_mutex_unlock, ast_set_flag, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), mixmonitor_ds::audiohook, ast_datastore::data, mixmonitor_ds::lock, mixmonitor_ds_info, NULL, and S_OR.

Referenced by manager_mute_mixmonitor().

◆ set_mixmonitor_methods()

static int set_mixmonitor_methods ( void )

static

Definition at line 1829 of file app_mixmonitor.c.

{
    struct ast_mixmonitor_methods mixmonitor_methods = {
        .start = start_mixmonitor_callback,
        .stop = stop_mixmonitor_callback,
    };
 
    return ast_set_mixmonitor_methods(&mixmonitor_methods);
}

References ast_set_mixmonitor_methods(), mixmonitor_methods, ast_mixmonitor_methods::start, start_mixmonitor_callback(), and stop_mixmonitor_callback().

Referenced by load_module().

◆ setup_mixmonitor_ds()

static int setup_mixmonitor_ds	(	struct mixmonitor *	mixmonitor,
		struct ast_channel *	chan,
		char **	datastore_id,
		const char *	beep_id
	)

static

Definition at line 972 of file app_mixmonitor.c.

{
    struct ast_datastore *datastore = NULL;
    struct mixmonitor_ds *mixmonitor_ds;
 
    if (!(mixmonitor_ds = ast_calloc(1, sizeof(*mixmonitor_ds)))) {
        return -1;
    }
 
    if (ast_asprintf(datastore_id, "%p", mixmonitor_ds) == -1) {
        ast_log(LOG_ERROR, "Failed to allocate memory for MixMonitor ID.\n");
        ast_free(mixmonitor_ds);
        return -1;
    }
 
    ast_mutex_init(&mixmonitor_ds->lock);
    ast_cond_init(&mixmonitor_ds->destruction_condition, NULL);
 
    if (!(datastore = ast_datastore_alloc(&mixmonitor_ds_info, *datastore_id))) {
        ast_mutex_destroy(&mixmonitor_ds->lock);
        ast_cond_destroy(&mixmonitor_ds->destruction_condition);
        ast_free(mixmonitor_ds);
        return -1;
    }
 
    if (ast_test_flag(mixmonitor, MUXFLAG_BEEP_START)) {
        ast_autochan_channel_lock(mixmonitor->autochan);
        ast_stream_and_wait(mixmonitor->autochan->chan, "beep", "");
        ast_autochan_channel_unlock(mixmonitor->autochan);
    }
 
    mixmonitor_ds->samp_rate = 8000;
    mixmonitor_ds->audiohook = &mixmonitor->audiohook;
    mixmonitor_ds->filename = ast_strdup(mixmonitor->filename);
    if (!ast_strlen_zero(beep_id)) {
        mixmonitor_ds->beep_id = ast_strdup(beep_id);
    }
    datastore->data = mixmonitor_ds;
 
    ast_channel_lock(chan);
    ast_channel_datastore_add(chan, datastore);
    ast_channel_unlock(chan);
 
    mixmonitor->mixmonitor_ds = mixmonitor_ds;
    return 0;
}

References ast_asprintf, ast_autochan_channel_lock, ast_autochan_channel_unlock, ast_calloc, ast_channel_datastore_add(), ast_channel_lock, ast_channel_unlock, ast_cond_destroy, ast_cond_init, ast_datastore_alloc, ast_free, ast_log, ast_mutex_destroy, ast_mutex_init, ast_strdup, ast_stream_and_wait(), ast_strlen_zero(), ast_test_flag, mixmonitor::audiohook, mixmonitor_ds::audiohook, mixmonitor::autochan, mixmonitor_ds::beep_id, ast_autochan::chan, ast_datastore::data, mixmonitor_ds::destruction_condition, mixmonitor::filename, mixmonitor_ds::filename, mixmonitor_ds::lock, LOG_ERROR, mixmonitor::mixmonitor_ds, mixmonitor_ds_info, MUXFLAG_BEEP_START, NULL, and mixmonitor_ds::samp_rate.

Referenced by launch_monitor_thread().

◆ start_mixmonitor_callback()

static int start_mixmonitor_callback	(	struct ast_channel *	chan,
		const char *	filename,
		const char *	options
	)

static

Definition at line 1660 of file app_mixmonitor.c.

{
    char args[PATH_MAX];
 
    if (ast_strlen_zero(options)) {
        snprintf(args, sizeof(args), "%s", filename);
    } else {
        snprintf(args, sizeof(args), "%s,%s", filename, options);
    }
 
    return mixmonitor_exec(chan, args);
}

References args, ast_strlen_zero(), mixmonitor_exec(), options, and PATH_MAX.

Referenced by set_mixmonitor_methods().

◆ startmon()

static int startmon	(	struct ast_channel *	chan,
		struct ast_audiohook *	audiohook
	)

static

Definition at line 580 of file app_mixmonitor.c.

{
    if (!chan) {
        return -1;
    }
 
    return ast_audiohook_attach(chan, audiohook);
}

References ast_audiohook_attach().

Referenced by launch_monitor_thread().

◆ stop_mixmonitor_callback()

static int stop_mixmonitor_callback	(	struct ast_channel *	chan,
		const char *	mixmonitor_id
	)

static

Definition at line 1673 of file app_mixmonitor.c.

{
    return stop_mixmonitor_full(chan, mixmonitor_id);
}

References stop_mixmonitor_full().

Referenced by set_mixmonitor_methods().

◆ stop_mixmonitor_exec()

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

static

Definition at line 1451 of file app_mixmonitor.c.

{
    stop_mixmonitor_full(chan, data);
    return 0;
}

References stop_mixmonitor_full().

Referenced by handle_cli_mixmonitor(), and load_module().

◆ stop_mixmonitor_full()

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

static

Definition at line 1377 of file app_mixmonitor.c.

{
    struct ast_datastore *datastore = NULL;
    char *parse = "";
    struct mixmonitor_ds *mixmonitor_ds;
    const char *beep_id = NULL;
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(mixmonid);
    );
 
    if (!ast_strlen_zero(data)) {
        parse = ast_strdupa(data);
    }
 
    AST_STANDARD_APP_ARGS(args, parse);
 
    ast_channel_lock(chan);
 
    datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info,
        S_OR(args.mixmonid, NULL));
    if (!datastore) {
        ast_channel_unlock(chan);
        return -1;
    }
    mixmonitor_ds = datastore->data;
 
    ast_mutex_lock(&mixmonitor_ds->lock);
 
    /* closing the filestream here guarantees the file is available to the dialplan
     * after calling StopMixMonitor */
    mixmonitor_ds_close_fs(mixmonitor_ds);
 
    /* The mixmonitor thread may be waiting on the audiohook trigger.
     * In order to exit from the mixmonitor loop before waiting on channel
     * destruction, poke the audiohook trigger. */
    if (mixmonitor_ds->audiohook) {
        if (mixmonitor_ds->audiohook->status != AST_AUDIOHOOK_STATUS_DONE) {
            ast_audiohook_update_status(mixmonitor_ds->audiohook, AST_AUDIOHOOK_STATUS_SHUTDOWN);
        }
        ast_audiohook_lock(mixmonitor_ds->audiohook);
        ast_cond_signal(&mixmonitor_ds->audiohook->trigger);
        ast_audiohook_unlock(mixmonitor_ds->audiohook);
        mixmonitor_ds->audiohook = NULL;
    }
 
    if (!ast_strlen_zero(mixmonitor_ds->beep_id)) {
        beep_id = ast_strdupa(mixmonitor_ds->beep_id);
    }
 
    ast_mutex_unlock(&mixmonitor_ds->lock);
 
    /* Remove the datastore so the monitor thread can exit */
    if (!ast_channel_datastore_remove(chan, datastore)) {
        ast_datastore_free(datastore);
    }
 
    ast_channel_unlock(chan);
 
    if (!ast_strlen_zero(beep_id)) {
        ast_beep_stop(chan, beep_id);
    }
 
    message = ast_channel_blob_create_from_cache(ast_channel_uniqueid(chan),
                                                 ast_channel_mixmonitor_stop_type(),
                                                 NULL);
    if (message) {
        stasis_publish(ast_channel_topic(chan), message);
    }
 
    return 0;
}

References ao2_cleanup, args, AST_APP_ARG, ast_audiohook_lock, AST_AUDIOHOOK_STATUS_DONE, AST_AUDIOHOOK_STATUS_SHUTDOWN, ast_audiohook_unlock, ast_audiohook_update_status(), ast_beep_stop(), ast_channel_blob_create_from_cache(), ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_mixmonitor_stop_type(), ast_channel_topic(), ast_channel_uniqueid(), ast_channel_unlock, ast_cond_signal, ast_datastore_free(), AST_DECLARE_APP_ARGS, ast_mutex_lock, ast_mutex_unlock, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), mixmonitor_ds::audiohook, mixmonitor_ds::beep_id, ast_datastore::data, mixmonitor_ds::lock, mixmonitor_ds_close_fs(), mixmonitor_ds_info, NULL, RAII_VAR, S_OR, stasis_publish(), ast_audiohook::status, and ast_audiohook::trigger.

Referenced by manager_stop_mixmonitor(), stop_mixmonitor_callback(), and stop_mixmonitor_exec().

◆ unload_module()

static int unload_module ( void )

static

Definition at line 1844 of file app_mixmonitor.c.

{
    int res;
 
    ast_cli_unregister_multiple(cli_mixmonitor, ARRAY_LEN(cli_mixmonitor));
    res = ast_unregister_application(stop_app);
    res |= ast_unregister_application(app);
    res |= ast_manager_unregister("MixMonitorMute");
    res |= ast_manager_unregister("MixMonitor");
    res |= ast_manager_unregister("StopMixMonitor");
    res |= ast_custom_function_unregister(&mixmonitor_function);
    res |= clear_mixmonitor_methods();
 
    return res;
}

References app, ARRAY_LEN, ast_cli_unregister_multiple(), ast_custom_function_unregister(), ast_manager_unregister(), ast_unregister_application(), clear_mixmonitor_methods(), cli_mixmonitor, mixmonitor_function, ast_mixmonitor_methods::start, and stop_app.

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Mixed Audio Monitoring Application" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .optional_modules = "func_periodic_hook", }

static

Definition at line 1881 of file app_mixmonitor.c.

◆ app

const char* const app = "MixMonitor"

static

Definition at line 396 of file app_mixmonitor.c.

Referenced by load_module(), and unload_module().

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1881 of file app_mixmonitor.c.

◆ cli_mixmonitor

struct ast_cli_entry cli_mixmonitor[]

static

Initial value:

= {
    { .handler =  handle_cli_mixmonitor , .summary =  "Execute a MixMonitor command" ,}
}

Definition at line 1825 of file app_mixmonitor.c.

                                               {
    AST_CLI_DEFINE(handle_cli_mixmonitor, "Execute a MixMonitor command")
};

Referenced by load_module(), and unload_module().

◆ mixmonitor_ds_info

const struct ast_datastore_info mixmonitor_ds_info

static

Initial value:

= {
    .type = "mixmonitor",
    .destroy = mixmonitor_ds_destroy,
}

Definition at line 561 of file app_mixmonitor.c.

                                                            {
    .type = "mixmonitor",
    .destroy = mixmonitor_ds_destroy,
};

Referenced by func_mixmonitor_read(), handle_cli_mixmonitor(), mixmonitor_ds_remove_and_free(), mute_mixmonitor_instance(), setup_mixmonitor_ds(), and stop_mixmonitor_full().

◆ mixmonitor_function

struct ast_custom_function mixmonitor_function

static

Initial value:

= {
    .name = "MIXMONITOR",
    .read = func_mixmonitor_read,
}

Definition at line 1820 of file app_mixmonitor.c.

                                                        {
    .name = "MIXMONITOR",
    .read = func_mixmonitor_read,
};

Referenced by load_module(), and unload_module().

◆ mixmonitor_opts

const struct ast_app_option mixmonitor_opts[128] = { [ 'a' ] = { .flag = MUXFLAG_APPEND }, [ 'b' ] = { .flag = MUXFLAG_BRIDGED }, [ 'B' ] = { .flag = MUXFLAG_BEEP , .arg_index = OPT_ARG_BEEP_INTERVAL + 1 }, [ 'c' ] = { .flag = MUXFLAG_REAL_CALLERID }, [ 'd' ] = { .flag = MUXFLAG_AUTO_DELETE }, [ 'p' ] = { .flag = MUXFLAG_BEEP_START }, [ 'P' ] = { .flag = MUXFLAG_BEEP_STOP }, [ 'v' ] = { .flag = MUXFLAG_READVOLUME , .arg_index = OPT_ARG_READVOLUME + 1 }, [ 'V' ] = { .flag = MUXFLAG_WRITEVOLUME , .arg_index = OPT_ARG_WRITEVOLUME + 1 }, [ 'W' ] = { .flag = MUXFLAG_VOLUME , .arg_index = OPT_ARG_VOLUME + 1 }, [ 'r' ] = { .flag = MUXFLAG_READ , .arg_index = OPT_ARG_READNAME + 1 }, [ 't' ] = { .flag = MUXFLAG_WRITE , .arg_index = OPT_ARG_WRITENAME + 1 }, [ 'D' ] = { .flag = MUXFLAG_INTERLEAVED }, [ 'i' ] = { .flag = MUXFLAG_UID , .arg_index = OPT_ARG_UID + 1 }, [ 'm' ] = { .flag = MUXFLAG_VMRECIPIENTS , .arg_index = OPT_ARG_VMRECIPIENTS + 1 }, [ 'S' ] = { .flag = MUXFLAG_DEPRECATED_RWSYNC , .arg_index = OPT_ARG_DEPRECATED_RWSYNC + 1 }, [ 'n' ] = { .flag = MUXFLAG_NO_RWSYNC , .arg_index = OPT_ARG_NO_RWSYNC + 1 }, }

static

Definition at line 492 of file app_mixmonitor.c.

Referenced by manager_mixmonitor(), and mixmonitor_exec().

◆ mixmonitor_spy_type

const char* const mixmonitor_spy_type = "MixMonitor"

static

Definition at line 400 of file app_mixmonitor.c.

Referenced by feature_automixmonitor(), launch_monitor_thread(), and manager_mute_mixmonitor().

◆ stop_app

const char* const stop_app = "StopMixMonitor"

static

Definition at line 398 of file app_mixmonitor.c.

Referenced by load_module(), and unload_module().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ get_volfactor

◆ SAMPLES_PER_FRAME

Enumeration Type Documentation

◆ mixmonitor_args

◆ mixmonitor_flags

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ add_vm_recipients_from_string()

◆ AST_MODULE_SELF_SYM()

◆ clear_mixmonitor_methods()

◆ clear_mixmonitor_recipient_list()

◆ copy_to_voicemail()

◆ destroy_monitor_audiohook()

◆ filename_parse()

◆ func_mixmonitor_read()

◆ handle_cli_mixmonitor()

◆ launch_monitor_thread()

◆ load_module()

◆ manager_mixmonitor()

◆ manager_mute_mixmonitor()

◆ manager_stop_mixmonitor()

◆ mixmonitor_autochan_is_bridged()

◆ mixmonitor_ds_close_fs()

◆ mixmonitor_ds_destroy()

◆ mixmonitor_ds_remove_and_free()

◆ mixmonitor_exec()

◆ mixmonitor_free()

◆ mixmonitor_save_prep()

◆ mixmonitor_thread()

◆ mute_mixmonitor_instance()

◆ set_mixmonitor_methods()

◆ setup_mixmonitor_ds()

◆ start_mixmonitor_callback()

◆ startmon()

◆ stop_mixmonitor_callback()

◆ stop_mixmonitor_exec()

◆ stop_mixmonitor_full()

◆ unload_module()

Variable Documentation

◆ __mod_info

◆ app

◆ ast_module_info

◆ cli_mixmonitor

◆ mixmonitor_ds_info

◆ mixmonitor_function

◆ mixmonitor_opts

◆ mixmonitor_spy_type

◆ stop_app