Asterisk - The Open Source Telephony Project GIT-master-f3e88d3
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)
}
 

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 }, [ '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 354 of file app_mixmonitor.c.

◆ SAMPLES_PER_FRAME

#define SAMPLES_PER_FRAME   160

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

419 {
430 OPT_ARG_ARRAY_SIZE, /* Always last element of the enum */
431};
@ 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 

Definition at line 399 of file app_mixmonitor.c.

399 {
400 MUXFLAG_APPEND = (1 << 1),
401 MUXFLAG_BRIDGED = (1 << 2),
402 MUXFLAG_VOLUME = (1 << 3),
403 MUXFLAG_READVOLUME = (1 << 4),
404 MUXFLAG_WRITEVOLUME = (1 << 5),
405 MUXFLAG_READ = (1 << 6),
406 MUXFLAG_WRITE = (1 << 7),
407 MUXFLAG_COMBINED = (1 << 8),
408 MUXFLAG_UID = (1 << 9),
409 MUXFLAG_VMRECIPIENTS = (1 << 10),
410 MUXFLAG_BEEP = (1 << 11),
411 MUXFLAG_BEEP_START = (1 << 12),
412 MUXFLAG_BEEP_STOP = (1 << 13),
413 MUXFLAG_DEPRECATED_RWSYNC = (1 << 14),
414 MUXFLAG_NO_RWSYNC = (1 << 15),
415 MUXFLAG_AUTO_DELETE = (1 << 16),
416 MUXFLAG_REAL_CALLERID = (1 << 17),
417};
@ MUXFLAG_VMRECIPIENTS
@ MUXFLAG_READ
@ MUXFLAG_AUTO_DELETE
@ MUXFLAG_DEPRECATED_RWSYNC
@ MUXFLAG_REAL_CALLERID
@ MUXFLAG_WRITEVOLUME
@ 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 1799 of file app_mixmonitor.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

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

554{
555 /* recipients are in a single string with a format format resembling "mailbox@context/INBOX,mailbox2@context2,mailbox3@context3/Work" */
556 char *cur_mailbox = ast_strdupa(vm_recipients);
557 char *cur_context;
558 char *cur_folder;
559 char *next;
560 int elements_processed = 0;
561
562 while (!ast_strlen_zero(cur_mailbox)) {
563 ast_debug(3, "attempting to add next element %d from %s\n", elements_processed, cur_mailbox);
564 if ((next = strchr(cur_mailbox, ',')) || (next = strchr(cur_mailbox, '&'))) {
565 *(next++) = '\0';
566 }
567
568 if ((cur_folder = strchr(cur_mailbox, '/'))) {
569 *(cur_folder++) = '\0';
570 } else {
571 cur_folder = "INBOX";
572 }
573
574 if ((cur_context = strchr(cur_mailbox, '@'))) {
575 *(cur_context++) = '\0';
576 } else {
577 cur_context = "default";
578 }
579
580 if (!ast_strlen_zero(cur_mailbox) && !ast_strlen_zero(cur_context)) {
581 struct vm_recipient *recipient;
582 if (!(recipient = ast_malloc(sizeof(*recipient)))) {
583 ast_log(LOG_ERROR, "Failed to allocate recipient. Aborting function.\n");
584 return;
585 }
586 ast_copy_string(recipient->context, cur_context, sizeof(recipient->context));
587 ast_copy_string(recipient->mailbox, cur_mailbox, sizeof(recipient->mailbox));
588 ast_copy_string(recipient->folder, cur_folder, sizeof(recipient->folder));
589
590 /* Add to list */
591 ast_verb(4, "Adding %s@%s to recipient list\n", recipient->mailbox, recipient->context);
593 } else {
594 ast_log(LOG_ERROR, "Failed to properly parse extension and/or context from element %d of recipient string: %s\n", elements_processed, vm_recipients);
595 }
596
597 cur_mailbox = next;
598 elements_processed++;
599 }
600}
#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 1799 of file app_mixmonitor.c.

◆ clear_mixmonitor_methods()

static int clear_mixmonitor_methods ( void  )
static

Definition at line 1757 of file app_mixmonitor.c.

1758{
1760}
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 602 of file app_mixmonitor.c.

603{
604 struct vm_recipient *current;
606 /* Clear list element data */
608 }
609}
#define ast_free(a)
Definition: astmm.h:180
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.
Definition: linkedlists.h:833
size_t current
Definition: main/cli.c:113

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

646{
647 struct vm_recipient *recipient = NULL;
648 struct ast_vm_recording_data recording_data;
649 if (ast_string_field_init(&recording_data, 512)) {
650 ast_log(LOG_ERROR, "Failed to string_field_init, skipping copy_to_voicemail\n");
651 return;
652 }
653
654 /* Copy strings to stringfields that will be used for all recipients */
655 ast_string_field_set(&recording_data, recording_file, filename);
656 ast_string_field_set(&recording_data, recording_ext, ext);
661 /* and call_priority gets copied too */
662 recording_data.call_priority = mixmonitor->call_priority;
663
664 AST_LIST_TRAVERSE(&mixmonitor->recipient_list, recipient, list) {
665 /* context, mailbox, and folder need to be set per recipient */
666 ast_string_field_set(&recording_data, context, recipient->context);
667 ast_string_field_set(&recording_data, mailbox, recipient->mailbox);
668 ast_string_field_set(&recording_data, folder, recipient->folder);
669
670 ast_verb(4, "MixMonitor attempting to send voicemail copy to %s@%s\n", recording_data.mailbox,
671 recording_data.context);
672 ast_app_copy_recording_to_vm(&recording_data);
673 }
674
675 /* Free the string fields for recording_data before exiting the function. */
676 ast_string_field_free_memory(&recording_data);
677}
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 524 of file app_mixmonitor.c.

