Asterisk - The Open Source Telephony Project GIT-master-8f1982c
All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Macros Modules Pages
Data Structures | Macros | Enumerations | Functions | Variables
app_mixmonitor.c File Reference

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_moduleAST_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. More...
 
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. More...
 
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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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_infoast_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 389 of file app_mixmonitor.c.

◆ SAMPLES_PER_FRAME

#define SAMPLES_PER_FRAME   160

Definition at line 648 of file app_mixmonitor.c.

Enumeration Type Documentation

◆ 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 455 of file app_mixmonitor.c.

455 {
466 OPT_ARG_ARRAY_SIZE, /* Always last element of the enum */
467};
@ OPT_ARG_WRITEVOLUME
@ OPT_ARG_UID
@ OPT_ARG_VMRECIPIENTS
@ OPT_ARG_DEPRECATED_RWSYNC
@ OPT_ARG_NO_RWSYNC
@ OPT_ARG_WRITENAME
@ OPT_ARG_READNAME
@ OPT_ARG_BEEP_INTERVAL
@ OPT_ARG_READVOLUME
@ OPT_ARG_VOLUME
@ OPT_ARG_ARRAY_SIZE

◆ 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 434 of file app_mixmonitor.c.

434 {
435 MUXFLAG_APPEND = (1 << 1),
436 MUXFLAG_BRIDGED = (1 << 2),
437 MUXFLAG_VOLUME = (1 << 3),
438 MUXFLAG_READVOLUME = (1 << 4),
439 MUXFLAG_WRITEVOLUME = (1 << 5),
440 MUXFLAG_READ = (1 << 6),
441 MUXFLAG_WRITE = (1 << 7),
442 MUXFLAG_COMBINED = (1 << 8),
443 MUXFLAG_UID = (1 << 9),
444 MUXFLAG_VMRECIPIENTS = (1 << 10),
445 MUXFLAG_BEEP = (1 << 11),
446 MUXFLAG_BEEP_START = (1 << 12),
447 MUXFLAG_BEEP_STOP = (1 << 13),
448 MUXFLAG_DEPRECATED_RWSYNC = (1 << 14),
449 MUXFLAG_NO_RWSYNC = (1 << 15),
450 MUXFLAG_AUTO_DELETE = (1 << 16),
451 MUXFLAG_REAL_CALLERID = (1 << 17),
452 MUXFLAG_INTERLEAVED = (1 << 18),
453};
@ MUXFLAG_VMRECIPIENTS
@ MUXFLAG_READ
@ MUXFLAG_AUTO_DELETE
@ MUXFLAG_DEPRECATED_RWSYNC
@ MUXFLAG_REAL_CALLERID
@ MUXFLAG_WRITEVOLUME
@ MUXFLAG_INTERLEAVED
@ MUXFLAG_NO_RWSYNC
@ MUXFLAG_VOLUME
@ MUXFLAG_BEEP_STOP
@ MUXFLAG_UID
@ MUXFLAG_APPEND
@ MUXFLAG_BEEP_START
@ MUXFLAG_WRITE
@ MUXFLAG_COMBINED
@ MUXFLAG_BEEP
@ MUXFLAG_BRIDGED
@ MUXFLAG_READVOLUME

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 1876 of file app_mixmonitor.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 1876 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 590 of file app_mixmonitor.c.

591{
592 /* recipients are in a single string with a format format resembling "mailbox@context/INBOX,mailbox2@context2,mailbox3@context3/Work" */
593 char *cur_mailbox = ast_strdupa(vm_recipients);
594 char *cur_context;
595 char *cur_folder;
596 char *next;
597 int elements_processed = 0;
598
599 while (!ast_strlen_zero(cur_mailbox)) {
600 ast_debug(3, "attempting to add next element %d from %s\n", elements_processed, cur_mailbox);
601 if ((next = strchr(cur_mailbox, ',')) || (next = strchr(cur_mailbox, '&'))) {
602 *(next++) = '\0';
603 }
604
605 if ((cur_folder = strchr(cur_mailbox, '/'))) {
606 *(cur_folder++) = '\0';
607 } else {
608 cur_folder = "INBOX";
609 }
610
611 if ((cur_context = strchr(cur_mailbox, '@'))) {
612 *(cur_context++) = '\0';
613 } else {
614 cur_context = "default";
615 }
616
617 if (!ast_strlen_zero(cur_mailbox) && !ast_strlen_zero(cur_context)) {
618 struct vm_recipient *recipient;
619 if (!(recipient = ast_malloc(sizeof(*recipient)))) {
620 ast_log(LOG_ERROR, "Failed to allocate recipient. Aborting function.\n");
621 return;
622 }
623 ast_copy_string(recipient->context, cur_context, sizeof(recipient->context));
624 ast_copy_string(recipient->mailbox, cur_mailbox, sizeof(recipient->mailbox));
625 ast_copy_string(recipient->folder, cur_folder, sizeof(recipient->folder));
626
627 /* Add to list */
628 ast_verb(4, "Adding %s@%s to recipient list\n", recipient->mailbox, recipient->context);
630 } else {
631 ast_log(LOG_ERROR, "Failed to properly parse extension and/or context from element %d of recipient string: %s\n", elements_processed, vm_recipients);
632 }
633
634 cur_mailbox = next;
635 elements_processed++;
636 }
637}
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:191
#define ast_log
Definition: astobj2.c:42
#define ast_debug(level,...)
Log a DEBUG message.
#define LOG_ERROR
#define ast_verb(level,...)
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.
Definition: linkedlists.h:711
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
struct mixmonitor::@42 recipient_list
char mailbox[AST_MAX_CONTEXT]
char context[AST_MAX_EXTENSION]
struct vm_recipient * next
char folder[80]
struct vm_recipient::@41 list

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 1876 of file app_mixmonitor.c.

◆ clear_mixmonitor_methods()

static int clear_mixmonitor_methods ( void  )
static

Definition at line 1834 of file app_mixmonitor.c.

1835{
1837}
int ast_clear_mixmonitor_methods(void)
Clear the MixMonitor virtual methods table. Use this to cleanup function pointers provided by a modul...
Definition: mixmonitor.c:59

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 639 of file app_mixmonitor.c.

640{
641 struct vm_recipient *current;
643 /* Clear list element data */
645 }
646}
#define ast_free(a)
Definition: astmm.h:180
size_t current
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833

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 682 of file app_mixmonitor.c.

683{
684 struct vm_recipient *recipient = NULL;
685 struct ast_vm_recording_data recording_data;
686 if (ast_string_field_init(&recording_data, 512)) {
687 ast_log(LOG_ERROR, "Failed to string_field_init, skipping copy_to_voicemail\n");
688 return;
689 }
690
691 /* Copy strings to stringfields that will be used for all recipients */
692 ast_string_field_set(&recording_data, recording_file, filename);
693 ast_string_field_set(&recording_data, recording_ext, ext);
698 /* and call_priority gets copied too */
699 recording_data.call_priority = mixmonitor->call_priority;
700
701 AST_LIST_TRAVERSE(&mixmonitor->recipient_list, recipient, list) {
702 /* context, mailbox, and folder need to be set per recipient */
703 ast_string_field_set(&recording_data, context, recipient->context);
704 ast_string_field_set(&recording_data, mailbox, recipient->mailbox);
705 ast_string_field_set(&recording_data, folder, recipient->folder);
706
707 ast_verb(4, "MixMonitor attempting to send voicemail copy to %s@%s\n", recording_data.mailbox,
708 recording_data.context);
709 ast_app_copy_recording_to_vm(&recording_data);
710 }
711
712 /* Free the string fields for recording_data before exiting the function. */
713 ast_string_field_free_memory(&recording_data);
714}
const char * ext
Definition: http.c:150
int ast_app_copy_recording_to_vm(struct ast_vm_recording_data *vm_rec_data)
param[in] vm_rec_data Contains data needed to make the recording. retval 0 voicemail successfully cre...
Definition: main/app.c:596
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
Definition: linkedlists.h:491
#define NULL
Definition: resample.c:96
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
Definition: stringfields.h:521
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
Definition: stringfields.h:359
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object
Definition: stringfields.h:374
Structure used for ast_copy_recording_to_vm in order to cleanly supply data needed for making the rec...
const ast_string_field recording_file
const ast_string_field call_callerchan
const ast_string_field folder
const ast_string_field call_callerid
const ast_string_field call_context
const ast_string_field recording_ext
const ast_string_field call_extension
const ast_string_field call_callerchan
const ast_string_field call_callerid
const ast_string_field call_context
const ast_string_field call_extension

