stasis_app_recording.h File Reference

Stasis Application Recording API. See StasisApplication API" for detailed documentation. More...

#include "asterisk/app.h"
#include "asterisk/stasis_app.h"

Include dependency graph for stasis_app_recording.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	stasis_app_recording_options

Functions
int	stasis_app_stored_recording_copy (struct stasis_app_stored_recording *src_recording, const char *dst, struct stasis_app_stored_recording **dst_recording)
	Copy a recording. More...
int	stasis_app_stored_recording_delete (struct stasis_app_stored_recording *recording)
	Delete a recording from disk. More...
struct ao2_container *	stasis_app_stored_recording_find_all (void)
	Find all stored recordings on disk. More...
struct stasis_app_stored_recording *	stasis_app_stored_recording_find_by_name (const char *name)
	Creates a stored recording object, with the given name. More...
const char *	stasis_app_stored_recording_get_extension (struct stasis_app_stored_recording *recording)
	Returns the extension for this recording. More...
const char *	stasis_app_stored_recording_get_file (struct stasis_app_stored_recording *recording)
	Returns the filename for this recording, for use with streamfile. More...
const char *	stasis_app_stored_recording_get_filename (struct stasis_app_stored_recording *recording)
	Returns the full filename, with extension, for this recording. More...
struct ast_json *	stasis_app_stored_recording_to_json (struct stasis_app_stored_recording *recording)
	Convert stored recording info to JSON. More...
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_media_operation {   STASIS_APP_RECORDING_CANCEL , STASIS_APP_RECORDING_STOP , STASIS_APP_RECORDING_PAUSE , STASIS_APP_RECORDING_UNPAUSE ,   STASIS_APP_RECORDING_MUTE , STASIS_APP_RECORDING_UNMUTE , STASIS_APP_RECORDING_OPER_MAX }
enum	stasis_app_recording_oper_results { STASIS_APP_RECORDING_OPER_OK , STASIS_APP_RECORDING_OPER_FAILED , STASIS_APP_RECORDING_OPER_NOT_RECORDING }
	Possible results from a recording operation. 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...
struct stasis_message_type *	stasis_app_recording_snapshot_type (void)
	Message type for recording updates. The data is an ast_channel_blob. More...
enum	stasis_app_recording_state {   STASIS_APP_RECORDING_STATE_QUEUED , STASIS_APP_RECORDING_STATE_RECORDING , STASIS_APP_RECORDING_STATE_PAUSED , STASIS_APP_RECORDING_STATE_COMPLETE ,   STASIS_APP_RECORDING_STATE_FAILED , STASIS_APP_RECORDING_STATE_CANCELED , STASIS_APP_RECORDING_STATE_MAX }
#define	STASIS_APP_RECORDING_TERMINATE_ANY   -2
#define	STASIS_APP_RECORDING_TERMINATE_INVALID   0
#define	STASIS_APP_RECORDING_TERMINATE_NONE   -1
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...

Detailed Description

Stasis Application Recording API. See StasisApplication API" for detailed documentation.

Author

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

Since

12

Definition in file stasis_app_recording.h.

Macro Definition Documentation

STASIS_APP_RECORDING_TERMINATE_ANY

#define STASIS_APP_RECORDING_TERMINATE_ANY   -2

Definition at line 174 of file stasis_app_recording.h.

STASIS_APP_RECORDING_TERMINATE_INVALID

#define STASIS_APP_RECORDING_TERMINATE_INVALID   0

Definition at line 172 of file stasis_app_recording.h.

STASIS_APP_RECORDING_TERMINATE_NONE

#define STASIS_APP_RECORDING_TERMINATE_NONE   -1

Definition at line 173 of file stasis_app_recording.h.

Enumeration Type Documentation

stasis_app_recording_media_operation

enum stasis_app_recording_media_operation

Valid operation for controlling a recording.

Enumerator
STASIS_APP_RECORDING_CANCEL	Stop the recording, deleting the media file(s)
STASIS_APP_RECORDING_STOP	Stop the recording.
STASIS_APP_RECORDING_PAUSE	Pause the recording
STASIS_APP_RECORDING_UNPAUSE	Unpause the recording
STASIS_APP_RECORDING_MUTE	Mute the recording (record silence)
STASIS_APP_RECORDING_UNMUTE	Unmute the recording
STASIS_APP_RECORDING_OPER_MAX	Sentinel