525{
530 }
531 /* kill the audiohook.*/
536}
#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:550
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:190
#define ast_mutex_lock(a)
Definition: lock.h:189
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 1113 of file app_mixmonitor.c.

1114{
1115 char *slash;
1116 char *ext;
1117
1118 ast_assert(len > 0);
1119
1120 if (ast_strlen_zero(filename)) {
1121 ast_log(LOG_WARNING, "No file name was provided for a file save option.\n");
1122 buffer[0] = 0;
1123 return buffer;
1124 }
1125
1126 /* If we don't have an absolute path, make one */
1127 if (*filename != '/') {
1128 char *build = ast_alloca(strlen(ast_config_AST_MONITOR_DIR) + strlen(filename) + 3);
1129 sprintf(build, "%s/%s", ast_config_AST_MONITOR_DIR, filename);
1130 filename = build;
1131 }
1132
1133 ast_copy_string(buffer, filename, len);
1134
1135 /* If the provided filename has a .wav49 extension, we need to convert it to .WAV to
1136 match the behavior of build_filename in main/file.c. Otherwise MIXMONITOR_FILENAME
1137 ends up referring to a file that does not/will not exist */
1138 ext = strrchr(buffer, '.');
1139 if (ext && !strcmp(ext, ".wav49")) {
1140 /* Change to WAV - we know we have at least 6 writeable bytes where 'ext' points,
1141 * so this is safe */
1142 memcpy(ext, ".WAV", sizeof(".WAV"));
1143 }
1144
1145 if ((slash = strrchr(filename, '/'))) {
1146 *slash = '\0';
1147 }
1148 ast_mkdir(filename, 0777);
1149
1150 return buffer;
1151}
#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:155
#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 1700 of file app_mixmonitor.c.

1702{
1703 struct ast_datastore *datastore;
1704 struct mixmonitor_ds *ds_data;
1706 AST_APP_ARG(id);
1707 AST_APP_ARG(key);
1708 );
1709
1711
1712 if (ast_strlen_zero(args.id) || ast_strlen_zero(args.key)) {
1713 ast_log(LOG_WARNING, "Not enough arguments provided to %s. "
1714 "An ID and key must be provided\n", cmd);
1715 return -1;
1716 }
1717
1718 ast_channel_lock(chan);
1719 datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, args.id);
1720 ast_channel_unlock(chan);
1721
1722 if (!datastore) {
1723 ast_log(LOG_WARNING, "Could not find MixMonitor with ID %s\n", args.id);
1724 return -1;
1725 }
1726
1727 ds_data = datastore->data;
1728
1729 if (!strcasecmp(args.key, "filename")) {
1730 ast_copy_string(buf, ds_data->filename, len);
1731 } else {
1732 ast_log(LOG_WARNING, "Unrecognized %s option %s\n", cmd, args.key);
1733 return -1;
1734 }
1735 return 0;
1736}
static const struct ast_datastore_info mixmonitor_ds_info
#define ast_channel_lock(chan)
Definition: channel.h:2922
#define ast_channel_unlock(chan)
Definition: channel.h:2923
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:2399
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 1375 of file app_mixmonitor.c.

1376{
1377 struct ast_channel *chan;
1378 struct ast_datastore *datastore = NULL;
1380
1381 switch (cmd) {
1382 case CLI_INIT:
1383 e->command = "mixmonitor {start|stop|list}";
1384 e->usage =
1385 "Usage: mixmonitor start <chan_name> [args]\n"
1386 " The optional arguments are passed to the MixMonitor application.\n"
1387 " mixmonitor stop <chan_name> [args]\n"
1388 " The optional arguments are passed to the StopMixMonitor application.\n"
1389 " mixmonitor list <chan_name>\n";
1390 return NULL;
1391 case CLI_GENERATE:
1392 return ast_complete_channels(a->line, a->word, a->pos, a->n, 2);
1393 }
1394
1395 if (a->argc < 3) {
1396 return CLI_SHOWUSAGE;
1397 }
1398
1399 if (!(chan = ast_channel_get_by_name_prefix(a->argv[2], strlen(a->argv[2])))) {
1400 ast_cli(a->fd, "No channel matching '%s' found.\n", a->argv[2]);
1401 /* Technically this is a failure, but we don't want 2 errors printing out */
1402 return CLI_SUCCESS;
1403 }
1404
1405 if (!strcasecmp(a->argv[1], "start")) {
1406 mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
1407 } else if (!strcasecmp(a->argv[1], "stop")){
1408 stop_mixmonitor_exec(chan, (a->argc >= 4) ? a->argv[3] : "");
1409 } else if (!strcasecmp(a->argv[1], "list")) {
1410 ast_cli(a->fd, "MixMonitor ID\tFile\tReceive File\tTransmit File\n");
1411 ast_cli(a->fd, "=========================================================================\n");
1412 ast_channel_lock(chan);
1414 if (datastore->info == &mixmonitor_ds_info) {
1415 char *filename = "";
1416 char *filename_read = "";
1417 char *filename_write = "";
1418
1419 mixmonitor_ds = datastore->data;
1420 if (mixmonitor_ds->fs) {
1422 }
1423 if (mixmonitor_ds->fs_read) {
1424 filename_read = mixmonitor_ds->fs_read->filename;
1425 }
1426 if (mixmonitor_ds->fs_write) {
1427 filename_write = mixmonitor_ds->fs_write->filename;
1428 }
1429 ast_cli(a->fd, "%p\t%s\t%s\t%s\n", mixmonitor_ds, filename, filename_read, filename_write);
1430 }
1431 }
1432 ast_channel_unlock(chan);
1433 } else {
1434 chan = ast_channel_unref(chan);
1435 return CLI_SHOWUSAGE;
1436 }
1437
1438 chan = ast_channel_unref(chan);
1439
1440 return CLI_SUCCESS;
1441}
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:1434
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:2958
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:1865
@ 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
Definition: search.h:40
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 955 of file app_mixmonitor.c.

