res_stasis recording support. More...

#include "asterisk.h"
#include "asterisk/dsp.h"
#include "asterisk/file.h"
#include "asterisk/module.h"
#include "asterisk/paths.h"
#include "asterisk/bridge.h"
#include "asterisk/stasis_app_impl.h"
#include "asterisk/stasis_app_recording.h"
#include "asterisk/stasis_channels.h"

Include dependency graph for res_stasis_recording.c:

Go to the source code of this file.

Data Structures
struct	stasis_app_recording

Macros
#define	RECORDING_BUCKETS 127

#define	RECORDING_CHECK 0

#define	RECORDING_COMMENT NULL

Typedefs
typedef int(*	recording_operation_cb) (struct stasis_app_recording *recording)

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

struct ast_module *	AST_MODULE_SELF_SYM (void)

static enum stasis_app_control_channel_result	check_rule_recording (const struct stasis_app_control *control)

static int	load_module (void)

static int	record_file (struct stasis_app_control control, struct ast_channel chan, void *data)

static int	recording_cancel (struct stasis_app_recording *recording)

static void	recording_cleanup (void *data)

static int	recording_cmp (void obj, void arg, int flags)

static int	recording_disregard (struct stasis_app_recording *recording)

static void	recording_dtor (void *obj)

static void	recording_fail (struct stasis_app_control control, struct stasis_app_recording recording, const char *cause)

static int	recording_hash (const void *obj, int flags)

static int	recording_mute (struct stasis_app_recording *recording)

static int	recording_noop (struct stasis_app_recording *recording)

static void	recording_options_dtor (void *obj)

static int	recording_pause (struct stasis_app_recording *recording)

static void	recording_publish (struct stasis_app_recording recording, const char cause)

static void	recording_set_state (struct stasis_app_recording recording, enum stasis_app_recording_state state, const char cause)

static int	recording_stop (struct stasis_app_recording *recording)

static struct ast_json *	recording_to_json (struct stasis_message message, const struct stasis_message_sanitizer sanitize)

static int	recording_unmute (struct stasis_app_recording *recording)

static int	recording_unpause (struct stasis_app_recording *recording)

struct stasis_app_recording *	stasis_app_control_record (struct stasis_app_control control, struct stasis_app_recording_options options)
	Record media from a channel.

struct stasis_app_recording *	stasis_app_recording_find_by_name (const char *name)
	Finds the recording object with the given name.

const char *	stasis_app_recording_get_name (struct stasis_app_recording *recording)
	Gets the unique name of a recording object.

enum stasis_app_recording_state	stasis_app_recording_get_state (struct stasis_app_recording *recording)
	Gets the current state of a recording operation.

enum ast_record_if_exists	stasis_app_recording_if_exists_parse (const char *str)
	Parse a string into the if_exists enum.

enum stasis_app_recording_oper_results	stasis_app_recording_operation (struct stasis_app_recording *recording, enum stasis_app_recording_media_operation operation)
	Controls the media for a given recording operation.

struct stasis_app_recording_options *	stasis_app_recording_options_create (const char name, const char format)
	Allocate a recording options object.

char	stasis_app_recording_termination_parse (const char *str)
	Parse a string into the recording termination enum.

struct ast_json *	stasis_app_recording_to_json (const struct stasis_app_recording *recording)
	Construct a JSON model of a recording.

	STASIS_MESSAGE_TYPE_DEFN (stasis_app_recording_snapshot_type,.to_json=recording_to_json,)

static const char *	state_to_string (enum stasis_app_recording_state state)

static int	toggle_recording_mute (struct stasis_app_recording *recording, int desired_mute_state)

static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS \| AST_MODFLAG_LOAD_ORDER , .description = "Stasis application recording support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", .load_pri = AST_MODPRI_APP_DEPEND }

static const struct ast_module_info *	ast_module_info = &__mod_info

recording_operation_cb	operations [STASIS_APP_RECORDING_STATE_MAX][STASIS_APP_RECORDING_OPER_MAX]

static struct ao2_container *	recordings

static struct stasis_app_control_rule	rule_recording

Detailed Description

res_stasis recording support.

Author: David M. Lee, II dlee@.nosp@m.digi.nosp@m.um.co.nosp@m.m

Definition in file res_stasis_recording.c.

Macro Definition Documentation

◆ RECORDING_BUCKETS

#define RECORDING_BUCKETS 127

Number of hash buckets for recording container. Keep it prime!

Definition at line 43 of file res_stasis_recording.c.

◆ RECORDING_CHECK

#define RECORDING_CHECK 0

Recording check is unimplemented. le sigh

Definition at line 49 of file res_stasis_recording.c.

◆ RECORDING_COMMENT

#define RECORDING_COMMENT NULL