References ast_app_copy_recording_to_vm(), AST_LIST_TRAVERSE, ast_log, ast_string_field_free_memory, ast_string_field_init, ast_string_field_set, ast_verb, mixmonitor::call_callerchan, ast_vm_recording_data::call_callerchan, mixmonitor::call_callerid, ast_vm_recording_data::call_callerid, mixmonitor::call_context, ast_vm_recording_data::call_context, mixmonitor::call_extension, ast_vm_recording_data::call_extension, mixmonitor::call_priority, ast_vm_recording_data::call_priority, vm_recipient::context, voicemailpwcheck::context, ast_vm_recording_data::context, ext, vm_recipient::folder, ast_vm_recording_data::folder, LOG_ERROR, vm_recipient::mailbox, voicemailpwcheck::mailbox, ast_vm_recording_data::mailbox, NULL, mixmonitor::recipient_list, ast_vm_recording_data::recording_ext, and ast_vm_recording_data::recording_file.

Referenced by mixmonitor_thread().

◆ destroy_monitor_audiohook()

static void destroy_monitor_audiohook ( struct mixmonitor mixmonitor)
static

Definition at line 561 of file app_mixmonitor.c.

562{
567 }
568 /* kill the audiohook.*/
573}
#define ast_audiohook_lock(ah)
Lock an audiohook.
Definition: audiohook.h:313
int ast_audiohook_detach(struct ast_audiohook *audiohook)
Detach audiohook from channel.
Definition: audiohook.c:578
int ast_audiohook_destroy(struct ast_audiohook *audiohook)
Destroys an audiohook structure.
Definition: audiohook.c:124
#define ast_audiohook_unlock(ah)
Unlock an audiohook.
Definition: audiohook.h:318
#define ast_mutex_unlock(a)
Definition: lock.h:197
#define ast_mutex_lock(a)
Definition: lock.h:196
struct ast_audiohook * audiohook
ast_mutex_t lock
struct ast_audiohook audiohook
struct mixmonitor_ds * mixmonitor_ds

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 1190 of file app_mixmonitor.c.

1191{
1192 char *slash;
1193 char *ext;
1194
1195 ast_assert(len > 0);
1196
1197 if (ast_strlen_zero(filename)) {
1198 ast_log(LOG_WARNING, "No file name was provided for a file save option.\n");
1199 buffer[0] = 0;
1200 return buffer;
1201 }
1202
1203 /* If we don't have an absolute path, make one */
1204 if (*filename != '/') {
1205 char *build = ast_alloca(strlen(ast_config_AST_MONITOR_DIR) + strlen(filename) + 3);
1206 sprintf(build, "%s/%s", ast_config_AST_MONITOR_DIR, filename);
1207 filename = build;
1208 }
1209
1210 ast_copy_string(buffer, filename, len);
1211
1212 /* If the provided filename has a .wav49 extension, we need to convert it to .WAV to
1213 match the behavior of build_filename in main/file.c. Otherwise MIXMONITOR_FILENAME
1214 ends up referring to a file that does not/will not exist */
1215 ext = strrchr(buffer, '.');
1216 if (ext && !strcmp(ext, ".wav49")) {
1217 /* Change to WAV - we know we have at least 6 writeable bytes where 'ext' points,
1218 * so this is safe */
1219 memcpy(ext, ".WAV", sizeof(".WAV"));
1220 }
1221
1222 if ((slash = strrchr(filename, '/'))) {
1223 *slash = '\0';
1224 }
1225 ast_mkdir(filename, 0777);
1226
1227 return buffer;
1228}
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
#define LOG_WARNING
const char * ast_config_AST_MONITOR_DIR
Definition: options.c:156
#define ast_assert(a)
Definition: utils.h:739
int ast_mkdir(const char *path, int mode)
Recursively create directory path.
Definition: utils.c:2479

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 1777 of file app_mixmonitor.c.

1779{
1780 struct ast_datastore *datastore;
1781 struct mixmonitor_ds *ds_data;
1783 AST_APP_ARG(id);
1784 AST_APP_ARG(key);
1785 );
1786
1788
1789 if (ast_strlen_zero(args.id) || ast_strlen_zero(args.key)) {
1790 ast_log(LOG_WARNING, "Not enough arguments provided to %s. "
1791 "An ID and key must be provided\n", cmd);
1792 return -1;
1793 }
1794
1795 ast_channel_lock(chan);
1796 datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, args.id);
1797 ast_channel_unlock(chan);
1798
1799 if (!datastore) {
1800 ast_log(LOG_WARNING, "Could not find MixMonitor with ID %s\n", args.id);
1801 return -1;
1802 }
1803
1804 ds_data = datastore->data;
1805
1806 if (!strcasecmp(args.key, "filename")) {
1807 ast_copy_string(buf, ds_data->filename, len);
1808 } else {
1809 ast_log(LOG_WARNING, "Unrecognized %s option %s\n", cmd, args.key);
1810 return -1;
1811 }
1812 return 0;
1813}
static const struct ast_datastore_info mixmonitor_ds_info
#define ast_channel_lock(chan)
Definition: channel.h:2972
#define ast_channel_unlock(chan)
Definition: channel.h:2973
struct ast_datastore * ast_channel_datastore_find(struct ast_channel *chan, const struct ast_datastore_info *info, const char *uid)
Find a datastore on a channel.
Definition: channel.c:2368
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
#define AST_APP_ARG(name)
Define an application argument.
#define AST_DECLARE_APP_ARGS(name, arglist)
Declare a structure to hold an application's arguments.
#define AST_STANDARD_APP_ARGS(args, parse)
Performs the 'standard' argument separation process for an application.
Structure for a data store object.
Definition: datastore.h:64
void * data
Definition: datastore.h:66
const char * args

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 1452 of file app_mixmonitor.c.