960{
961 pthread_t thread;
962 struct mixmonitor *mixmonitor;
963 char postprocess2[1024] = "";
964 char *datastore_id = NULL;
965
966 postprocess2[0] = 0;
967 /* If a post process system command is given attach it to the structure */
969 char *p1, *p2;
970
972 for (p2 = p1; *p2; p2++) {
973 if (*p2 == '^' && *(p2+1) == '{') {
974 *p2 = '$';
975 }
976 }
977 ast_channel_lock(chan);
978 pbx_substitute_variables_helper(chan, p1, postprocess2, sizeof(postprocess2) - 1);
979 ast_channel_unlock(chan);
980 }
981
982 /* Pre-allocate mixmonitor structure and spy */
983 if (!(mixmonitor = ast_calloc(1, sizeof(*mixmonitor)))) {
984 return -1;
985 }
986
987 /* Now that the struct has been calloced, go ahead and initialize the string fields. */
990 return -1;
991 }
992
993 /* Setup the actual spy before creating our thread */
996 return -1;
997 }
998
999 /* Copy over flags and channel name */
1001 if (!(mixmonitor->autochan = ast_autochan_setup(chan))) {
1003 return -1;
1004 }
1005
1006 if (!ast_strlen_zero(filename)) {
1008 }
1009
1012 }
1013
1016 }
1017
1018 if (setup_mixmonitor_ds(mixmonitor, chan, &datastore_id, beep_id)) {
1021 ast_free(datastore_id);
1022 return -1;
1023 }
1024
1025 if (!ast_strlen_zero(uid_channel_var)) {
1026 if (datastore_id) {
1027 pbx_builtin_setvar_helper(chan, uid_channel_var, datastore_id);
1028 }
1029 }
1030
1032
1033 if (!ast_strlen_zero(postprocess2)) {
1034 mixmonitor->post_process = ast_strdup(postprocess2);
1035 }
1036
1037 if (!ast_strlen_zero(recipients)) {
1038 char callerid[256];
1039
1040 ast_channel_lock(chan);
1041
1042 /* We use the connected line of the invoking channel for caller ID,
1043 * unless we've been told to use the Caller ID.
1044 * The initial use for this relied on Connected Line to get the
1045 * actual number for recording with Digium phones,
1046 * but in generic use the Caller ID is likely what people want.
1047 */
1048
1050 struct ast_party_caller *caller;
1051 caller = ast_channel_caller(chan);
1052 ast_debug(3, "Caller ID = %d - %s : %d - %s\n", caller->id.name.valid,
1053 caller->id.name.str, caller->id.number.valid,
1054 caller->id.number.str);
1055 ast_callerid_merge(callerid, sizeof(callerid),
1056 S_COR(caller->id.name.valid, caller->id.name.str, NULL),
1057 S_COR(caller->id.number.valid, caller->id.number.str, NULL),
1058 "Unknown");
1059 } else {
1062 ast_debug(3, "Connected Line CID = %d - %s : %d - %s\n", connected->id.name.valid,
1063 connected->id.name.str, connected->id.number.valid,
1064 connected->id.number.str);
1065 ast_callerid_merge(callerid, sizeof(callerid),
1066 S_COR(connected->id.name.valid, connected->id.name.str, NULL),
1067 S_COR(connected->id.number.valid, connected->id.number.str, NULL),
1068 "Unknown");
1069 }
1070
1072 ast_string_field_set(mixmonitor, call_extension, ast_channel_exten(chan));
1073 ast_string_field_set(mixmonitor, call_callerchan, ast_channel_name(chan));
1074 ast_string_field_set(mixmonitor, call_callerid, callerid);
1076
1077 ast_channel_unlock(chan);
1078
1080 }
1081
1085 }
1086
1087 if (readvol)
1089 if (writevol)
1091
1092 if (startmon(chan, &mixmonitor->audiohook)) {
1093 ast_log(LOG_WARNING, "Unable to add '%s' spy to channel '%s'\n",
1095 mixmonitor_ds_remove_and_free(chan, datastore_id);
1096 ast_free(datastore_id);
1100 return -1;
1101 }
1102
1103 ast_free(datastore_id);
1104
1105 /* reference be released at mixmonitor destruction */
1107
1109}
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:329
#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:2298
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:418
struct ast_party_id id
Caller party ID.
Definition: channel.h:420
Connected Line/Party information.
Definition: channel.h:456
struct ast_party_name name
Subscriber name.
Definition: channel.h:340
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:342
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:279
char * str
Subscriber name (Malloced)
Definition: channel.h:264
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:297
char * str
Subscriber phone number (Malloced)
Definition: channel.h:291
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 1778 of file app_mixmonitor.c.