Comment is ignored by most formats, so we will ignore it, too.

Definition at line 46 of file res_stasis_recording.c.

Typedef Documentation

◆ recording_operation_cb

typedef int(* recording_operation_cb) (struct stasis_app_recording *recording)

Definition at line 519 of file res_stasis_recording.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 674 of file res_stasis_recording.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 674 of file res_stasis_recording.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 674 of file res_stasis_recording.c.

◆ check_rule_recording()

static enum stasis_app_control_channel_result check_rule_recording ( const struct stasis_app_control * control )

static

Definition at line 262 of file res_stasis_recording.c.

{
    return STASIS_APP_CHANNEL_RECORDING;
}

References STASIS_APP_CHANNEL_RECORDING.

◆ load_module()

static int load_module ( void )

static

Definition at line 642 of file res_stasis_recording.c.

{
    int r;
 
    r = STASIS_MESSAGE_TYPE_INIT(stasis_app_recording_snapshot_type);
    if (r != 0) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    recordings = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, RECORDING_BUCKETS,
        recording_hash, NULL, recording_cmp);
    if (!recordings) {
        STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_recording_snapshot_type);
        return AST_MODULE_LOAD_DECLINE;
    }
    return AST_MODULE_LOAD_SUCCESS;
}

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, NULL, RECORDING_BUCKETS, recording_cmp(), recording_hash(), recordings, stasis_app_recording_snapshot_type(), STASIS_MESSAGE_TYPE_CLEANUP, and STASIS_MESSAGE_TYPE_INIT.

◆ record_file()

static int record_file	(	struct stasis_app_control *	control,
		struct ast_channel *	chan,
		void *	data
	)

static

Definition at line 297 of file res_stasis_recording.c.

{
    struct stasis_app_recording *recording = data;
    struct ast_bridge *bridge;
    char *acceptdtmf;
    int res;
 
    ast_assert(recording != NULL);
 
    /*
     * Recording is not allowed while the channel is in a "real" bridge,
     * but ARI places an originated channel into an internal, invisible
     * holding bridge (the dial bridge) while dialing. That bridge is not
     * a bridge the application created - it is flagged invisible - so
     * recording must still be permitted there. Otherwise, channels.record
     * fails with "Cannot record channel while in bridge" even though the
     * application never joined the channel to a bridge of its own.
     * See GH issue #2044.
     */
    bridge = stasis_app_get_bridge(control);
    if (bridge && !ast_test_flag(&bridge->feature_flags, AST_BRIDGE_FLAG_INVISIBLE)) {
        ast_log(LOG_ERROR, "Cannot record channel while in bridge\n");
        recording_fail(control, recording, "Cannot record channel while in bridge");
        return -1;
    }
 
    switch (recording->options->terminate_on) {
    case STASIS_APP_RECORDING_TERMINATE_NONE:
    case STASIS_APP_RECORDING_TERMINATE_INVALID:
        acceptdtmf = "";
        break;
    case STASIS_APP_RECORDING_TERMINATE_ANY:
        acceptdtmf = "#*0123456789abcd";
        break;
    default:
        acceptdtmf = ast_alloca(2);
        acceptdtmf[0] = recording->options->terminate_on;
        acceptdtmf[1] = '\0';
    }
 
    res = ast_auto_answer(chan);
    if (res != 0) {
        ast_debug(3, "%s: Failed to answer\n",
            ast_channel_uniqueid(chan));
        recording_fail(control, recording, "Failed to answer channel");
        return -1;
    }
 
    recording_set_state(
        recording, STASIS_APP_RECORDING_STATE_RECORDING, NULL);
    ast_play_and_record_full(chan,
        NULL, /* playfile */
        recording->absolute_name,
        recording->options->max_duration_seconds,
        recording->options->format,
        &recording->duration.total,
        recording->options->max_silence_seconds ? &recording->duration.energy_only : NULL,
        recording->options->beep,
        -1, /* silencethreshold */
        recording->options->max_silence_seconds * 1000,
        NULL, /* path */
        acceptdtmf,
        NULL, /* canceldtmf */
        1, /* skip_confirmation_sound */
        recording->options->if_exists);
 
    ast_debug(3, "%s: Recording complete\n", ast_channel_uniqueid(chan));
 
    recording_set_state(
        recording, STASIS_APP_RECORDING_STATE_COMPLETE, NULL);
 
    stasis_app_control_unregister_add_rule(control, &rule_recording);
 
    return 0;
}

Referenced by stasis_app_control_record().

◆ recording_cancel()

static int recording_cancel ( struct stasis_app_recording * recording )

static

Definition at line 532 of file res_stasis_recording.c.

