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/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. More...

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

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

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

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

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. More...

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

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

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

	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 = "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, .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 42 of file res_stasis_recording.c.

◆ RECORDING_CHECK

#define RECORDING_CHECK 0

Recording check is unimplemented. le sigh

Definition at line 48 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 45 of file res_stasis_recording.c.

Typedef Documentation

◆ recording_operation_cb

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

Definition at line 506 of file res_stasis_recording.c.

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 661 of file res_stasis_recording.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 661 of file res_stasis_recording.c.

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 661 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 261 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 629 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 296 of file res_stasis_recording.c.

{
    struct stasis_app_recording *recording = data;
    char *acceptdtmf;
    int res;
 
    ast_assert(recording != NULL);
 
    if (stasis_app_get_bridge(control)) {
        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 519 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 287 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 109 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 513 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 361 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 277 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 102 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 563 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 508 of file res_stasis_recording.c.

{
    return 0;
}

◆ recording_options_dtor()

static void recording_options_dtor ( void * obj )

static

Definition at line 144 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 536 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 217 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 252 of file res_stasis_recording.c.

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

References lock, recording_publish(), SCOPED_AO2LOCK, state, 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 529 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 73 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 568 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 543 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 370 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 473 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 467 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 461 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 194 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 590 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 151 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 169 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 478 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 122 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 550 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 647 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 = "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, .requires = "res_stasis", .load_pri = AST_MODPRI_APP_DEPEND }

static

Definition at line 661 of file res_stasis_recording.c.

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 661 of file res_stasis_recording.c.

◆ operations

recording_operation_cb operations[STASIS_APP_RECORDING_STATE_MAX][STASIS_APP_RECORDING_OPER_MAX]

Definition at line 573 of file res_stasis_recording.c.

Referenced by stasis_app_recording_operation().

◆ recordings

struct ao2_container* recordings

static

Container of all current recordings

Definition at line 51 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 273 of file res_stasis_recording.c.

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