1779{
1780 int res;
1781
1789 res |= set_mixmonitor_methods();
1790
1791 return res;
1792}
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:191
#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:1558
#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 1596 of file app_mixmonitor.c.

1597{
1598 struct ast_channel *c;
1599 const char *name = astman_get_header(m, "Channel");
1600 const char *id = astman_get_header(m, "ActionID");
1601 const char *file = astman_get_header(m, "File");
1602 const char *options = astman_get_header(m, "Options");
1603 const char *command = astman_get_header(m, "Command");
1604 char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
1605 struct ast_flags flags = { 0 };
1606 char *uid_channel_var = NULL;
1607 const char *mixmonitor_id = NULL;
1608 int res;
1609 char args[PATH_MAX];
1610
1611 if (ast_strlen_zero(name)) {
1612 astman_send_error(s, m, "No channel specified");
1613 return AMI_SUCCESS;
1614 }
1615
1617 if (!c) {
1618 astman_send_error(s, m, "No such channel");
1619 return AMI_SUCCESS;
1620 }
1621
1622 if (!ast_strlen_zero(options)) {
1624 }
1625
1626 snprintf(args, sizeof(args), "%s,%s,%s", file, options, command);
1627
1628 res = mixmonitor_exec(c, args);
1629
1631 uid_channel_var = opts[OPT_ARG_UID];
1633 mixmonitor_id = pbx_builtin_getvar_helper(c, uid_channel_var);
1634 mixmonitor_id = ast_strdupa(S_OR(mixmonitor_id, ""));
1636 }
1637
1638 if (res) {
1640 astman_send_error(s, m, "Could not start monitoring channel");
1641 return AMI_SUCCESS;
1642 }
1643
1644 astman_append(s, "Response: Success\r\n");
1645
1646 if (!ast_strlen_zero(id)) {
1647 astman_append(s, "ActionID: %s\r\n", id);
1648 }
1649
1650 if (!ast_strlen_zero(mixmonitor_id)) {
1651 astman_append(s, "MixMonitorID: %s\r\n", mixmonitor_id);
1652 }
1653
1654 astman_append(s, "\r\n");
1655
1657
1658 return AMI_SUCCESS;
1659}
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 *name)
Find a channel by name.
Definition: channel.c:1454
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:3389
const char * astman_get_header(const struct message *m, char *var)
Get header from manager transaction.
Definition: manager.c:3050
void astman_append(struct mansession *s, const char *fmt,...)
Definition: manager.c:3310
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:3056
#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 1488 of file app_mixmonitor.c.

1489{
1490 struct ast_channel *c;
1491 const char *name = astman_get_header(m, "Channel");
1492 const char *id = astman_get_header(m, "ActionID");
1493 const char *state = astman_get_header(m, "State");
1494 const char *direction = astman_get_header(m,"Direction");
1495 const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
1496 int clearmute = 1, mutedcount = 0;
1499 RAII_VAR(struct ast_json *, stasis_message_blob, NULL, ast_json_unref);
1500
1502 astman_send_error(s, m, "No direction specified. Must be read, write or both");
1503 return AMI_SUCCESS;
1504 }
1505
1506 if (!strcasecmp(direction, "read")) {
1508 } else if (!strcasecmp(direction, "write")) {
1510 } else if (!strcasecmp(direction, "both")) {
1512 } else {
1513 astman_send_error(s, m, "Invalid direction specified. Must be read, write or both");
1514 return AMI_SUCCESS;
1515 }
1516
1517 if (ast_strlen_zero(name)) {
1518 astman_send_error(s, m, "No channel specified");
1519 return AMI_SUCCESS;
1520 }
1521
1522 if (ast_strlen_zero(state)) {
1523 astman_send_error(s, m, "No state specified");
1524 return AMI_SUCCESS;
1525 }
1526
1527 clearmute = ast_false(state);
1528
1530 if (!c) {
1531 astman_send_error(s, m, "No such channel");
1532 return AMI_SUCCESS;
1533 }
1534
1535 if (ast_strlen_zero(mixmonitor_id)) {
1536 mutedcount = ast_audiohook_set_mute_all(c, mixmonitor_spy_type, flag, clearmute);
1537 if (mutedcount < 0) {
1539 astman_send_error(s, m, "Cannot set mute flag");
1540 return AMI_SUCCESS;
1541 }
1542 } else {
1543 if (mute_mixmonitor_instance(c, mixmonitor_id, flag, clearmute)) {
1545 astman_send_error(s, m, "Cannot set mute flag");
1546 return AMI_SUCCESS;
1547 }
1548 mutedcount = 1;
1549 }
1550
1551
1552 stasis_message_blob = ast_json_pack("{s: s, s: b, s: s, s: i}",
1553 "direction", direction,
1554 "state", ast_true(state),
1555 "mixmonitorid", mixmonitor_id,
1556 "count", mutedcount);
1557
1559 ast_channel_mixmonitor_mute_type(), stasis_message_blob);
1560
1561 if (stasis_message) {
1563 }
1564
1565 astman_append(s, "Response: Success\r\n");
1566
1567 if (!ast_strlen_zero(id)) {
1568 astman_append(s, "ActionID: %s\r\n", id);
1569 }
1570
1571 astman_append(s, "\r\n");
1572
1574
1575 return AMI_SUCCESS;
1576}
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:1380
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:1511
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 1661 of file app_mixmonitor.c.