{
    int res = 0;
    recording->state = STASIS_APP_RECORDING_STATE_CANCELED;
    res |= stasis_app_control_queue_control(recording->control,
        AST_CONTROL_RECORD_CANCEL);
    res |= ast_filedelete(recording->absolute_name, NULL);
    return res;
}

References stasis_app_recording::absolute_name, AST_CONTROL_RECORD_CANCEL, ast_filedelete(), stasis_app_recording::control, NULL, stasis_app_control_queue_control(), STASIS_APP_RECORDING_STATE_CANCELED, and stasis_app_recording::state.

◆ recording_cleanup()

static void recording_cleanup ( void * data )

static

Definition at line 288 of file res_stasis_recording.c.

{
    struct stasis_app_recording *recording = data;
 
    ao2_unlink_flags(recordings, recording,
        OBJ_POINTER | OBJ_UNLINK | OBJ_NODATA);
    ao2_ref(recording, -1);
}

References ao2_ref, ao2_unlink_flags, OBJ_NODATA, OBJ_POINTER, OBJ_UNLINK, and recordings.

Referenced by stasis_app_control_record().

◆ recording_cmp()

static int recording_cmp	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 110 of file res_stasis_recording.c.

{
    struct stasis_app_recording *lhs = obj;
    struct stasis_app_recording *rhs = arg;
    const char *rhs_id = flags & OBJ_KEY ? arg : rhs->options->name;
 
    if (strcmp(lhs->options->name, rhs_id) == 0) {
        return CMP_MATCH | CMP_STOP;
    } else {
        return 0;
    }
}

References CMP_MATCH, CMP_STOP, stasis_app_recording_options::name, OBJ_KEY, and stasis_app_recording::options.

Referenced by load_module().

◆ recording_disregard()

static int recording_disregard ( struct stasis_app_recording * recording )

static

Definition at line 526 of file res_stasis_recording.c.

{
    recording->state = STASIS_APP_RECORDING_STATE_CANCELED;
    return 0;
}

References STASIS_APP_RECORDING_STATE_CANCELED, and stasis_app_recording::state.

◆ recording_dtor()

static void recording_dtor ( void * obj )

static

Definition at line 374 of file res_stasis_recording.c.

{
    struct stasis_app_recording *recording = obj;
 
    ast_free(recording->absolute_name);
    ao2_cleanup(recording->control);
    ao2_cleanup(recording->options);
}

References stasis_app_recording::absolute_name, ao2_cleanup, ast_free, stasis_app_recording::control, and stasis_app_recording::options.

Referenced by stasis_app_control_record().

◆ recording_fail()

static void recording_fail	(	struct stasis_app_control *	control,
		struct stasis_app_recording *	recording,
		const char *	cause
	)

static

Definition at line 278 of file res_stasis_recording.c.

{
    stasis_app_control_unregister_add_rule(control, &rule_recording);
 
    recording_set_state(
        recording, STASIS_APP_RECORDING_STATE_FAILED, cause);
}

References recording_set_state(), rule_recording, stasis_app_control_unregister_add_rule(), and STASIS_APP_RECORDING_STATE_FAILED.

Referenced by record_file().

◆ recording_hash()

static int recording_hash	(	const void *	obj,
		int	flags
	)

static

Definition at line 103 of file res_stasis_recording.c.

{
    const struct stasis_app_recording *recording = obj;
    const char *id = flags & OBJ_KEY ? obj : recording->options->name;
    return ast_str_hash(id);
}

References ast_str_hash(), stasis_app_recording_options::name, OBJ_KEY, and stasis_app_recording::options.

Referenced by load_module().

◆ recording_mute()

static int recording_mute ( struct stasis_app_recording * recording )

static

Definition at line 576 of file res_stasis_recording.c.

{
    return toggle_recording_mute(recording, 1);
}

References toggle_recording_mute().

◆ recording_noop()

static int recording_noop ( struct stasis_app_recording * recording )

static

Definition at line 521 of file res_stasis_recording.c.

{
    return 0;
}

◆ recording_options_dtor()

static void recording_options_dtor ( void * obj )

static

Definition at line 145 of file res_stasis_recording.c.

{
    struct stasis_app_recording_options *options = obj;
 
    ast_string_field_free_memory(options);
}

References ast_string_field_free_memory, and options.

Referenced by stasis_app_recording_options_create().

◆ recording_pause()

static int recording_pause ( struct stasis_app_recording * recording )

static

Definition at line 549 of file res_stasis_recording.c.

{
    recording->state = STASIS_APP_RECORDING_STATE_PAUSED;
    return stasis_app_control_queue_control(recording->control,
        AST_CONTROL_RECORD_SUSPEND);
}

References AST_CONTROL_RECORD_SUSPEND, stasis_app_recording::control, stasis_app_control_queue_control(), STASIS_APP_RECORDING_STATE_PAUSED, and stasis_app_recording::state.