Definition at line 155 of file stasis_app_recording.h.

                                          {
    /*! Stop the recording, deleting the media file(s) */
    STASIS_APP_RECORDING_CANCEL,
    /*! Stop the recording. */
    STASIS_APP_RECORDING_STOP,
    /*! Pause the recording */
    STASIS_APP_RECORDING_PAUSE,
    /*! Unpause the recording */
    STASIS_APP_RECORDING_UNPAUSE,
    /*! Mute the recording (record silence) */
    STASIS_APP_RECORDING_MUTE,
    /*! Unmute the recording */
    STASIS_APP_RECORDING_UNMUTE,
    /*! Sentinel */
    STASIS_APP_RECORDING_OPER_MAX,
};

stasis_app_recording_oper_results

enum stasis_app_recording_oper_results

Possible results from a recording operation.

Enumerator
STASIS_APP_RECORDING_OPER_OK	Operation completed successfully.
STASIS_APP_RECORDING_OPER_FAILED	Operation failed.
STASIS_APP_RECORDING_OPER_NOT_RECORDING	Operation failed b/c recording is not in session.

Definition at line 292 of file stasis_app_recording.h.

                                       {
    /*! Operation completed successfully. */
    STASIS_APP_RECORDING_OPER_OK,
    /*! Operation failed. */
    STASIS_APP_RECORDING_OPER_FAILED,
    /*! Operation failed b/c recording is not in session. */
    STASIS_APP_RECORDING_OPER_NOT_RECORDING,
};

stasis_app_recording_state

enum stasis_app_recording_state

State of a recording operation

Enumerator
STASIS_APP_RECORDING_STATE_QUEUED	The recording has not started yet
STASIS_APP_RECORDING_STATE_RECORDING	The media is currently recording
STASIS_APP_RECORDING_STATE_PAUSED	The media is currently paused
STASIS_APP_RECORDING_STATE_COMPLETE	The media has stopped recording
STASIS_APP_RECORDING_STATE_FAILED	The media has stopped recording, with error
STASIS_APP_RECORDING_STATE_CANCELED	The media has stopped recording, discard the recording file
STASIS_APP_RECORDING_STATE_MAX	Sentinel

Definition at line 137 of file stasis_app_recording.h.

                                {
    /*! The recording has not started yet */
    STASIS_APP_RECORDING_STATE_QUEUED,
    /*! The media is currently recording */
    STASIS_APP_RECORDING_STATE_RECORDING,
    /*! The media is currently paused */
    STASIS_APP_RECORDING_STATE_PAUSED,
    /*! The media has stopped recording */
    STASIS_APP_RECORDING_STATE_COMPLETE,
    /*! The media has stopped recording, with error */
    STASIS_APP_RECORDING_STATE_FAILED,
    /*! The media has stopped recording, discard the recording file */
    STASIS_APP_RECORDING_STATE_CANCELED,
    /*! Sentinel */
    STASIS_APP_RECORDING_STATE_MAX,
};

Function Documentation

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_snapshot_type()

struct stasis_message_type * stasis_app_recording_snapshot_type

(

void

)

Message type for recording updates. The data is an ast_channel_blob.

Referenced by load_module(), recording_publish(), and unload_module().

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_app_stored_recording_copy()

int stasis_app_stored_recording_copy	(	struct stasis_app_stored_recording *	src_recording,
		const char *	dst,
		struct stasis_app_stored_recording **	dst_recording
	)

Copy a recording.

Parameters

src_recording	The recording to copy
dst	The destination of the recording to make
dst_recording	If successful, the stored recording created as a result of the copy

Return values

0	on success
Non-zero	on error

Definition at line 398 of file stored.c.