1662{
1663 struct ast_channel *c;
1664 const char *name = astman_get_header(m, "Channel");
1665 const char *id = astman_get_header(m, "ActionID");
1666 const char *mixmonitor_id = astman_get_header(m, "MixMonitorID");
1667 int res;
1668
1669 if (ast_strlen_zero(name)) {
1670 astman_send_error(s, m, "No channel specified");
1671 return AMI_SUCCESS;
1672 }
1673
1675 if (!c) {
1676 astman_send_error(s, m, "No such channel");
1677 return AMI_SUCCESS;
1678 }
1679
1680 res = stop_mixmonitor_full(c, mixmonitor_id);
1681 if (res) {
1683 astman_send_error(s, m, "Could not stop monitoring channel");
1684 return AMI_SUCCESS;
1685 }
1686
1687 astman_append(s, "Response: Success\r\n");
1688
1689 if (!ast_strlen_zero(id)) {
1690 astman_append(s, "ActionID: %s\r\n", id);
1691 }
1692
1693 astman_append(s, "\r\n");
1694
1696
1697 return AMI_SUCCESS;
1698}
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 708 of file app_mixmonitor.c.

709{
710 int is_bridged;
711
713 is_bridged = ast_channel_is_bridged(autochan->chan);
715 return is_bridged;
716}
#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:10545
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 476 of file app_mixmonitor.c.

477{
478 unsigned char quitting = 0;
479
480 if (mixmonitor_ds->fs) {
481 quitting = 1;
484 ast_verb(2, "MixMonitor close filestream (mixed)\n");
485 }
486
487 if (mixmonitor_ds->fs_read) {
488 quitting = 1;
491 ast_verb(2, "MixMonitor close filestream (read)\n");
492 }
493
494 if (mixmonitor_ds->fs_write) {
495 quitting = 1;
498 ast_verb(2, "MixMonitor close filestream (write)\n");
499 }
500
501 if (quitting) {
503 }
504}
int ast_closestream(struct ast_filestream *f)
Closes a stream.
Definition: file.c:1111

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

938{
939 struct ast_datastore *datastore;
940
941 ast_channel_lock(chan);
942
943 datastore = ast_channel_datastore_find(chan, &mixmonitor_ds_info, datastore_id);
944
945 /*
946 * Currently the one place this function is called from guarantees a
947 * datastore is present, thus return checks can be avoided here.
948 */
949 ast_channel_datastore_remove(chan, datastore);
950 ast_datastore_free(datastore);
951
952 ast_channel_unlock(chan);
953}
int ast_channel_datastore_remove(struct ast_channel *chan, struct ast_datastore *datastore)
Remove a datastore from a channel.
Definition: channel.c:2394
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 1153 of file app_mixmonitor.c.