◆ recording_publish()

static void recording_publish	(	struct stasis_app_recording *	recording,
		const char *	cause
	)

static

Definition at line 218 of file res_stasis_recording.c.

{
    RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
 
    ast_assert(recording != NULL);
 
    json = stasis_app_recording_to_json(recording);
    if (json == NULL) {
        return;
    }
 
    if (!ast_strlen_zero(cause)) {
        struct ast_json *failure_cause = ast_json_string_create(cause);
 
        if (!failure_cause) {
            return;
        }
 
        if (ast_json_object_set(json, "cause", failure_cause)) {
            return;
        }
    }
 
    message = ast_channel_blob_create_from_cache(
        stasis_app_control_get_channel_id(recording->control),
        stasis_app_recording_snapshot_type(), json);
    if (message == NULL) {
        return;
    }
 
    stasis_app_control_publish(recording->control, message);
}

References ao2_cleanup, ast_assert, ast_channel_blob_create_from_cache(), ast_json_object_set(), ast_json_string_create(), ast_json_unref(), ast_strlen_zero(), stasis_app_recording::control, NULL, RAII_VAR, stasis_app_control_get_channel_id(), stasis_app_control_publish(), stasis_app_recording_snapshot_type(), and stasis_app_recording_to_json().

Referenced by recording_set_state().

◆ recording_set_state()

static void recording_set_state	(	struct stasis_app_recording *	recording,
		enum stasis_app_recording_state	state,
		const char *	cause
	)

static

Definition at line 253 of file res_stasis_recording.c.

{
    SCOPED_AO2LOCK(lock, recording);
    recording->state = state;
    recording_publish(recording, cause);
}

References lock, recording_publish(), SCOPED_AO2LOCK, and stasis_app_recording::state.

Referenced by record_file(), and recording_fail().

◆ recording_stop()

static int recording_stop ( struct stasis_app_recording * recording )

static

Definition at line 542 of file res_stasis_recording.c.

{
    recording->state = STASIS_APP_RECORDING_STATE_COMPLETE;
    return stasis_app_control_queue_control(recording->control,
        AST_CONTROL_RECORD_STOP);
}

References AST_CONTROL_RECORD_STOP, stasis_app_recording::control, stasis_app_control_queue_control(), STASIS_APP_RECORDING_STATE_COMPLETE, and stasis_app_recording::state.

◆ recording_to_json()

static struct ast_json * recording_to_json	(	struct stasis_message *	message,
		const struct stasis_message_sanitizer *	sanitize
	)

static

Definition at line 74 of file res_stasis_recording.c.

{
    struct ast_channel_blob *channel_blob = stasis_message_data(message);
    struct ast_json *blob = channel_blob->blob;
    const char *state =
        ast_json_string_get(ast_json_object_get(blob, "state"));
    const char *type;
 
    if (!strcmp(state, "recording")) {
        type = "RecordingStarted";
    } else if (!strcmp(state, "done") || !strcasecmp(state, "canceled")) {
        type = "RecordingFinished";
    } else if (!strcmp(state, "failed")) {
        type = "RecordingFailed";
    } else {
        return NULL;
    }
 
    return ast_json_pack("{s: s, s: o?, s: O}",
        "type", type,
        "timestamp", ast_json_timeval(*stasis_message_timestamp(message), NULL),
        "recording", blob);
}

References ast_json_object_get(), ast_json_pack(), ast_json_string_get(), ast_json_timeval(), ast_channel_blob::blob, NULL, stasis_message_data(), stasis_message_timestamp(), and type.

◆ recording_unmute()

static int recording_unmute ( struct stasis_app_recording * recording )

static

Definition at line 581 of file res_stasis_recording.c.

{
    return toggle_recording_mute(recording, 0);
}

References toggle_recording_mute().

◆ recording_unpause()

static int recording_unpause ( struct stasis_app_recording * recording )

static

Definition at line 556 of file res_stasis_recording.c.

{
    recording->state = STASIS_APP_RECORDING_STATE_RECORDING;
    return stasis_app_control_queue_control(recording->control,
        AST_CONTROL_RECORD_SUSPEND);
}

References AST_CONTROL_RECORD_SUSPEND, stasis_app_recording::control, stasis_app_control_queue_control(), STASIS_APP_RECORDING_STATE_RECORDING, and stasis_app_recording::state.

◆ stasis_app_control_record()

struct stasis_app_recording * stasis_app_control_record	(	struct stasis_app_control *	control,
		struct stasis_app_recording_options *	options
	)

Record media from a channel.

A reference to the options object may be kept, so it MUST NOT be modified after calling this function.

On error, errno is set to indicate the failure reason.