{
    RAII_VAR(char *, full_path, NULL, ast_free);
    char *dst_file = ast_strdupa(dst);
    char *format;
    char *last_slash;
    int res;
 
    /* Drop the extension if specified, core will do this for us */
    format = strrchr(dst_file, '.');
    if (format) {
        *format = '\0';
    }
 
    /* See if any intermediary directories need to be made */
    last_slash = strrchr(dst_file, '/');
    if (last_slash) {
        RAII_VAR(char *, tmp_path, NULL, ast_free);
 
        *last_slash = '\0';
        if (ast_asprintf(&tmp_path, "%s/%s", ast_config_AST_RECORDING_DIR, dst_file) < 0) {
            return -1;
        }
        if (ast_safe_mkdir(ast_config_AST_RECORDING_DIR,
                tmp_path, 0777) != 0) {
            /* errno set by ast_mkdir */
            return -1;
        }
        *last_slash = '/';
        if (ast_asprintf(&full_path, "%s/%s", ast_config_AST_RECORDING_DIR, dst_file) < 0) {
            return -1;
        }
    } else {
        /* There is no directory portion */
        if (ast_asprintf(&full_path, "%s/%s", ast_config_AST_RECORDING_DIR, dst_file) < 0) {
            return -1;
        }
    }
 
    ast_verb(4, "Copying recording %s to %s (format %s)\n", src_recording->file,
        full_path, src_recording->format);
    res = ast_filecopy(src_recording->file, full_path, src_recording->format);
    if (!res) {
        *dst_recording = stasis_app_stored_recording_find_by_name(dst_file);
    }
 
    return res;
}

References ast_asprintf, ast_config_AST_RECORDING_DIR, ast_filecopy(), ast_free, ast_safe_mkdir(), ast_strdupa, ast_verb, stasis_app_stored_recording::file, stasis_app_stored_recording::format, NULL, RAII_VAR, and stasis_app_stored_recording_find_by_name().

Referenced by ast_ari_recordings_copy_stored().

stasis_app_stored_recording_delete()

int stasis_app_stored_recording_delete

(

struct stasis_app_stored_recording *

recording

)

Delete a recording from disk.

Parameters

recording

Recording to delete.

Returns

0 on success.

Non-zero on error.

Definition at line 448 of file stored.c.

{
    /* Path was validated when the recording object was created */
    return unlink(recording->file_with_ext);
}

References stasis_app_stored_recording::file_with_ext.

Referenced by ast_ari_recordings_delete_stored().

stasis_app_stored_recording_find_all()

struct ao2_container * stasis_app_stored_recording_find_all

(

void

)

Find all stored recordings on disk.

Returns

Container of stasis_app_stored_recording objects.

Return values

NULL

on error.

Definition at line 297 of file stored.c.