1453{
1454 struct ast_channel *chan;
1455 struct ast_datastore *datastore = NULL;
1457
1458 switch (cmd) {
1459 case CLI_INIT:
1460 e->command = "mixmonitor {start|stop|list}";
1461 e->usage =
1462 "Usage: mixmonitor start <chan_name> [args]\n"
1463 " The optional arguments are passed to the MixMonitor application.\n"
1464 " mixmonitor stop <chan_name> [args]\n"
1465 " The optional arguments are passed to the StopMixMonitor application.\n"
1466 " mixmonitor list <chan_name>\n";
1467 return NULL;
1468 case CLI_GENERATE:
1469 return ast_complete_channels(a->line, a->word, a->pos, a->n, 2);
1470 }
1471
1472 if (a->argc < 3) {
1473 return CLI_SHOWUSAGE;
1474 }
1475
1476 if (!(chan = ast_channel_get_by_name_prefix(a->argv[2], strlen(a->argv[2])))) {
1477 ast_cli(a->fd, "No channel matching '%s' found.\n", a->argv[2]);
1478 /* Technically this is a failure, but we don't want 2 errors printing out */
1479 return CLI_SUCCESS;
1480 }
1481
1482 if (!strcasecmp(a->argv[1], "start")) {
1483 mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
1484 } else if (!strcasecmp(a->argv[1], "stop")){
1485 stop_mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
1486 } else if (!strcasecmp(a->argv[1], "list")) {
1487 ast_cli(a->fd, "MixMonitor ID\tFile\tReceive File\tTransmit File\n");
1488 ast_cli(a->fd, "=========================================================================\n");
1489 ast_channel_lock(chan);
1490 AST_LIST_TRAVERSE(ast_channel_datastores(chan), datastore, entry) {
1491 if (datastore->info == &mixmonitor_ds_info) {
1492 char *filename = "";
1493 char *filename_read = "";
1494 char *filename_write = "";
1495
1496 mixmonitor_ds = datastore->data;
1497 if (mixmonitor_ds->fs) {
1499 }
1500 if (mixmonitor_ds->fs_read) {
1501 filename_read = mixmonitor_ds->fs_read->filename;
1502 }
1503 if (mixmonitor_ds->fs_write) {
1504 filename_write = mixmonitor_ds->fs_write->filename;
1505 }
1506 ast_cli(a->fd, "%p\t%s\t%s\t%s\n", mixmonitor_ds, filename, filename_read, filename_write);
1507 }
1508 }
1509 ast_channel_unlock(chan);
1510 } else {
1511 chan = ast_channel_unref(chan);
1512 return CLI_SHOWUSAGE;
1513 }
1514
1515 chan = ast_channel_unref(chan);
1516
1517 return CLI_SUCCESS;
1518}
static int mixmonitor_exec(struct ast_channel *chan, const char *data)
static int stop_mixmonitor_exec(struct ast_channel *chan, const char *data)
struct ast_channel * ast_channel_get_by_name_prefix(const char *name, size_t name_len)
Find a channel by a name prefix.
Definition: channel.c:1380
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:3008
struct ast_datastore_list * ast_channel_datastores(struct ast_channel *chan)
#define CLI_SHOWUSAGE
Definition: cli.h:45
#define CLI_SUCCESS
Definition: cli.h:44
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
char * ast_complete_channels(const char *line, const char *word, int pos, int state, int rpos)
Command completion for the list of active channels.
Definition: main/cli.c:1872
@ CLI_INIT
Definition: cli.h:152
@ CLI_GENERATE
Definition: cli.h:153
Main Channel structure associated with a channel.
char * command
Definition: cli.h:186
const char * usage
Definition: cli.h:177
const struct ast_datastore_info * info
Definition: datastore.h:67
char * filename
Definition: mod_format.h:107
struct ast_filestream * fs_read
struct ast_filestream * fs_write
struct ast_filestream * fs
static struct test_val a

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 1032 of file app_mixmonitor.c.

1037{
1038 pthread_t thread;
1039 struct mixmonitor *mixmonitor;
1040 char postprocess2[1024] = "";
1041 char *datastore_id = NULL;
1042
1043 postprocess2[0] = 0;
1044 /* If a post process system command is given attach it to the structure */
1046 char *p1, *p2;
1047
1049 for (p2 = p1; *p2; p2++) {
1050 if (*p2 == '^' && *(p2+1) == '{') {
1051 *p2 = '$';
1052 }
1053 }
1054 ast_channel_lock(chan);
1055 pbx_substitute_variables_helper(chan, p1, postprocess2, sizeof(postprocess2) - 1);
1056 ast_channel_unlock(chan);
1057 }
1058
1059 /* Pre-allocate mixmonitor structure and spy */
1060 if (!(mixmonitor = ast_calloc(1, sizeof(*mixmonitor)))) {
1061 return -1;
1062 }
1063
1064 /* Now that the struct has been calloced, go ahead and initialize the string fields. */
1067 return -1;
1068 }
1069
1070 /* Setup the actual spy before creating our thread */
1073 return -1;
1074 }
1075
1076 /* Copy over flags and channel name */
1078 if (!(mixmonitor->autochan = ast_autochan_setup(chan))) {
1080 return -1;
1081 }
1082
1083 if (!ast_strlen_zero(filename)) {
1085 }
1086
1089 }
1090
1093 }
1094
1095 if (setup_mixmonitor_ds(mixmonitor, chan, &datastore_id, beep_id)) {
1098 ast_free(datastore_id);
1099 return -1;
1100 }
1101
1102 if (!ast_strlen_zero(uid_channel_var)) {
1103 if (datastore_id) {
1104 pbx_builtin_setvar_helper(chan, uid_channel_var, datastore_id);
1105 }
1106 }
1107
1109
1110 if (!ast_strlen_zero(postprocess2)) {
1111 mixmonitor->post_process = ast_strdup(postprocess2);
1112 }
1113
1114 if (!ast_strlen_zero(recipients)) {
1115 char callerid[256];
1116
1117 ast_channel_lock(chan);
1118
1119 /* We use the connected line of the invoking channel for caller ID,
1120 * unless we've been told to use the Caller ID.
1121 * The initial use for this relied on Connected Line to get the
1122 * actual number for recording with Digium phones,
1123 * but in generic use the Caller ID is likely what people want.
1124 */
1125
1127 struct ast_party_caller *caller;
1128 caller = ast_channel_caller(chan);
1129 ast_debug(3, "Caller ID = %d - %s : %d - %s\n", caller->id.name.valid,
1130 caller->id.name.str, caller->id.number.valid,
1131 caller->id.number.str);
1132 ast_callerid_merge(callerid, sizeof(callerid),
1133 S_COR(caller->id.name.valid, caller->id.name.str, NULL),
1134 S_COR(caller->id.number.valid, caller->id.number.str, NULL),
1135 "Unknown");
1136 } else {
1139 ast_debug(3, "Connected Line CID = %d - %s : %d - %s\n", connected->id.name.valid,
1140 connected->id.name.str, connected->id.number.valid,
1141 connected->id.number.str);
1142 ast_callerid_merge(callerid, sizeof(callerid),
1143 S_COR(connected->id.name.valid, connected->id.name.str, NULL),
1144 S_COR(connected->id.number.valid, connected->id.number.str, NULL),
1145 "Unknown");
1146 }
1147
1149 ast_string_field_set(mixmonitor, call_extension, ast_channel_exten(chan));
1150 ast_string_field_set(mixmonitor, call_callerchan, ast_channel_name(chan));
1151 ast_string_field_set(mixmonitor, call_callerid, callerid);
1153
1154 ast_channel_unlock(chan);
1155
1157 }
1158
1162 }
1163
1164 if (readvol)
1166 if (writevol)
1168
1169 if (startmon(chan, &mixmonitor->audiohook)) {
1170 ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
1172 mixmonitor_ds_remove_and_free(chan, datastore_id);
1173 ast_free(datastore_id);
1177 return -1;
1178 }
1179
1180 ast_free(datastore_id);
1181
1182 /* reference be released at mixmonitor destruction */
1184
1186}
static void mixmonitor_free(struct mixmonitor *mixmonitor)
static void * mixmonitor_thread(void *obj)
static void mixmonitor_ds_remove_and_free(struct ast_channel *chan, const char *datastore_id)
static int setup_mixmonitor_ds(struct mixmonitor *mixmonitor, struct ast_channel *chan, char **datastore_id, const char *beep_id)
static int startmon(struct ast_channel *chan, struct ast_audiohook *audiohook)
static const char *const mixmonitor_spy_type
static void add_vm_recipients_from_string(struct mixmonitor *mixmonitor, const char *vm_recipients)
pthread_t thread
Definition: app_sla.c:335
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:202
int ast_audiohook_init(struct ast_audiohook *audiohook, enum ast_audiohook_type type, const char *source, enum ast_audiohook_init_flags flags)
Initialize an audiohook structure.
Definition: audiohook.c:100
@ AST_AUDIOHOOK_SUBSTITUTE_SILENCE
Definition: audiohook.h:68
@ AST_AUDIOHOOK_TRIGGER_SYNC
Definition: audiohook.h:59
@ AST_AUDIOHOOK_TYPE_SPY
Definition: audiohook.h:36
struct ast_autochan * ast_autochan_setup(struct ast_channel *chan)
set up a new ast_autochan structure
Definition: autochan.c:38
void ast_autochan_destroy(struct ast_autochan *autochan)
destroy an ast_autochan structure
Definition: autochan.c:64
char * ast_callerid_merge(char *buf, int bufsiz, const char *name, const char *num, const char *unknown)
Definition: callerid.c:1273
const char * ast_channel_name(const struct ast_channel *chan)
int ast_channel_priority(const struct ast_channel *chan)
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
const char * ast_channel_context(const struct ast_channel *chan)
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
const char * ast_channel_exten(const struct ast_channel *chan)
char connected
Definition: eagi_proxy.c:82
ast_callid ast_read_threadstorage_callid(void)
extracts the callerid from the thread
Definition: logger.c:2273
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
void pbx_substitute_variables_helper(struct ast_channel *c, const char *cp1, char *cp2, int count)
Definition: ael_main.c:211
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:87
struct ast_audiohook_options options
Definition: audiohook.h:119
Caller Party information.
Definition: channel.h:420
struct ast_party_id id
Caller party ID.
Definition: channel.h:422
Connected Line/Party information.
Definition: channel.h:458
struct ast_party_name name
Subscriber name.
Definition: channel.h:342
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:344
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:281
char * str
Subscriber name (Malloced)
Definition: channel.h:266
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:299
char * str
Subscriber phone number (Malloced)
Definition: channel.h:293
char * filename_write
ast_callid callid
struct ast_autochan * autochan
char * post_process
char * filename_read
unsigned int flags
char * filename
#define ast_test_flag(p, flag)
Definition: utils.h:63
#define ast_pthread_create_detached_background(a, b, c, d)
Definition: utils.h:597
#define ast_set_flag(p, flag)
Definition: utils.h:70

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 1855 of file app_mixmonitor.c.