EINVAL: Invalid input.
EEXIST: A recording with that name is in session.
ENOMEM: Out of memory.

Parameters

control	Control for `res_stasis`.
options	Recording options.

Returns: Recording control object.

Return values

NULL on error.

Definition at line 383 of file res_stasis_recording.c.

{
    struct stasis_app_recording *recording;
    char *last_slash;
 
    errno = 0;
 
    if (options == NULL ||
        ast_strlen_zero(options->name) ||
        ast_strlen_zero(options->format) ||
        options->max_silence_seconds < 0 ||
        options->max_duration_seconds < 0) {
        errno = EINVAL;
        return NULL;
    }
 
    ast_debug(3, "%s: Sending record(%s.%s) command\n",
        stasis_app_control_get_channel_id(control), options->name,
        options->format);
 
    recording = ao2_alloc(sizeof(*recording), recording_dtor);
    if (!recording) {
        errno = ENOMEM;
        return NULL;
    }
    recording->duration.total = -1;
    recording->duration.energy_only = -1;
 
    ast_asprintf(&recording->absolute_name, "%s/%s",
        ast_config_AST_RECORDING_DIR, options->name);
 
    if (recording->absolute_name == NULL) {
        errno = ENOMEM;
        ao2_ref(recording, -1);
        return NULL;
    }
 
    if ((last_slash = strrchr(recording->absolute_name, '/'))) {
        *last_slash = '\0';
        if (ast_safe_mkdir(ast_config_AST_RECORDING_DIR,
                recording->absolute_name, 0777) != 0) {
            /* errno set by ast_mkdir */
            ao2_ref(recording, -1);
            return NULL;
        }
        *last_slash = '/';
    }
 
    ao2_ref(options, +1);
    recording->options = options;
    ao2_ref(control, +1);
    recording->control = control;
    recording->state = STASIS_APP_RECORDING_STATE_QUEUED;
 
    if ((recording->options->if_exists == AST_RECORD_IF_EXISTS_FAIL) &&
            (ast_fileexists(recording->absolute_name, NULL, NULL))) {
        ast_log(LOG_WARNING, "Recording file '%s' already exists and ifExists option is failure.\n",
            recording->absolute_name);
        errno = EEXIST;
        ao2_ref(recording, -1);
        return NULL;
    }
 
    {
        RAII_VAR(struct stasis_app_recording *, old_recording, NULL,
            ao2_cleanup);
 
        SCOPED_AO2LOCK(lock, recordings);
 
        old_recording = ao2_find(recordings, options->name,
            OBJ_KEY | OBJ_NOLOCK);
        if (old_recording) {
            ast_log(LOG_WARNING,
                "Recording %s already in progress\n",
                recording->options->name);
            errno = EEXIST;
            ao2_ref(recording, -1);
            return NULL;
        }
        ao2_link(recordings, recording);
    }
 
    stasis_app_control_register_add_rule(control, &rule_recording);
 
    stasis_app_send_command_async(control, record_file, ao2_bump(recording), recording_cleanup);
 
    return recording;
}

References stasis_app_recording::absolute_name, ao2_alloc, ao2_bump, ao2_cleanup, ao2_find, ao2_link, ao2_ref, ast_asprintf, ast_config_AST_RECORDING_DIR, ast_debug, ast_fileexists(), ast_log, AST_RECORD_IF_EXISTS_FAIL, ast_safe_mkdir(), ast_strlen_zero(), stasis_app_recording::control, stasis_app_recording::duration, stasis_app_recording::energy_only, errno, stasis_app_recording_options::if_exists, lock, LOG_WARNING, stasis_app_recording_options::name, NULL, OBJ_KEY, OBJ_NOLOCK, stasis_app_recording::options, options, RAII_VAR, record_file(), recording_cleanup(), recording_dtor(), recordings, rule_recording, SCOPED_AO2LOCK, stasis_app_control_get_channel_id(), stasis_app_control_register_add_rule(), STASIS_APP_RECORDING_STATE_QUEUED, stasis_app_send_command_async(), stasis_app_recording::state, and stasis_app_recording::total.

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

◆ stasis_app_recording_find_by_name()

struct stasis_app_recording * stasis_app_recording_find_by_name ( const char * name )

Finds the recording object with the given name.

Parameters

name	Name of the recording object to find.

Returns: Associated stasis_app_recording object.

Return values

NULL	if name not found.

Definition at line 486 of file res_stasis_recording.c.

{
    return ao2_find(recordings, name, OBJ_KEY);
}

References ao2_find, name, OBJ_KEY, and recordings.

Referenced by ast_ari_recordings_get_live(), and control_recording().

◆ stasis_app_recording_get_name()

const char * stasis_app_recording_get_name ( struct stasis_app_recording * recording )

Gets the unique name of a recording object.