1154{
1155 int x, readvol = 0, writevol = 0;
1156 char *filename_read = NULL;
1157 char *filename_write = NULL;
1158 char filename_buffer[1024] = "";
1159 char *uid_channel_var = NULL;
1160 char beep_id[64] = "";
1161
1162 struct ast_flags flags = { 0 };
1163 char *recipients = NULL;
1164 char *parse;
1167 AST_APP_ARG(filename);
1169 AST_APP_ARG(post_process);
1170 );
1171
1172 if (ast_strlen_zero(data)) {
1173 ast_log(LOG_WARNING, "MixMonitor requires an argument (filename or ,t(filename) and/or r(filename)\n");
1174 return -1;
1175 }
1176
1177 parse = ast_strdupa(data);
1178
1180
1181 if (args.options) {
1182 char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
1183
1185
1187 ast_log(LOG_NOTICE, "The synchronization behavior enabled by the 'S' option is now the default"
1188 " and does not need to be specified.\n");
1189 }
1190
1193 ast_log(LOG_WARNING, "No volume level was provided for the heard volume ('v') option.\n");
1194 } else if ((sscanf(opts[OPT_ARG_READVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1195 ast_log(LOG_NOTICE, "Heard volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_READVOLUME]);
1196 } else {
1197 readvol = get_volfactor(x);
1198 }
1199 }
1200
1203 ast_log(LOG_WARNING, "No volume level was provided for the spoken volume ('V') option.\n");
1204 } else if ((sscanf(opts[OPT_ARG_WRITEVOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1205 ast_log(LOG_NOTICE, "Spoken volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_WRITEVOLUME]);
1206 } else {
1207 writevol = get_volfactor(x);
1208 }
1209 }
1210
1212 if (ast_strlen_zero(opts[OPT_ARG_VOLUME])) {
1213 ast_log(LOG_WARNING, "No volume level was provided for the combined volume ('W') option.\n");
1214 } else if ((sscanf(opts[OPT_ARG_VOLUME], "%2d", &x) != 1) || (x < -4) || (x > 4)) {
1215 ast_log(LOG_NOTICE, "Combined volume must be a number between -4 and 4, not '%s'\n", opts[OPT_ARG_VOLUME]);
1216 } else {
1217 readvol = writevol = get_volfactor(x);
1218 }
1219 }
1220
1223 ast_log(LOG_WARNING, "No voicemail recipients were specified for the vm copy ('m') option.\n");
1224 } else {
1225 recipients = ast_strdupa(opts[OPT_ARG_VMRECIPIENTS]);
1226 }
1227 }
1228
1230 filename_write = ast_strdupa(filename_parse(opts[OPT_ARG_WRITENAME], filename_buffer, sizeof(filename_buffer)));
1231 }
1232
1234 filename_read = ast_strdupa(filename_parse(opts[OPT_ARG_READNAME], filename_buffer, sizeof(filename_buffer)));
1235 }
1236
1238 uid_channel_var = opts[OPT_ARG_UID];
1239 }
1240
1242 const char *interval_str = S_OR(opts[OPT_ARG_BEEP_INTERVAL], "15");
1243 unsigned int interval = 15;
1244
1245 if (sscanf(interval_str, "%30u", &interval) != 1) {
1246 ast_log(LOG_WARNING, "Invalid interval '%s' for periodic beep. Using default of %u\n",
1247 interval_str, interval);
1248 }
1249
1250 if (ast_beep_start(chan, interval, beep_id, sizeof(beep_id))) {
1251 ast_log(LOG_WARNING, "Unable to enable periodic beep, please ensure func_periodic_hook is loaded.\n");
1252 return -1;
1253 }
1254 }
1255 }
1256 /* If there are no file writing arguments/options for the mix monitor, send a warning message and return -1 */
1257
1259 ast_log(LOG_WARNING, "MixMonitor requires an argument (filename)\n");
1260 return -1;
1261 }
1262
1263 /* If filename exists, try to create directories for it */
1264 if (!(ast_strlen_zero(args.filename))) {
1265 args.filename = ast_strdupa(filename_parse(args.filename, filename_buffer, sizeof(filename_buffer)));
1266 }
1267
1268 pbx_builtin_setvar_helper(chan, "MIXMONITOR_FILENAME", args.filename);
1269
1270 /* If launch_monitor_thread works, the module reference must not be released until it is finished. */
1272 if (launch_monitor_thread(chan,
1273 args.filename,
1274 flags.flags,
1275 readvol,
1276 writevol,
1277 args.post_process,
1278 filename_write,
1279 filename_read,
1280 uid_channel_var,
1281 recipients,
1282 beep_id)) {
1284 }
1285
1288 if (message) {
1290 }
1291
1292 return 0;
1293}
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 679 of file app_mixmonitor.c.

680{
681 /* Initialize the file if not already done so */
682 char *last_slash = NULL;
683 if (!ast_strlen_zero(filename)) {
684 if (!*fs && !*errflag && !mixmonitor->mixmonitor_ds->fs_quit) {
685 *oflags = O_CREAT | O_WRONLY;
686 *oflags |= ast_test_flag(mixmonitor, MUXFLAG_APPEND) ? O_APPEND : O_TRUNC;
687
688 last_slash = strrchr(filename, '/');
689
690 if ((*ext = strrchr(filename, '.')) && (*ext > last_slash)) {
691 **ext = '\0';
692 *ext = *ext + 1;
693 } else {
694 *ext = "raw";
695 }
696
697 if (!(*fs = ast_writefile(filename, *ext, NULL, *oflags, 0, 0666))) {
698 ast_log(LOG_ERROR, "Cannot open %s.%s\n", filename, *ext);
699 *errflag = 1;
700 } else {
701 struct ast_filestream *tmp = *fs;
703 }
704 }
705 }
706}
static int tmp()
Definition: bt_open.c:389
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:1423
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
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, mixmonitor_ds::fs_quit, LOG_ERROR, MAX, mixmonitor::mixmonitor_ds, MUXFLAG_APPEND, NULL, mixmonitor_ds::samp_rate, and tmp().

Referenced by mixmonitor_thread().

◆ mixmonitor_thread()

static void * mixmonitor_thread ( void *  obj)
static

Definition at line 718 of file app_mixmonitor.c.