1856{
1857 int res;
1858
1866 res |= set_mixmonitor_methods();
1867
1868 return res;
1869}
static int manager_stop_mixmonitor(struct mansession *s, const struct message *m)
static struct ast_cli_entry cli_mixmonitor[]
static struct ast_custom_function mixmonitor_function
static int set_mixmonitor_methods(void)
static const char *const app
static int manager_mute_mixmonitor(struct mansession *s, const struct message *m)
Mute / unmute a MixMonitor channel.
static const char *const stop_app
static int manager_mixmonitor(struct mansession *s, const struct message *m)
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
#define EVENT_FLAG_SYSTEM
Definition: manager.h:75
#define ast_manager_register_xml(action, authority, func)
Register a manager callback using XML documentation to describe the manager.
Definition: manager.h:192
#define EVENT_FLAG_CALL
Definition: manager.h:76
#define ast_register_application_xml(app, execute)
Register an application using XML documentation.
Definition: module.h:640
#define ast_custom_function_register(acf)
Register a custom function.
Definition: pbx.h:1559
#define ARRAY_LEN(a)
Definition: utils.h:666

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(), stop_app, and stop_mixmonitor_exec().

◆ manager_mixmonitor()

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

Definition at line 1673 of file app_mixmonitor.c.

1674{
1675 struct ast_channel *c;
1676 const char *name = astman_get_header(m, "Channel");
1677 const char *id = astman_get_header(m, "ActionID");
1678 const char *file = astman_get_header(m, "File");
1679 const char *options = astman_get_header(m, "Options");
1680 const char *command = astman_get_header(m, "Command");
1681 char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
1682 struct ast_flags flags = { 0 };
1683 char *uid_channel_var = NULL;
1684 const char *mixmonitor_id = NULL;
1685 int res;
1686 char args[PATH_MAX];
1687
1688 if (ast_strlen_zero(name)) {
1689 astman_send_error(s, m, "No channel specified");
1690 return AMI_SUCCESS;
1691 }
1692
1694 if (!c) {
1695 astman_send_error(s, m, "No such channel");
1696 return AMI_SUCCESS;
1697 }
1698
1699 if (!ast_strlen_zero(options)) {
1701 }
1702
1703 snprintf(args, sizeof(args), "%s,%s,%s", file, options, command);
1704
1705 res = mixmonitor_exec(c, args);
1706
1708 uid_channel_var = opts[OPT_ARG_UID];
1710 mixmonitor_id = pbx_builtin_getvar_helper(c, uid_channel_var);
1711 mixmonitor_id = ast_strdupa(S_OR(mixmonitor_id, ""));
1713 }
1714
1715 if (res) {
1717 astman_send_error(s, m, "Could not start monitoring channel");
1718 return AMI_SUCCESS;
1719 }
1720
1721 astman_append(s, "Response: Success\r\n");
1722
1723 if (!ast_strlen_zero(id)) {
1724 astman_append(s, "ActionID: %s\r\n", id);
1725 }
1726
1727 if (!ast_strlen_zero(mixmonitor_id)) {
1728 astman_append(s, "MixMonitorID: %s\r\n", mixmonitor_id);
1729 }
1730
1731 astman_append(s, "\r\n");
1732
1734
1735 return AMI_SUCCESS;
1736}
static const struct ast_app_option mixmonitor_opts[128]
#define PATH_MAX
Definition: asterisk.h:40
struct ast_channel * ast_channel_get_by_name(const char *search)
Find a channel by name or uniqueid.
Definition: channel.c:1397
static const char name[]
Definition: format_mp3.c:68
void astman_send_error(struct mansession *s, const struct message *m, char *error)
Send error in manager transaction.
Definition: manager.c:1986
const char * astman_get_header(const struct message *m, char *var)
Get header from manager transaction.
Definition: manager.c:1647
void astman_append(struct mansession *s, const char *fmt,...)
Definition: manager.c:1907
int ast_app_parse_options(const struct ast_app_option *options, struct ast_flags *flags, char **args, char *optstr)
Parses a string containing application options and sets flags/arguments.
Definition: main/app.c:3066
#define AMI_SUCCESS
Definition: manager.h:66
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition: strings.h:80
Structure used to handle boolean flags.
Definition: utils.h:199
unsigned int flags
Definition: utils.h:200
static struct test_options options
static struct test_val c

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, make_ari_stubs::file, 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 1565 of file app_mixmonitor.c.