Parameters

recording Recording control object.

Returns: recording's name.

Return values

NULL	if recording ic `NULL`

Definition at line 480 of file res_stasis_recording.c.

{
    return recording->options->name;
}

References stasis_app_recording_options::name, and stasis_app_recording::options.

◆ stasis_app_recording_get_state()

enum stasis_app_recording_state stasis_app_recording_get_state ( struct stasis_app_recording * recording )

Gets the current state of a recording operation.

Parameters

recording Recording control object.

Returns: The state of the recording object.

Definition at line 474 of file res_stasis_recording.c.

{
    return recording->state;
}

References stasis_app_recording::state.

◆ stasis_app_recording_if_exists_parse()

enum ast_record_if_exists stasis_app_recording_if_exists_parse ( const char * str )

Parse a string into the if_exists enum.

Parameters

str	String to parse.

Returns: How to handle an existing file.; -1 on error.

Definition at line 195 of file res_stasis_recording.c.

{
    if (ast_strlen_zero(str)) {
        /* Default value */
        return AST_RECORD_IF_EXISTS_FAIL;
    }
 
    if (strcasecmp(str, "fail") == 0) {
        return AST_RECORD_IF_EXISTS_FAIL;
    }
 
    if (strcasecmp(str, "overwrite") == 0) {
        return AST_RECORD_IF_EXISTS_OVERWRITE;
    }
 
    if (strcasecmp(str, "append") == 0) {
        return AST_RECORD_IF_EXISTS_APPEND;
    }
 
    return AST_RECORD_IF_EXISTS_ERROR;
}

References AST_RECORD_IF_EXISTS_APPEND, AST_RECORD_IF_EXISTS_ERROR, AST_RECORD_IF_EXISTS_FAIL, AST_RECORD_IF_EXISTS_OVERWRITE, ast_strlen_zero(), and str.

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

◆ stasis_app_recording_operation()

enum stasis_app_recording_oper_results stasis_app_recording_operation	(	struct stasis_app_recording *	recording,
		enum stasis_app_recording_media_operation	operation
	)

Controls the media for a given recording operation.

Parameters

recording	Recording control object.
operation	Media control operation.

Return values

STASIS_APP_RECORDING_OPER_OK on success.

Returns: stasis_app_recording_oper_results indicating failure.

Definition at line 603 of file res_stasis_recording.c.

{
    recording_operation_cb cb;
    SCOPED_AO2LOCK(lock, recording);
 
    if ((unsigned int)recording->state >= STASIS_APP_RECORDING_STATE_MAX) {
        ast_log(LOG_WARNING, "Invalid recording state %u\n",
            recording->state);
        return -1;
    }
 
    if ((unsigned int)operation >= STASIS_APP_RECORDING_OPER_MAX) {
        ast_log(LOG_WARNING, "Invalid recording operation %u\n",
            operation);
        return -1;
    }
 
    cb = operations[recording->state][operation];
 
    if (!cb) {
        if (recording->state != STASIS_APP_RECORDING_STATE_RECORDING) {
            /* So we can be specific in our error message. */
            return STASIS_APP_RECORDING_OPER_NOT_RECORDING;
        } else {
            /* And, really, all operations should be valid during
             * recording */
            ast_log(LOG_ERROR,
                "Unhandled operation during recording: %u\n",
                operation);
            return STASIS_APP_RECORDING_OPER_FAILED;
        }
    }
 
    return cb(recording) ?
        STASIS_APP_RECORDING_OPER_FAILED : STASIS_APP_RECORDING_OPER_OK;
}

References ast_log, lock, LOG_ERROR, LOG_WARNING, operations, SCOPED_AO2LOCK, STASIS_APP_RECORDING_OPER_FAILED, STASIS_APP_RECORDING_OPER_MAX, STASIS_APP_RECORDING_OPER_NOT_RECORDING, STASIS_APP_RECORDING_OPER_OK, STASIS_APP_RECORDING_STATE_MAX, STASIS_APP_RECORDING_STATE_RECORDING, and stasis_app_recording::state.

Referenced by control_recording().

◆ stasis_app_recording_options_create()

struct stasis_app_recording_options * stasis_app_recording_options_create	(	const char *	name,
		const char *	format
	)

Allocate a recording options object.

Clean up with ao2_cleanup().

Parameters

name	Name of the recording.
format	Format to record in.

Returns: Newly allocated options object.

Return values

NULL on error.

Definition at line 152 of file res_stasis_recording.c.

{
    RAII_VAR(struct stasis_app_recording_options *, options, NULL,
        ao2_cleanup);
 
    options = ao2_alloc(sizeof(*options), recording_options_dtor);
 
    if (!options || ast_string_field_init(options, 128)) {
        return NULL;
    }
    ast_string_field_set(options, name, name);
    ast_string_field_set(options, format, format);
 
    ao2_ref(options, +1);
    return options;
}