719{
720 struct mixmonitor *mixmonitor = obj;
721 char *fs_ext = "";
722 char *fs_read_ext = "";
723 char *fs_write_ext = "";
724
725 struct ast_filestream **fs = NULL;
726 struct ast_filestream **fs_read = NULL;
727 struct ast_filestream **fs_write = NULL;
728
729 unsigned int oflags;
730 int errflag = 0;
731 struct ast_format *format_slin;
732
733 /* Keep callid association before any log messages */
734 if (mixmonitor->callid) {
736 }
737
738 ast_verb(2, "Begin MixMonitor Recording %s\n", mixmonitor->name);
739
741 fs_read = &mixmonitor->mixmonitor_ds->fs_read;
742 fs_write = &mixmonitor->mixmonitor_ds->fs_write;
743
745 mixmonitor_save_prep(mixmonitor, mixmonitor->filename, fs, &oflags, &errflag, &fs_ext);
746 mixmonitor_save_prep(mixmonitor, mixmonitor->filename_read, fs_read, &oflags, &errflag, &fs_read_ext);
747 mixmonitor_save_prep(mixmonitor, mixmonitor->filename_write, fs_write, &oflags, &errflag, &fs_write_ext);
748
750
752
753 /* The audiohook must enter and exit the loop locked */
756 struct ast_frame *fr = NULL;
757 struct ast_frame *fr_read = NULL;
758 struct ast_frame *fr_write = NULL;
759
761 &fr_read, &fr_write))) {
763
765 break;
766 }
767 continue;
768 }
769
770 /* audiohook lock is not required for the next block.
771 * Unlock it, but remember to lock it before looping or exiting */
773
777
778 /* Write out the frame(s) */
779 if ((*fs_read) && (fr_read)) {
780 struct ast_frame *cur;
781
782 for (cur = fr_read; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
783 ast_writestream(*fs_read, cur);
784 }
785 }
786
787 if ((*fs_write) && (fr_write)) {
788 struct ast_frame *cur;
789
790 for (cur = fr_write; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
791 ast_writestream(*fs_write, cur);
792 }
793 }
794
795 if ((*fs) && (fr)) {
796 struct ast_frame *cur;
797
798 for (cur = fr; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
799 ast_writestream(*fs, cur);
800 }
801 }
803 }
804 /* All done! free it. */
805 if (fr) {
806 ast_frame_free(fr, 0);
807 }
808 if (fr_read) {
809 ast_frame_free(fr_read, 0);
810 }
811 if (fr_write) {
812 ast_frame_free(fr_write, 0);
813 }
814
815 fr = NULL;
816 fr_write = NULL;
817 fr_read = NULL;
818
820 }
821
823
828 }
829
831
832 /* Datastore cleanup. close the filestream and wait for ds destruction */
837 }
839
840 /* kill the audiohook */
842
844 ast_verb(2, "Executing [%s]\n", mixmonitor->post_process);
846 }
847
848 ast_verb(2, "End MixMonitor Recording %s\n", mixmonitor->name);
849 ast_test_suite_event_notify("MIXMONITOR_END", "File: %s\r\n", mixmonitor->filename);
850
852 if (ast_strlen_zero(fs_ext)) {
853 ast_log(LOG_ERROR, "No file extension set for Mixmonitor %s. Skipping copy to voicemail.\n",
854 mixmonitor -> name);
855 } else {
856 ast_verb(3, "Copying recordings for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
858 }
859 if (!ast_strlen_zero(fs_read_ext)) {
860 ast_verb(3, "Copying read recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
862 }
863 if (!ast_strlen_zero(fs_write_ext)) {
864 ast_verb(3, "Copying write recording for Mixmonitor %s to voicemail recipients\n", mixmonitor->name);
866 }
867 } else {
868 ast_debug(3, "No recipients to forward monitor to, moving on.\n");
869 }
870
872 ast_debug(3, "Deleting our copies of recording files\n");
873 if (!ast_strlen_zero(fs_ext)) {
875 }
876 if (!ast_strlen_zero(fs_read_ext)) {
878 }
879 if (!ast_strlen_zero(fs_write_ext)) {
881 }
882 }
883
885
887 return NULL;
888}
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:451
void ast_audiohook_trigger_wait(struct ast_audiohook *audiohook)
Wait for audiohook trigger to be triggered.
Definition: audiohook.c:1094
@ AST_AUDIOHOOK_STATUS_RUNNING
Definition: audiohook.h:43
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:1878
int ast_filedelete(const char *filename, const char *fmt)
Deletes a file.
Definition: file.c:1141
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
int ast_callid_threadassoc_add(ast_callid callid)
Adds a known callid to thread storage of the calling thread.
Definition: logger.c:2320
#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:205
enum ast_audiohook_status status
Definition: audiohook.h:108
Definition of a media format.
Definition: format.c:43
Data structure associated with a single frame of data.
#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_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(), destroy_monitor_audiohook(), mixmonitor_ds::destruction_condition, mixmonitor_ds::destruction_ok, mixmonitor::filename, mixmonitor::filename_read, mixmonitor::filename_write, 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, name, mixmonitor::name, NULL, mixmonitor::post_process, mixmonitor::recipient_list, mixmonitor_ds::samp_rate, SAMPLES_PER_FRAME, ast_module_info::self, and ast_audiohook::status.

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