1566{
1567 struct ast_channel *c;
1568 const char *name = astman_get_header(m, "Channel");
1569 const char *id = astman_get_header(m, "ActionID");
1570 const char *state = astman_get_header(m, "State");
1571 const char *direction = astman_get_header(m,"Direction");
1572 const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
1573 int clearmute = 1, mutedcount = 0;
1576 RAII_VAR(struct ast_json *, stasis_message_blob, NULL, ast_json_unref);
1577
1579 astman_send_error(s, m, "No direction specified. Must be read, write or both");
1580 return AMI_SUCCESS;
1581 }
1582
1583 if (!strcasecmp(direction, "read")) {
1585 } else if (!strcasecmp(direction, "write")) {
1587 } else if (!strcasecmp(direction, "both")) {
1589 } else {
1590 astman_send_error(s, m, "Invalid direction specified. Must be read, write or both");
1591 return AMI_SUCCESS;
1592 }
1593
1594 if (ast_strlen_zero(name)) {
1595 astman_send_error(s, m, "No channel specified");
1596 return AMI_SUCCESS;
1597 }
1598
1599 if (ast_strlen_zero(state)) {
1600 astman_send_error(s, m, "No state specified");
1601 return AMI_SUCCESS;
1602 }
1603
1604 clearmute = ast_false(state);
1605
1607 if (!c) {
1608 astman_send_error(s, m, "No such channel");
1609 return AMI_SUCCESS;
1610 }
1611
1612 if (ast_strlen_zero(mixmonitor_id)) {
1613 mutedcount = ast_audiohook_set_mute_all(c, mixmonitor_spy_type, flag, clearmute);
1614 if (mutedcount < 0) {
1616 astman_send_error(s, m, "Cannot set mute flag");
1617 return AMI_SUCCESS;
1618 }
1619 } else {
1620 if (mute_mixmonitor_instance(c, mixmonitor_id, flag, clearmute)) {
1622 astman_send_error(s, m, "Cannot set mute flag");
1623 return AMI_SUCCESS;
1624 }
1625 mutedcount = 1;
1626 }
1627
1628
1629 stasis_message_blob = ast_json_pack("{s: s, s: b, s: s, s: i}",
1630 "direction", direction,
1631 "state", ast_true(state),
1632 "mixmonitorid", mixmonitor_id,
1633 "count", mutedcount);
1634
1636 ast_channel_mixmonitor_mute_type(), stasis_message_blob);
1637
1638 if (stasis_message) {
1640 }
1641
1642 astman_append(s, "Response: Success\r\n");
1643
1644 if (!ast_strlen_zero(id)) {
1645 astman_append(s, "ActionID: %s\r\n", id);
1646 }
1647
1648 astman_append(s, "\r\n");
1649
1651
1652 return AMI_SUCCESS;
1653}
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.
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
int ast_audiohook_set_mute_all(struct ast_channel *chan, const char *source, enum ast_audiohook_flags flag, int clear)
Mute frames read from or written for all audiohooks on a channel.
Definition: audiohook.c:1423
ast_audiohook_flags
Definition: audiohook.h:54
@ AST_AUDIOHOOK_MUTE_READ
Definition: audiohook.h:64
@ AST_AUDIOHOOK_MUTE_WRITE
Definition: audiohook.h:65
struct stasis_topic * ast_channel_topic(struct ast_channel *chan)
A topic which publishes the events for a particular channel.
const char * ast_channel_uniqueid(const struct ast_channel *chan)
long int flag
Definition: f2c.h:83
direction
struct stasis_message_type * ast_channel_mixmonitor_mute_type(void)
Message type for muting or unmuting mixmonitor on a channel.
struct stasis_message * ast_channel_blob_create_from_cache(const char *uniqueid, struct stasis_message_type *type, struct ast_json *blob)
Create a ast_channel_blob message, pulling channel state from the cache.
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition: json.c:612
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic's subscribers.
Definition: stasis.c:1538
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition: utils.c:2199
int attribute_pure ast_false(const char *val)
Make sure something is false. Determine if a string containing a boolean value is "false"....
Definition: utils.c:2216
Abstract JSON element (object, array, string, int, ...).
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941

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 1738 of file app_mixmonitor.c.

1739{
1740 struct ast_channel *c;
1741 const char *name = astman_get_header(m, "Channel");
1742 const char *id = astman_get_header(m, "ActionID");
1743 const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
1744 int res;
1745
1746 if (ast_strlen_zero(name)) {
1747 astman_send_error(s, m, "No channel specified");
1748 return AMI_SUCCESS;
1749 }
1750
1752 if (!c) {
1753 astman_send_error(s, m, "No such channel");
1754 return AMI_SUCCESS;
1755 }
1756
1757 res = stop_mixmonitor_full(c, mixmonitor_id);
1758 if (res) {
1760 astman_send_error(s, m, "Could not stop monitoring channel");
1761 return AMI_SUCCESS;
1762 }
1763
1764 astman_append(s, "Response: Success\r\n");
1765
1766 if (!ast_strlen_zero(id)) {
1767 astman_append(s, "ActionID: %s\r\n", id);
1768 }
1769
1770 astman_append(s, "\r\n");
1771
1773
1774 return AMI_SUCCESS;
1775}
static int stop_mixmonitor_full(struct ast_channel *chan, const char *data)

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 745 of file app_mixmonitor.c.

746{
747 int is_bridged;
748
750 is_bridged = ast_channel_is_bridged(autochan->chan);
752 return is_bridged;
753}
#define ast_autochan_channel_lock(autochan)
Lock the autochan's channel lock.
Definition: autochan.h:75
#define ast_autochan_channel_unlock(autochan)
Definition: autochan.h:84
int ast_channel_is_bridged(const struct ast_channel *chan)
Determine if a channel is in a bridge.
Definition: channel.c:10550
struct ast_channel * chan
Definition: autochan.h:33

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 513 of file app_mixmonitor.c.

514{
515 unsigned char quitting = 0;
516
517 if (mixmonitor_ds->fs) {
518 quitting = 1;
521 ast_verb(2, "MixMonitor close filestream (mixed)\n");
522 }
523
524 if (mixmonitor_ds->fs_read) {
525 quitting = 1;
528 ast_verb(2, "MixMonitor close filestream (read)\n");
529 }
530
531 if (mixmonitor_ds->fs_write) {
532 quitting = 1;
535 ast_verb(2, "MixMonitor close filestream (write)\n");
536 }
537
538 if (quitting) {
540 }
541}
int ast_closestream(struct ast_filestream *f)
Closes a stream.
Definition: file.c:1119

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

◆ mixmonitor_ds_remove_and_free()

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

Definition at line 1014 of file app_mixmonitor.c.

1015{
1016 struct ast_datastore *datastore;
1017
1018 ast_channel_lock(chan);
1019
1020 datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, datastore_id);
1021
1022 /*
1023 * Currently the one place this function is called from guarantees a
1024 * datastore is present, thus return checks can be avoided here.
1025 */
1026 ast_channel_datastore_remove(chan, datastore);
1027 ast_datastore_free(datastore);
1028
1029 ast_channel_unlock(chan);
1030}
int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
Remove a datastore from a channel.
Definition: channel.c:2363
int ast_datastore_free(struct ast_datastore *datastore)
Free a data store object.
Definition: datastore.c:68

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 1230 of file app_mixmonitor.c.