References ao2_alloc, ao2_cleanup, ao2_ref, ast_string_field_init, ast_string_field_set, stasis_app_recording_options::format, name, NULL, options, RAII_VAR, and recording_options_dtor().

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

◆ stasis_app_recording_termination_parse()

char stasis_app_recording_termination_parse ( const char * str )

Parse a string into the recording termination enum.

Parameters

str	String to parse.

Returns: DTMF value to terminate on.

Return values

STASIS_APP_RECORDING_TERMINATE_NONE	to not terminate on DTMF.
STASIS_APP_RECORDING_TERMINATE_ANY	to terminate on any DTMF.
STASIS_APP_RECORDING_TERMINATE_INVALID	if input was invalid.

Definition at line 170 of file res_stasis_recording.c.

{
    if (ast_strlen_zero(str)) {
        return STASIS_APP_RECORDING_TERMINATE_NONE;
    }
 
    if (strcasecmp(str, "none") == 0) {
        return STASIS_APP_RECORDING_TERMINATE_NONE;
    }
 
    if (strcasecmp(str, "any") == 0) {
        return STASIS_APP_RECORDING_TERMINATE_ANY;
    }
 
    if (strcasecmp(str, "#") == 0) {
        return '#';
    }
 
    if (strcasecmp(str, "*") == 0) {
        return '*';
    }
 
    return STASIS_APP_RECORDING_TERMINATE_INVALID;
}

References ast_strlen_zero(), STASIS_APP_RECORDING_TERMINATE_ANY, STASIS_APP_RECORDING_TERMINATE_INVALID, STASIS_APP_RECORDING_TERMINATE_NONE, and str.

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

◆ stasis_app_recording_to_json()

struct ast_json * stasis_app_recording_to_json ( const struct stasis_app_recording * recording )

Construct a JSON model of a recording.

Parameters

recording Recording to conver.

Returns: JSON model.

Return values

NULL on error.

Definition at line 491 of file res_stasis_recording.c.

{
    RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
 
    if (recording == NULL) {
        return NULL;
    }
 
    json = ast_json_pack("{s: s, s: s, s: s, s: s}",
        "name", recording->options->name,
        "format", recording->options->format,
        "state", state_to_string(recording->state),
        "target_uri", recording->options->target);
    if (json && recording->duration.total > -1) {
        ast_json_object_set(json, "duration",
            ast_json_integer_create(recording->duration.total));
    }
    if (json && recording->duration.energy_only > -1) {
        ast_json_object_set(json, "talking_duration",
            ast_json_integer_create(recording->duration.energy_only));
        ast_json_object_set(json, "silence_duration",
            ast_json_integer_create(recording->duration.total - recording->duration.energy_only));
    }
 
    return ast_json_ref(json);
}

References ast_json_integer_create(), ast_json_object_set(), ast_json_pack(), ast_json_ref(), ast_json_unref(), stasis_app_recording::duration, stasis_app_recording::energy_only, stasis_app_recording_options::format, stasis_app_recording_options::name, NULL, stasis_app_recording::options, RAII_VAR, stasis_app_recording::state, state_to_string(), stasis_app_recording_options::target, and stasis_app_recording::total.

Referenced by ast_ari_bridges_record(), ast_ari_channels_record(), ast_ari_recordings_get_live(), and recording_publish().

◆ STASIS_MESSAGE_TYPE_DEFN()

STASIS_MESSAGE_TYPE_DEFN	(	stasis_app_recording_snapshot_type	,
		.	to_json = `recording_to_json`
	)

◆ state_to_string()

static const char * state_to_string ( enum stasis_app_recording_state state )

static

Definition at line 123 of file res_stasis_recording.c.

{
    switch (state) {
    case STASIS_APP_RECORDING_STATE_QUEUED:
        return "queued";
    case STASIS_APP_RECORDING_STATE_RECORDING:
        return "recording";
    case STASIS_APP_RECORDING_STATE_PAUSED:
        return "paused";
    case STASIS_APP_RECORDING_STATE_COMPLETE:
        return "done";
    case STASIS_APP_RECORDING_STATE_FAILED:
        return "failed";
    case STASIS_APP_RECORDING_STATE_CANCELED:
        return "canceled";
    case STASIS_APP_RECORDING_STATE_MAX:
        return "?";
    }
 
    return "?";
}

References STASIS_APP_RECORDING_STATE_CANCELED, STASIS_APP_RECORDING_STATE_COMPLETE, STASIS_APP_RECORDING_STATE_FAILED, STASIS_APP_RECORDING_STATE_MAX, STASIS_APP_RECORDING_STATE_PAUSED, STASIS_APP_RECORDING_STATE_QUEUED, and STASIS_APP_RECORDING_STATE_RECORDING.