1446{
1447 struct ast_datastore *datastore = NULL;
1448 char *parse = "";
1450
1452 AST_APP_ARG(mixmonid);
1453 );
1454
1455 if (!ast_strlen_zero(data)) {
1456 parse = ast_strdupa(data);
1457 }
1458
1460
1461 ast_channel_lock(chan);
1462
1464 S_OR(args.mixmonid, NULL));
1465 if (!datastore) {
1466 ast_channel_unlock(chan);
1467 return -1;
1468 }
1469 mixmonitor_ds = datastore->data;
1470
1472
1473 if (mixmonitor_ds->audiohook) {
1474 if (clearmute) {
1476 } else {
1478 }
1479 }
1480
1482 ast_channel_unlock(chan);
1483
1484 return 0;
1485}
#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 1747 of file app_mixmonitor.c.

1748{
1752 };
1753
1755}
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 890 of file app_mixmonitor.c.

891{
892 struct ast_datastore *datastore = NULL;
894
895 if (!(mixmonitor_ds = ast_calloc(1, sizeof(*mixmonitor_ds)))) {
896 return -1;
897 }
898
899 if (ast_asprintf(datastore_id, "%p", mixmonitor_ds) == -1) {
900 ast_log(LOG_ERROR, "Failed to allocate memory for MixMonitor ID.\n");
902 return -1;
903 }
904
907
908 if (!(datastore = ast_datastore_alloc(&mixmonitor_ds_info, *datastore_id))) {
912 return -1;
913 }
914
919 }
920
921 mixmonitor_ds->samp_rate = 8000;
924 if (!ast_strlen_zero(beep_id)) {
926 }
927 datastore->data = mixmonitor_ds;
928
929 ast_channel_lock(chan);
930 ast_channel_datastore_add(chan, datastore);
931 ast_channel_unlock(chan);
932
934 return 0;
935}
#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:2385
#define ast_datastore_alloc(info, uid)
Definition: datastore.h:85
#define ast_cond_init(cond, attr)
Definition: lock.h:201
#define ast_mutex_init(pmutex)
Definition: lock.h:186

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

1579{
1580 char args[PATH_MAX];
1581
1582 if (ast_strlen_zero(options)) {
1583 snprintf(args, sizeof(args), "%s", filename);
1584 } else {
1585 snprintf(args, sizeof(args), "%s,%s", filename, options);
1586 }
1587
1588 return mixmonitor_exec(chan, args);
1589}

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

539{
540 if (!chan) {
541 return -1;
542 }
543
544 return ast_audiohook_attach(chan, audiohook);
545}
int ast_audiohook_attach(struct ast_channel *chan, struct ast_audiohook *audiohook)
Attach audiohook to channel.
Definition: audiohook.c:484

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

1592{
1593 return stop_mixmonitor_full(chan, mixmonitor_id);
1594}

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

1370{
1371 stop_mixmonitor_full(chan, data);
1372 return 0;
1373}

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

1296{
1297 struct ast_datastore *datastore = NULL;
1298 char *parse = "";
1300 const char *beep_id = NULL;
1302
1304 AST_APP_ARG(mixmonid);
1305 );
1306
1307 if (!ast_strlen_zero(data)) {
1308 parse = ast_strdupa(data);
1309 }
1310
1312
1313 ast_channel_lock(chan);
1314
1316 S_OR(args.mixmonid, NULL));
1317 if (!datastore) {
1318 ast_channel_unlock(chan);
1319 return -1;
1320 }
1321 mixmonitor_ds = datastore->data;
1322
1324
1325 /* closing the filestream here guarantees the file is available to the dialplan
1326 * after calling StopMixMonitor */
1328
1329 /* The mixmonitor thread may be waiting on the audiohook trigger.
1330 * In order to exit from the mixmonitor loop before waiting on channel
1331 * destruction, poke the audiohook trigger. */
1332 if (mixmonitor_ds->audiohook) {
1335 }
1340 }
1341
1344 }
1345
1347
1348 /* Remove the datastore so the monitor thread can exit */
1349 if (!ast_channel_datastore_remove(chan, datastore)) {
1350 ast_datastore_free(datastore);
1351 }
1352
1353 ast_channel_unlock(chan);
1354
1355 if (!ast_strlen_zero(beep_id)) {
1356 ast_beep_stop(chan, beep_id);
1357 }
1358
1361 NULL);
1362 if (message) {
1364 }
1365
1366 return 0;
1367}
void ast_audiohook_update_status(struct ast_audiohook *audiohook, enum ast_audiohook_status status)
Update audiohook's status.
Definition: audiohook.c:540
@ 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 1762 of file app_mixmonitor.c.

1763{
1764 int res;
1765
1769 res |= ast_manager_unregister("MixMonitorMute");
1770 res |= ast_manager_unregister("MixMonitor");
1771 res |= ast_manager_unregister("StopMixMonitor");
1773 res |= clear_mixmonitor_methods();
1774
1775 return res;
1776}
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:8057
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 1799 of file app_mixmonitor.c.

◆ app

const char* const app = "MixMonitor"
static

Definition at line 356 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 1799 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 1743 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 519 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 1738 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 }, [ '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 450 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 358 of file app_mixmonitor.c.

Referenced by load_module(), and unload_module().