1231{
1232 int x, readvol = 0, writevol = 0;
1233 char *filename_read = NULL;
1234 char *filename_write = NULL;
1235 char filename_buffer[1024] = "";
1236 char *uid_channel_var = NULL;
1237 char beep_id[64] = "";
1238
1239 struct ast_flags flags = { 0 };
1240 char *recipients = NULL;
1241 char *parse;
1244 AST_APP_ARG(filename);
1246 AST_APP_ARG(post_process);
1247 );
1248
1249 if (ast_strlen_zero(data)) {
1250 ast_log(LOG_WARNING, "MixMonitor requires an argument (filename or ,t(filename) and/or r(filename)\n");
1251 return -1;
1252 }
1253
1254 parse = ast_strdupa(data);
1255
1257
1258 if (args.options) {
1259 char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
1260
1262
1264 ast_log(LOG_NOTICE, "The synchronization behavior enabled by the 'S' option is now the default"
1265 " and does not need to be specified.\n");
1266 }
1267
1270 ast_log(LOG_WARNING, "No volume level was provided for the heard volume ('v') option.\n");
1271 } else if ((sscanf(opts[OPT_ARG_READVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1272 ast_log(LOG_NOTICE, "Heard volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_READVOLUME]);
1273 } else {
1274 readvol = get_volfactor(x);
1275 }
1276 }
1277
1280 ast_log(LOG_WARNING, "No volume level was provided for the spoken volume ('V') option.\n");
1281 } else if ((sscanf(opts[OPT_ARG_WRITEVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1282 ast_log(LOG_NOTICE, "Spoken volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_WRITEVOLUME]);
1283 } else {
1284 writevol = get_volfactor(x);
1285 }
1286 }
1287
1289 if (ast_strlen_zero(opts[OPT_ARG_VOLUME])) {
1290 ast_log(LOG_WARNING, "No volume level was provided for the combined volume ('W') option.\n");
1291 } else if ((sscanf(opts[OPT_ARG_VOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1292 ast_log(LOG_NOTICE, "Combined volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_VOLUME]);
1293 } else {
1294 readvol = writevol = get_volfactor(x);
1295 }
1296 }
1297
1300 ast_log(LOG_WARNING, "No voicemail recipients were specified for the vm copy ('m') option.\n");
1301 } else {
1302 recipients = ast_strdupa(opts[OPT_ARG_VMRECIPIENTS]);
1303 }
1304 }
1305
1307 filename_write = ast_strdupa(filename_parse(opts[OPT_ARG_WRITENAME], filename_buffer, sizeof(filename_buffer)));
1308 }
1309
1311 filename_read = ast_strdupa(filename_parse(opts[OPT_ARG_READNAME], filename_buffer, sizeof(filename_buffer)));
1312 }
1313
1315 uid_channel_var = opts[OPT_ARG_UID];
1316 }
1317
1319 const char *interval_str = S_OR(opts[OPT_ARG_BEEP_INTERVAL], "15");
1320 unsigned int interval = 15;
1321
1322 if (sscanf(interval_str, "%30u", &interval) != 1) {
1323 ast_log(LOG_WARNING, "Invalid interval '%s' for periodic beep. Using default of %u\n",
1324 interval_str, interval);
1325 }
1326
1327 if (ast_beep_start(chan, interval, beep_id, sizeof(beep_id))) {
1328 ast_log(LOG_WARNING, "Unable to enable periodic beep, please ensure func_periodic_hook is loaded.\n");
1329 return -1;
1330 }
1331 }
1332 }
1333 /* If there are no file writing arguments/options for the mix monitor, send a warning message and return -1 */
1334
1336 ast_log(LOG_WARNING, "MixMonitor requires an argument (filename)\n");
1337 return -1;
1338 }
1339
1340 /* If filename exists, try to create directories for it */
1341 if (!(ast_strlen_zero(args.filename))) {
1342 args.filename = ast_strdupa(filename_parse(args.filename, filename_buffer, sizeof(filename_buffer)));
1343 }
1344
1345 pbx_builtin_setvar_helper(chan, "MIXMONITOR_FILENAME", args.filename);
1346
1347 /* If launch_monitor_thread works, the module reference must not be released until it is finished. */
1349 if (launch_monitor_thread(chan,
1350 args.filename,
1351 flags.flags,
1352 readvol,
1353 writevol,
1354 args.post_process,
1355 filename_write,
1356 filename_read,
1357 uid_channel_var,
1358 recipients,
1359 beep_id)) {
1361 }
1362
1365 if (message) {
1367 }
1368
1369 return 0;
1370}
static char * filename_parse(char *filename, char *buffer, size_t len)
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)
#define get_volfactor(x)
int AST_OPTIONAL_API_NAME() ast_beep_start(struct ast_channel *chan, unsigned int interval, char *beep_id, size_t len)
struct stasis_message_type * ast_channel_mixmonitor_start_type(void)
Message type for starting mixmonitor on a channel.
#define LOG_NOTICE
#define ast_module_unref(mod)
Release a reference to the module.
Definition: module.h:483
#define ast_module_ref(mod)
Hold a reference to the module.
Definition: module.h:457
struct ast_module * self
Definition: module.h:356

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, 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

◆ 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 716 of file app_mixmonitor.c.