Referenced by stasis_app_recording_to_json().

◆ toggle_recording_mute()

static int toggle_recording_mute	(	struct stasis_app_recording *	recording,
		int	desired_mute_state
	)

static

Definition at line 563 of file res_stasis_recording.c.

{
    if (recording->muted == desired_mute_state) {
        /* already in desired state */
        return 0;
    }
 
    recording->muted = desired_mute_state;
 
    return stasis_app_control_queue_control(recording->control,
        AST_CONTROL_RECORD_MUTE);
}

References AST_CONTROL_RECORD_MUTE, stasis_app_recording::control, stasis_app_recording::muted, and stasis_app_control_queue_control().

Referenced by recording_mute(), and recording_unmute().

◆ unload_module()

static int unload_module ( void )

static

Definition at line 660 of file res_stasis_recording.c.

{
    ao2_cleanup(recordings);
    recordings = NULL;
    STASIS_MESSAGE_TYPE_CLEANUP(stasis_app_recording_snapshot_type);
    return 0;
}

References ao2_cleanup, NULL, recordings, stasis_app_recording_snapshot_type(), and STASIS_MESSAGE_TYPE_CLEANUP.

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Stasis application recording support" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", .load_pri = AST_MODPRI_APP_DEPEND }

static

Definition at line 674 of file res_stasis_recording.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 674 of file res_stasis_recording.c.

◆ operations

recording_operation_cb operations[STASIS_APP_RECORDING_STATE_MAX][STASIS_APP_RECORDING_OPER_MAX]

Definition at line 586 of file res_stasis_recording.c.

                                                                                                   {
    [STASIS_APP_RECORDING_STATE_QUEUED][STASIS_APP_RECORDING_CANCEL] = recording_disregard,
    [STASIS_APP_RECORDING_STATE_QUEUED][STASIS_APP_RECORDING_STOP] = recording_disregard,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_CANCEL] = recording_cancel,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_STOP] = recording_stop,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_PAUSE] = recording_pause,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_UNPAUSE] = recording_noop,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_MUTE] = recording_mute,
    [STASIS_APP_RECORDING_STATE_RECORDING][STASIS_APP_RECORDING_UNMUTE] = recording_unmute,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_CANCEL] = recording_cancel,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_STOP] = recording_stop,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_PAUSE] = recording_noop,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_UNPAUSE] = recording_unpause,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_MUTE] = recording_mute,
    [STASIS_APP_RECORDING_STATE_PAUSED][STASIS_APP_RECORDING_UNMUTE] = recording_unmute,
};

Referenced by stasis_app_recording_operation().

◆ recordings

struct ao2_container* recordings

static

Container of all current recordings

Definition at line 52 of file res_stasis_recording.c.

Referenced by load_module(), recording_cleanup(), stasis_app_control_record(), stasis_app_recording_find_by_name(), and unload_module().

◆ rule_recording

struct stasis_app_control_rule rule_recording

static

Initial value:

= {
    .check_rule = check_rule_recording
}

Definition at line 274 of file res_stasis_recording.c.

                                                       {
    .check_rule = check_rule_recording
};

Referenced by record_file(), recording_fail(), and stasis_app_control_record().

Data Structures

Macros

Typedefs

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ RECORDING_BUCKETS

◆ RECORDING_CHECK

◆ RECORDING_COMMENT

Typedef Documentation

◆ recording_operation_cb

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AST_MODULE_SELF_SYM()

◆ check_rule_recording()

◆ load_module()

◆ record_file()

◆ recording_cancel()

◆ recording_cleanup()

◆ recording_cmp()

◆ recording_disregard()

◆ recording_dtor()

◆ recording_fail()

◆ recording_hash()

◆ recording_mute()

◆ recording_noop()

◆ recording_options_dtor()

◆ recording_pause()

◆ recording_publish()

◆ recording_set_state()

◆ recording_stop()

◆ recording_to_json()

◆ recording_unmute()

◆ recording_unpause()

◆ stasis_app_control_record()

◆ stasis_app_recording_find_by_name()

◆ stasis_app_recording_get_name()

◆ stasis_app_recording_get_state()

◆ stasis_app_recording_if_exists_parse()

◆ stasis_app_recording_operation()

◆ stasis_app_recording_options_create()

◆ stasis_app_recording_termination_parse()

◆ stasis_app_recording_to_json()

◆ STASIS_MESSAGE_TYPE_DEFN()

◆ state_to_string()

◆ toggle_recording_mute()

◆ unload_module()

Variable Documentation

◆ __mod_info

◆ ast_module_info

◆ operations

◆ recordings

◆ rule_recording