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
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...
const char *	stasis_app_stored_recording_get_extension (struct stasis_app_stored_recording *recording)
	Returns the 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 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...
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...
#define	STASIS_APP_RECORDING_TERMINATE_INVALID   0
#define	STASIS_APP_RECORDING_TERMINATE_NONE   -1
#define	STASIS_APP_RECORDING_TERMINATE_ANY   -2
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 }
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...
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...
enum ast_record_if_exists	stasis_app_recording_if_exists_parse (const char *str)
	Parse a string into the if_exists enum. 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...
enum stasis_app_recording_state	stasis_app_recording_get_state (struct stasis_app_recording *recording)
	Gets the current state of a recording operation. More...
const char *	stasis_app_recording_get_name (struct stasis_app_recording *recording)
	Gets the unique name of a recording object. More...
struct stasis_app_recording *	stasis_app_recording_find_by_name (const char *name)
	Finds the recording object with the given name. More...
struct ast_json *	stasis_app_recording_to_json (const struct stasis_app_recording *recording)
	Construct a JSON model of a recording. 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_message_type *	stasis_app_recording_snapshot_type (void)
	Message type for recording updates. The data is an ast_channel_blob. 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.

Referenced by record_file(), and stasis_app_recording_termination_parse().

STASIS_APP_RECORDING_TERMINATE_INVALID

#define STASIS_APP_RECORDING_TERMINATE_INVALID   0

Definition at line 172 of file stasis_app_recording.h.

Referenced by ast_ari_bridges_record(), ast_ari_channels_record(), record_file(), and stasis_app_recording_termination_parse().

STASIS_APP_RECORDING_TERMINATE_NONE

#define STASIS_APP_RECORDING_TERMINATE_NONE   -1

Definition at line 173 of file stasis_app_recording.h.

Referenced by record_file(), and stasis_app_recording_termination_parse().

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.

NULL on error.

Definition at line 370 of file res_stasis_recording.c.

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::format, stasis_app_recording_options::if_exists, lock, LOG_WARNING, stasis_app_recording_options::max_duration_seconds, stasis_app_recording_options::max_silence_seconds, stasis_app_recording_options::name, NULL, OBJ_KEY, OBJ_NOLOCK, stasis_app_recording::options, RAII_VAR, record_file(), recording_cleanup(), recording_dtor(), 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().

{
   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;
}

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.

NULL if name not found.

Definition at line 473 of file res_stasis_recording.c.

References ao2_find, and OBJ_KEY.

Referenced by ast_ari_recordings_get_live(), and control_recording().

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

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.

NULL if recording ic NULL

Definition at line 467 of file res_stasis_recording.c.

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

{
   return recording->options->name;
}

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.

References stasis_app_recording::state.

{
   return 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.

References AST_RECORD_IF_EXISTS_APPEND, AST_RECORD_IF_EXISTS_ERROR, AST_RECORD_IF_EXISTS_FAIL, AST_RECORD_IF_EXISTS_OVERWRITE, and ast_strlen_zero.

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

{
   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;
}

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.
control	Media control operation.

Returns

STASIS_APP_RECORDING_OPER_OK on success.

stasis_app_recording_oper_results indicating failure.

Definition at line 590 of file res_stasis_recording.c.

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

{
   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;
}

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.

NULL on error.

Definition at line 151 of file res_stasis_recording.c.

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

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

{
   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;
}

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(), recording_to_json(), 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.

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.

References ast_strlen_zero, STASIS_APP_RECORDING_TERMINATE_ANY, STASIS_APP_RECORDING_TERMINATE_INVALID, and STASIS_APP_RECORDING_TERMINATE_NONE.

Referenced by ast_ari_bridges_record(), and ast_ari_channels_record().

{
   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;
}

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.

NULL on error.

Definition at line 478 of file res_stasis_recording.c.

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

{
   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);
}

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 389 of file stored.c.

Referenced by ast_ari_recordings_copy_stored().

{
   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) {

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 439 of file stored.c.

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.

NULL on error.

Definition at line 290 of file stored.c.

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

{
   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;

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.

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 310 of file stored.c.

References ao2_cleanup, ast_begins_with(), ast_config_AST_RECORDING_DIR, ast_free, ast_log, ast_std_free(), ast_string_field_build, ast_string_field_set, errno, stasis_app_stored_recording::file, stasis_app_stored_recording::file_with_ext, find_recording(), LOG_WARNING, 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(), and play_on_channel().

{
   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;

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.

NULL on error

Definition at line 71 of file stored.c.

References stasis_app_stored_recording::format, and NULL.

Referenced by ast_ari_recordings_get_stored_file().

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

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.

NULL on error.

Definition at line 53 of file stored.c.

References stasis_app_stored_recording::file, and NULL.

Referenced by play_on_channel().

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

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.

NULL on error

Definition at line 62 of file stored.c.

References stasis_app_stored_recording::file_with_ext, and NULL.

Referenced by ast_ari_recordings_get_stored_file().

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

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.

NULL on error.

Definition at line 446 of file stored.c.

References ast_json_pack(), stasis_app_stored_recording::file_with_ext, 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().

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

struct ast_json *stasis_app_stored_recording_to_json(
   struct stasis_app_stored_recording *recording)
{
   if (!recording) {
      return NULL;
   }