717{
718 /* Initialize the file if not already done so */
719 char *last_slash = NULL;
720 if (!ast_strlen_zero(filename)) {
721 if (!*fs && !*errflag && !mixmonitor->mixmonitor_ds->fs_quit) {
722 *oflags = O_CREAT | O_WRONLY;
723 *oflags |= ast_test_flag(mixmonitor, MUXFLAG_APPEND) ? O_APPEND : O_TRUNC;
724
725 last_slash = strrchr(filename, '/');
726
727 if ((*ext = strrchr(filename, '.')) && (*ext > last_slash)) {
728 **ext = '\0';
729 *ext = *ext + 1;
730 } else {
731 *ext = "raw";
732 }
733
734 if (!(*fs = ast_writefile(filename, *ext, NULL, *oflags, 0, 0666))) {
735 ast_log(LOG_ERROR, "Cannot open %s.%s\n", filename, *ext);
736 *errflag = 1;
737 } else {
738 struct ast_filestream *tmp = *fs;
740 }
741 }
742 }
743}
struct ast_filestream * ast_writefile(const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
Starts writing a file.
Definition: file.c:1431
unsigned int ast_format_get_sample_rate(const struct ast_format *format)
Get the sample rate of a media format.
Definition: format.c:379
This structure is allocated by file.c in one chunk, together with buf_size and desc_size bytes of mem...
Definition: mod_format.h:101
struct ast_format_def * fmt
Definition: mod_format.h:103
struct ast_format * format
Definition: mod_format.h:48
unsigned int samp_rate
#define MAX(a, b)
Definition: utils.h:233

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 755 of file app_mixmonitor.c.

756{
757 struct mixmonitor *mixmonitor = obj;
758 char *fs_ext = "";
759 char *fs_read_ext = "";
760 char *fs_write_ext = "";
761
762 struct ast_filestream **fs = NULL;
763 struct ast_filestream **fs_read = NULL;
764 struct ast_filestream **fs_write = NULL;
765
766 unsigned int oflags;
767 int errflag = 0;
768 struct ast_format *format_slin;
769
770 /* Keep callid association before any log messages */
771 if (mixmonitor->callid) {
773 }
774
775 ast_verb(2, "Begin MixMonitor Recording %s\n", mixmonitor->name);
776
778 fs_read = &mixmonitor->mixmonitor_ds->fs_read;
779 fs_write = &mixmonitor->mixmonitor_ds->fs_write;
780
782 mixmonitor_save_prep(mixmonitor, mixmonitor->filename, fs, &oflags, &errflag, &fs_ext);
783 mixmonitor_save_prep(mixmonitor, mixmonitor->filename_read, fs_read, &oflags, &errflag, &fs_read_ext);
784 mixmonitor_save_prep(mixmonitor, mixmonitor->filename_write, fs_write, &oflags, &errflag, &fs_write_ext);
785
787
789
790 /* The audiohook must enter and exit the loop locked */
793 struct ast_frame *fr = NULL;
794 struct ast_frame *fr_read = NULL;
795 struct ast_frame *fr_write = NULL;
796
798 &fr_read, &fr_write))) {
800
802 break;
803 }
804 continue;
805 }
806
807 /* audiohook lock is not required for the next block.
808 * Unlock it, but remember to lock it before looping or exiting */
810
814
815 /* Write out the frame(s) */
816 if ((*fs_read) && (fr_read)) {
817 struct ast_frame *cur;
818
819 for (cur = fr_read; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
820 ast_writestream(*fs_read, cur);
821 }
822 }
823
824 if ((*fs_write) && (fr_write)) {
825 struct ast_frame *cur;
826
827 for (cur = fr_write; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
828 ast_writestream(*fs_write, cur);
829 }
830 }
831
833 /* The 'D' option is set, so mix the frame as an interleaved dual channel frame */
834 int i;
835 short read_buf[SAMPLES_PER_FRAME];
837 short stereo_buf[SAMPLES_PER_FRAME * 2];
838 struct ast_frame stereo_frame = {
840 .datalen = sizeof(stereo_buf),
842 };
843
844 if (fr) {
845 ast_frame_free(fr, 0);
846 fr = NULL;
847 }
848
849 if (fr_read) {
850 memcpy(read_buf, fr_read->data.ptr, sizeof(read_buf));
851 } else {
852 memset(read_buf, 0, sizeof(read_buf));
853 }
854
855 if (fr_write) {
856 memcpy(write_buf, fr_write->data.ptr, sizeof(write_buf));
857 } else {
858 memset(write_buf, 0, sizeof(write_buf));
859 }
860
861 for (i = 0; i < SAMPLES_PER_FRAME; i++) {
862 stereo_buf[i * 2] = read_buf[i];
863 stereo_buf[i * 2 + 1] = write_buf[i];
864 }
865
866 stereo_frame.data.ptr = stereo_buf;
868
869 fr = ast_frdup(&stereo_frame);
870 }
871
872 if ((*fs) && (fr)) {
873 struct ast_frame *cur;
874
875 for (cur = fr; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
876 ast_writestream(*fs, cur);
877 }
878 }
880 }
881 /* All done! free it. */
882 if (fr) {
883 ast_frame_free(fr, 0);
884 }
885 if (fr_read) {
886 ast_frame_free(fr_read, 0);
887 }
888 if (fr_write) {
889 ast_frame_free(fr_write, 0);
890 }
891
892 fr = NULL;
893 fr_write = NULL;
894 fr_read = NULL;
895
897 }
898
900
905 }
906
908
909 /* Datastore cleanup. close the filestream and wait for ds destruction */
914 }
916
917 /* kill the audiohook */
919
921 ast_verb(2, "Executing [%s]\n", mixmonitor->post_process);
923 }
924
925 ast_verb(2, "End MixMonitor Recording %s\n", mixmonitor->name);
926 ast_test_suite_event_notify("MIXMONITOR_END", "File: %s\r\n", mixmonitor->filename);
927
929 if (ast_strlen_zero(fs_ext)) {
930 ast_log(LOG_ERROR, "No file extension set for Mixmonitor %s. Skipping copy to voicemail.\n",
931 mixmonitor -> name);
932 } else {
933 ast_verb(3, "Copying recordings for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
935 }
936 if (!ast_strlen_zero(fs_read_ext)) {
937 ast_verb(3, "Copying read recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
939 }
940 if (!ast_strlen_zero(fs_write_ext)) {
941 ast_verb(3, "Copying write recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
943 }
944 } else {
945 ast_debug(3, "No recipients to forward monitor to, moving on.\n");
946 }
947
949 ast_debug(3, "Deleting our copies of recording files\n");
950 if (!ast_strlen_zero(fs_ext)) {
952 }
953 if (!ast_strlen_zero(fs_read_ext)) {
955 }
956 if (!ast_strlen_zero(fs_write_ext)) {
958 }
959 }
960
962
964 return NULL;
965}
static void destroy_monitor_audiohook(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 int mixmonitor_autochan_is_bridged(struct ast_autochan *autochan)
static void copy_to_voicemail(struct mixmonitor *mixmonitor, const char *ext, const char *filename)
#define SAMPLES_PER_FRAME
static void mixmonitor_ds_close_fs(struct mixmonitor_ds *mixmonitor_ds)
struct ast_frame * ast_audiohook_read_frame_all(struct ast_audiohook *audiohook, size_t samples, struct ast_format *format, struct ast_frame **read_frame, struct ast_frame **write_frame)
Reads a frame in from the audiohook structure in mixed audio mode and copies read and write frame dat...
Definition: audiohook.c:479
void ast_audiohook_trigger_wait(struct ast_audiohook *audiohook)
Wait for audiohook trigger to be triggered.
Definition: audiohook.c:1122
@ AST_AUDIOHOOK_STATUS_RUNNING
Definition: audiohook.h:43
void write_buf(int file, char *buffer, int num)
Definition: eagi_proxy.c:312
int ast_writestream(struct ast_filestream *fs, struct ast_frame *f)
Writes a frame to a stream.
Definition: file.c:244
int ast_stream_and_wait(struct ast_channel *chan, const char *file, const char *digits)
stream file until digit If the file name is non-empty, try to play it.
Definition: file.c:1886
int ast_filedelete(const char *filename, const char *fmt)
Deletes a file.
Definition: file.c:1149
struct ast_format * ast_format_cache_get_slin_by_rate(unsigned int rate)
Retrieve the best signed linear format given a sample rate.
Definition: format_cache.c:512
int ast_safe_system(const char *s)
Safely spawn an OS shell command while closing file descriptors.
Definition: extconf.c:829
void ast_frame_free(struct ast_frame *frame, int cache)
Frees a frame or list of frames.
Definition: main/frame.c:176
#define ast_frdup(fr)
Copies a frame.
@ AST_FRAME_VOICE
int ast_callid_threadassoc_add(ast_callid callid)
Adds a known callid to thread storage of the calling thread.
Definition: logger.c:2295
#define AST_LIST_EMPTY(head)
Checks whether the specified list contains any entries.
Definition: linkedlists.h:450
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
Definition: linkedlists.h:439
#define ast_cond_wait(cond, mutex)
Definition: lock.h:212
enum ast_audiohook_status status
Definition: audiohook.h:108
Definition of a media format.
Definition: format.c:43
struct ast_format * format
Data structure associated with a single frame of data.
union ast_frame::@228 data
struct ast_frame_subclass subclass
enum ast_frame_type frametype
#define ast_test_suite_event_notify(s, f,...)
Definition: test.h:189

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 1521 of file app_mixmonitor.c.

1523{
1524 struct ast_datastore *datastore = NULL;
1525 char *parse = "";
1527
1529 AST_APP_ARG(mixmonid);
1530 );
1531
1532 if (!ast_strlen_zero(data)) {
1533 parse = ast_strdupa(data);
1534 }
1535
1537
1538 ast_channel_lock(chan);
1539
1541 S_OR(args.mixmonid, NULL));
1542 if (!datastore) {
1543 ast_channel_unlock(chan);
1544 return -1;
1545 }
1546 mixmonitor_ds = datastore->data;
1547
1549
1550 if (mixmonitor_ds->audiohook) {
1551 if (clearmute) {
1553 } else {
1555 }
1556 }
1557
1559 ast_channel_unlock(chan);
1560
1561 return 0;
1562}
#define ast_clear_flag(p, flag)
Definition: utils.h:77

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 1824 of file app_mixmonitor.c.