{
    struct ao2_container *recordings;
    int res;
 
    recordings = ao2_container_alloc_rbtree(AO2_ALLOC_OPT_LOCK_NOLOCK,
        AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, recording_sort, NULL);
    if (!recordings) {
        return NULL;
    }
 
    res = ast_file_read_dirs(ast_config_AST_RECORDING_DIR,
                 handle_scan_file, recordings, -1);
    if (res) {
        ao2_ref(recordings, -1);
        return NULL;
    }
 
    return recordings;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, AO2_CONTAINER_ALLOC_OPT_DUPS_REPLACE, ao2_container_alloc_rbtree, ao2_ref, ast_config_AST_RECORDING_DIR, ast_file_read_dirs(), handle_scan_file(), NULL, recording_sort(), and recordings.

Referenced by ast_ari_recordings_list_stored().

stasis_app_stored_recording_find_by_name()

struct stasis_app_stored_recording * stasis_app_stored_recording_find_by_name

(

const char *

name

)

Creates a stored recording object, with the given name.

Parameters

name	Name of the recording.

Returns

New recording object.

Return values

NULL	if recording is not found. errno is set to indicate why ENOMEM - out of memeory EACCES - file permissions (or recording is outside the config dir) Any of the error codes for stat(), opendir(), readdir()

Definition at line 318 of file stored.c.

{
    RAII_VAR(struct stasis_app_stored_recording *, recording, NULL,
        ao2_cleanup);
    RAII_VAR(char *, dir, NULL, ast_free);
    RAII_VAR(char *, file, NULL, ast_free);
    RAII_VAR(char *, file_with_ext, NULL, ast_free);
    int res;
    struct stat file_stat;
    int prefix_len = strlen(ast_config_AST_RECORDING_DIR);
 
    errno = 0;
 
    if (!name) {
        errno = EINVAL;
        return NULL;
    }
 
    recording = recording_alloc();
    if (!recording) {
        return NULL;
    }
 
    res = split_path(name, &dir, &file);
    if (res != 0) {
        return NULL;
    }
    ast_string_field_build(recording, file, "%s/%s", dir, file);
 
    if (!ast_begins_with(dir, ast_config_AST_RECORDING_DIR)) {
        /* It's possible that one or more component of the recording path is
         * a symbolic link, this would prevent dir from ever matching. */
        char *real_basedir = realpath(ast_config_AST_RECORDING_DIR, NULL);
 
        if (!real_basedir || !ast_begins_with(dir, real_basedir)) {
            /* Attempt to escape the recording directory */
            ast_log(LOG_WARNING, "Attempt to access invalid recording directory %s\n",
                dir);
            ast_std_free(real_basedir);
            errno = EACCES;
 
            return NULL;
        }
 
        prefix_len = strlen(real_basedir);
        ast_std_free(real_basedir);
    }
 
    /* The actual name of the recording is file with the config dir
     * prefix removed.
     */
    ast_string_field_set(recording, name, recording->file + prefix_len + 1);
 
    file_with_ext = find_recording(dir, file);
    if (!file_with_ext) {
        return NULL;
    }
    ast_string_field_set(recording, file_with_ext, file_with_ext);
    recording->format = strrchr(recording->file_with_ext, '.');
    if (!recording->format) {
        return NULL;
    }
    ++(recording->format);
 
    res = stat(file_with_ext, &file_stat);
    if (res != 0) {
        return NULL;
    }
 
    if (!S_ISREG(file_stat.st_mode)) {
        /* Let's not play if it's not a regular file */
        errno = EACCES;
        return NULL;
    }
 
    ao2_ref(recording, +1);
    return recording;
}

References ao2_cleanup, ao2_ref, ast_begins_with(), ast_config_AST_RECORDING_DIR, ast_free, ast_log, ast_std_free(), ast_string_field_build, ast_string_field_set, errno, make_ari_stubs::file, stasis_app_stored_recording::file_with_ext, find_recording(), LOG_WARNING, name, NULL, RAII_VAR, recording_alloc(), and split_path().

Referenced by ast_ari_recordings_copy_stored(), ast_ari_recordings_delete_stored(), ast_ari_recordings_get_stored(), ast_ari_recordings_get_stored_file(), play_on_channel(), and stasis_app_stored_recording_copy().

stasis_app_stored_recording_get_extension()

const char * stasis_app_stored_recording_get_extension

(

struct stasis_app_stored_recording *

recording

)

Returns the extension for this recording.

Since

14.0.0

Parameters

recording

Recording to query.

Returns

The extension associated with this recording.

Return values

NULL

on error

Definition at line 71 of file stored.c.

{
    if (!recording) {
        return NULL;
    }
    return recording->format;
}

References stasis_app_stored_recording::format, and NULL.

Referenced by ast_ari_recordings_get_stored_file().

stasis_app_stored_recording_get_file()

const char * stasis_app_stored_recording_get_file

(

struct stasis_app_stored_recording *

recording

)

Returns the filename for this recording, for use with streamfile.

The returned string will be valid until the recording object is freed.

Parameters

recording

Recording to query.

Returns

Absolute path to the recording file, without the extension.

Return values

NULL

on error.

Definition at line 53 of file stored.c.

{
    if (!recording) {
        return NULL;
    }
    return recording->file;
}

References stasis_app_stored_recording::file, and NULL.

Referenced by play_on_channel().

stasis_app_stored_recording_get_filename()

const char * stasis_app_stored_recording_get_filename

(

struct stasis_app_stored_recording *

recording

)

Returns the full filename, with extension, for this recording.

Since

14.0.0

Parameters

recording

Recording to query.

Returns

Absolute path to the recording file, with the extension.

Return values

NULL

on error

Definition at line 62 of file stored.c.

{
    if (!recording) {
        return NULL;
    }
    return recording->file_with_ext;
}

References stasis_app_stored_recording::file_with_ext, and NULL.

Referenced by ast_ari_recordings_get_stored_file().

stasis_app_stored_recording_to_json()

struct ast_json * stasis_app_stored_recording_to_json

(

struct stasis_app_stored_recording *

recording

)

Convert stored recording info to JSON.

Parameters

recording

Recording to convert.

Returns

JSON representation.

Return values

NULL

on error.

Definition at line 455 of file stored.c.

{
    if (!recording) {
        return NULL;
    }
 
    return ast_json_pack("{ s: s, s: s }",
        "name", recording->name,
        "format", recording->format);
}

References ast_json_pack(), stasis_app_stored_recording::format, stasis_app_stored_recording::name, and NULL.

Referenced by ast_ari_recordings_copy_stored(), ast_ari_recordings_get_stored(), and ast_ari_recordings_list_stored().