1825{
1829 };
1830
1832}
static int start_mixmonitor_callback(struct ast_channel *chan, const char *filename, const char *options)
static int stop_mixmonitor_callback(struct ast_channel *chan, const char *mixmonitor_id)
static struct ast_mixmonitor_methods mixmonitor_methods
Definition: mixmonitor.c:40
int ast_set_mixmonitor_methods(struct ast_mixmonitor_methods *vmethod_table)
Setup MixMonitor virtual methods table. Use this to provide the MixMonitor functionality from a loada...
Definition: mixmonitor.c:43
MixMonitor virtual methods table definition.
Definition: mixmonitor.h:58
ast_mixmonitor_start_fn start
Definition: mixmonitor.h:59

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 967 of file app_mixmonitor.c.

968{
969 struct ast_datastore *datastore = NULL;
971
972 if (!(mixmonitor_ds = ast_calloc(1, sizeof(*mixmonitor_ds)))) {
973 return -1;
974 }
975
976 if (ast_asprintf(datastore_id, "%p", mixmonitor_ds) == -1) {
977 ast_log(LOG_ERROR, "Failed to allocate memory for MixMonitor ID.\n");
979 return -1;
980 }
981
984
985 if (!(datastore = ast_datastore_alloc(&mixmonitor_ds_info, *datastore_id))) {
989 return -1;
990 }
991
996 }
997
998 mixmonitor_ds->samp_rate = 8000;
1001 if (!ast_strlen_zero(beep_id)) {
1003 }
1004 datastore->data = mixmonitor_ds;
1005
1006 ast_channel_lock(chan);
1007 ast_channel_datastore_add(chan, datastore);
1008 ast_channel_unlock(chan);
1009
1011 return 0;
1012}
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
Definition: astmm.h:267
int ast_channel_datastore_add(struct ast_channel *chan, struct ast_datastore *datastore)
Add a datastore to a channel.
Definition: channel.c:2354
#define ast_datastore_alloc(info, uid)
Definition: datastore.h:85
#define ast_cond_init(cond, attr)
Definition: lock.h:208
#define ast_mutex_init(pmutex)
Definition: lock.h:193

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 1655 of file app_mixmonitor.c.

1656{
1657 char args[PATH_MAX];
1658
1659 if (ast_strlen_zero(options)) {
1660 snprintf(args, sizeof(args), "%s", filename);
1661 } else {
1662 snprintf(args, sizeof(args), "%s,%s", filename, options);
1663 }
1664
1665 return mixmonitor_exec(chan, args);
1666}

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 575 of file app_mixmonitor.c.

576{
577 if (!chan) {
578 return -1;
579 }
580
581 return ast_audiohook_attach(chan, audiohook);
582}
int ast_audiohook_attach(struct ast_channel *chan, struct ast_audiohook *audiohook)
Attach audiohook to channel.
Definition: audiohook.c:512

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 1668 of file app_mixmonitor.c.

1669{
1670 return stop_mixmonitor_full(chan, mixmonitor_id);
1671}

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 1446 of file app_mixmonitor.c.

1447{
1448 stop_mixmonitor_full(chan, data);
1449 return 0;
1450}

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 1372 of file app_mixmonitor.c.

1373{
1374 struct ast_datastore *datastore = NULL;
1375 char *parse = "";
1377 const char *beep_id = NULL;
1379
1381 AST_APP_ARG(mixmonid);
1382 );
1383
1384 if (!ast_strlen_zero(data)) {
1385 parse = ast_strdupa(data);
1386 }
1387
1389
1390 ast_channel_lock(chan);
1391
1393 S_OR(args.mixmonid, NULL));
1394 if (!datastore) {
1395 ast_channel_unlock(chan);
1396 return -1;
1397 }
1398 mixmonitor_ds = datastore->data;
1399
1401
1402 /* closing the filestream here guarantees the file is available to the dialplan
1403 * after calling StopMixMonitor */
1405
1406 /* The mixmonitor thread may be waiting on the audiohook trigger.
1407 * In order to exit from the mixmonitor loop before waiting on channel
1408 * destruction, poke the audiohook trigger. */
1409 if (mixmonitor_ds->audiohook) {
1412 }
1417 }
1418
1421 }
1422
1424
1425 /* Remove the datastore so the monitor thread can exit */
1426 if (!ast_channel_datastore_remove(chan, datastore)) {
1427 ast_datastore_free(datastore);
1428 }
1429
1430 ast_channel_unlock(chan);
1431
1432 if (!ast_strlen_zero(beep_id)) {
1433 ast_beep_stop(chan, beep_id);
1434 }
1435
1438 NULL);
1439 if (message) {
1441 }
1442
1443 return 0;
1444}
void ast_audiohook_update_status(struct ast_audiohook *audiohook, enum ast_audiohook_status status)
Update audiohook's status.
Definition: audiohook.c:568
@ AST_AUDIOHOOK_STATUS_DONE
Definition: audiohook.h:45
@ AST_AUDIOHOOK_STATUS_SHUTDOWN
Definition: audiohook.h:44
int AST_OPTIONAL_API_NAME() ast_beep_stop(struct ast_channel *chan, const char *beep_id)
struct stasis_message_type * ast_channel_mixmonitor_stop_type(void)
Message type for stopping mixmonitor on a channel.
ast_cond_t trigger
Definition: audiohook.h:106

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 1839 of file app_mixmonitor.c.

1840{
1841 int res;
1842
1846 res |= ast_manager_unregister("MixMonitorMute");
1847 res |= ast_manager_unregister("MixMonitor");
1848 res |= ast_manager_unregister("StopMixMonitor");
1850 res |= clear_mixmonitor_methods();
1851
1852 return res;
1853}
static int clear_mixmonitor_methods(void)
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
int ast_manager_unregister(const char *action)
Unregister a registered manager command.
Definition: manager.c:7697
int ast_unregister_application(const char *app)
Unregister an application.
Definition: pbx_app.c:392
int ast_custom_function_unregister(struct ast_custom_function *acf)
Unregister a custom function.

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, 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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .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 1876 of file app_mixmonitor.c.

◆ app

const char* const app = "MixMonitor"
static

Definition at line 391 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 1876 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" ,}
}
static char * handle_cli_mixmonitor(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)

Definition at line 1820 of file app_mixmonitor.c.

Referenced by load_module(), and unload_module().

◆ mixmonitor_ds_info

const struct ast_datastore_info mixmonitor_ds_info
static
Initial value:
= {
.type = "mixmonitor",
}
static void mixmonitor_ds_destroy(void *data)

Definition at line 556 of file app_mixmonitor.c.

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",
}
static int func_mixmonitor_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)

Definition at line 1815 of file app_mixmonitor.c.

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 487 of file app_mixmonitor.c.

Referenced by manager_mixmonitor(), and mixmonitor_exec().

◆ mixmonitor_spy_type

const char* const mixmonitor_spy_type = "MixMonitor"
static

◆ stop_app

const char* const stop_app = "StopMixMonitor"
static

Definition at line 393 of file app_mixmonitor.c.

Referenced by load_module(), and unload_module().