Wed Oct 28 11:52:24 2009

Asterisk developer's documentation


file.c File Reference

Generic File Format Support. More...

#include "asterisk.h"
#include <dirent.h>
#include <sys/stat.h>
#include <math.h>
#include "asterisk/_private.h"
#include "asterisk/paths.h"
#include "asterisk/mod_format.h"
#include "asterisk/cli.h"
#include "asterisk/channel.h"
#include "asterisk/sched.h"
#include "asterisk/translate.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/pbx.h"
#include "asterisk/linkedlists.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"

Include dependency graph for file.c:

Go to the source code of this file.

Data Structures

struct  formats

Defines

#define FORMAT   "%-10s %-10s %-20s\n"
#define FORMAT2   "%-10s %-10s %-20s\n"

Enumerations

enum  file_action {
  ACTION_EXISTS = 1, ACTION_DELETE, ACTION_RENAME, ACTION_OPEN,
  ACTION_COPY
}
enum  fsread_res { FSREAD_FAILURE, FSREAD_SUCCESS_SCHED, FSREAD_SUCCESS_NOSCHED }
enum  wrap_fn { WRAP_OPEN, WRAP_REWRITE }

Functions

int __ast_format_register (const struct ast_format *f, struct ast_module *mod)
 Register a new file format capability. Adds a format to Asterisk's format abilities.
static void __fini_formats (void)
static void __init_formats (void)
int ast_applystream (struct ast_channel *chan, struct ast_filestream *s)
 Applys a open stream to a channel.
int ast_closestream (struct ast_filestream *f)
 Closes a stream.
int ast_file_init (void)
int ast_filecopy (const char *filename, const char *filename2, const char *fmt)
 Copies a file.
int ast_filedelete (const char *filename, const char *fmt)
 Deletes a file.
int ast_fileexists (const char *filename, const char *fmt, const char *preflang)
 Checks for the existence of a given file.
static int ast_filehelper (const char *filename, const void *arg2, const char *fmt, const enum file_action action)
 perform various actions on a file. Second argument arg2 depends on the command: unused for EXISTS and DELETE destination file name (const char *) for COPY and RENAME struct ast_channel * for OPEN if fmt is NULL, OPEN will return the first matching entry, whereas other functions will run on all matching entries.
int ast_filerename (const char *filename, const char *filename2, const char *fmt)
 Renames a file.
int ast_format_unregister (const char *name)
 Unregisters a file format.
static int ast_fsread_audio (const void *data)
static int ast_fsread_video (const void *data)
struct ast_filestreamast_openstream (struct ast_channel *chan, const char *filename, const char *preflang)
 Opens stream for use in seeking, playing.
struct ast_filestreamast_openstream_full (struct ast_channel *chan, const char *filename, const char *preflang, int asis)
 Opens stream for use in seeking, playing.
struct ast_filestreamast_openvstream (struct ast_channel *chan, const char *filename, const char *preflang)
 Opens stream for use in seeking, playing.
int ast_playstream (struct ast_filestream *s)
 Play a open stream on a channel.
static enum fsread_res ast_readaudio_callback (struct ast_filestream *s)
struct ast_filestreamast_readfile (const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
 Starts reading from a file.
struct ast_frameast_readframe (struct ast_filestream *s)
 Read a frame from a filestream.
static enum fsread_res ast_readvideo_callback (struct ast_filestream *s)
int ast_seekstream (struct ast_filestream *fs, off_t sample_offset, int whence)
 Seeks into stream.
int ast_stopstream (struct ast_channel *tmp)
 Stops a stream.
int ast_stream_and_wait (struct ast_channel *chan, const char *file, const char *digits)
 stream file until digit If the file name is non-empty, try to play it.
int ast_stream_fastforward (struct ast_filestream *fs, off_t ms)
 Fast forward stream ms.
int ast_stream_rewind (struct ast_filestream *fs, off_t ms)
 Rewind stream ms.
int ast_streamfile (struct ast_channel *chan, const char *filename, const char *preflang)
 Streams a file.
off_t ast_tellstream (struct ast_filestream *fs)
 Tell where we are in a stream.
int ast_truncstream (struct ast_filestream *fs)
 Trunc stream at current location.
int ast_waitstream (struct ast_channel *c, const char *breakon)
 Waits for a stream to stop or digit to be pressed.
int ast_waitstream_exten (struct ast_channel *c, const char *context)
 Waits for a stream to stop or digit matching a valid one digit exten to be pressed.
int ast_waitstream_fr (struct ast_channel *c, const char *breakon, const char *forward, const char *reverse, int ms)
 Same as waitstream but allows stream to be forwarded or rewound.
int ast_waitstream_full (struct ast_channel *c, const char *breakon, int audiofd, int cmdfd)
struct ast_filestreamast_writefile (const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
 Starts writing a file.
int ast_writestream (struct ast_filestream *fs, struct ast_frame *f)
 Writes a frame to a stream.
static char * build_filename (const char *filename, const char *ext)
 construct a filename. Absolute pathnames are preserved, relative names are prefixed by the sounds/ directory. The wav49 suffix is replaced by 'WAV'. Returns a malloc'ed string to be freed by the caller.
static int copy (const char *infile, const char *outfile)
static int exts_compare (const char *exts, const char *type)
static int fileexists_core (const char *filename, const char *fmt, const char *preflang, char *buf, int buflen)
 helper routine to locate a file with a given format and language preference. Try preflang, preflang with stripped '_' suffix, or NULL. In the standard asterisk, language goes just before the last component. In an alternative configuration, the language should be a prefix to the actual filename.
static int fileexists_test (const char *filename, const char *fmt, const char *lang, char *buf, int buflen)
static void filestream_destructor (void *arg)
static int fn_wrapper (struct ast_filestream *s, const char *comment, enum wrap_fn mode)
static struct ast_filestreamget_filestream (struct ast_format *fmt, FILE *bfile)
static char * handle_cli_core_show_file_formats (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int is_absolute_path (const char *filename)
static int open_wrapper (struct ast_filestream *s)
static struct ast_frameread_frame (struct ast_filestream *s, int *whennext)
static int rewrite_wrapper (struct ast_filestream *s, const char *comment)
static int waitstream_core (struct ast_channel *c, const char *breakon, const char *forward, const char *reverse, int skip_ms, int audiofd, int cmdfd, const char *context)
 the core of all waitstream() functions

Variables

int ast_language_is_prefix = 1
struct ast_cli_entry cli_file []


Detailed Description

Generic File Format Support.

Author:
Mark Spencer <markster@digium.com>

Definition in file file.c.


Define Documentation

#define FORMAT   "%-10s %-10s %-20s\n"

#define FORMAT2   "%-10s %-10s %-20s\n"


Enumeration Type Documentation

Enumerator:
ACTION_EXISTS 
ACTION_DELETE 
ACTION_RENAME 
ACTION_OPEN 
ACTION_COPY 

Definition at line 391 of file file.c.

00391                  {
00392    ACTION_EXISTS = 1, /* return matching format if file exists, 0 otherwise */
00393    ACTION_DELETE, /* delete file, return 0 on success, -1 on error */
00394    ACTION_RENAME, /* rename file. return 0 on success, -1 on error */
00395    ACTION_OPEN,
00396    ACTION_COPY /* copy file. return 0 on success, -1 on error */
00397 };

enum fsread_res

Enumerator:
FSREAD_FAILURE 
FSREAD_SUCCESS_SCHED 
FSREAD_SUCCESS_NOSCHED 

Definition at line 727 of file file.c.

00727                 {
00728    FSREAD_FAILURE,
00729    FSREAD_SUCCESS_SCHED,
00730    FSREAD_SUCCESS_NOSCHED,
00731 };

enum wrap_fn

Enumerator:
WRAP_OPEN 
WRAP_REWRITE 

Definition at line 361 of file file.c.

00361 { WRAP_OPEN, WRAP_REWRITE };


Function Documentation

int __ast_format_register ( const struct ast_format f,
struct ast_module mod 
)

Register a new file format capability. Adds a format to Asterisk's format abilities.

Return values:
0 on success
-1 on failure

Definition at line 61 of file file.c.

References ast_calloc, ast_log(), AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, ast_format::buf_size, ast_format::exts, ast_format::list, LOG_WARNING, ast_format::module, and ast_format::name.

00062 {
00063    struct ast_format *tmp;
00064 
00065    AST_RWLIST_WRLOCK(&formats);
00066    AST_RWLIST_TRAVERSE(&formats, tmp, list) {
00067       if (!strcasecmp(f->name, tmp->name)) {
00068          AST_RWLIST_UNLOCK(&formats);
00069          ast_log(LOG_WARNING, "Tried to register '%s' format, already registered\n", f->name);
00070          return -1;
00071       }
00072    }
00073    if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
00074       AST_RWLIST_UNLOCK(&formats);
00075       return -1;
00076    }
00077    *tmp = *f;
00078    tmp->module = mod;
00079    if (tmp->buf_size) {
00080       /*
00081        * Align buf_size properly, rounding up to the machine-specific
00082        * alignment for pointers.
00083        */
00084       struct _test_align { void *a, *b; } p;
00085       int align = (char *)&p.b - (char *)&p.a;
00086       tmp->buf_size = ((f->buf_size + align - 1) / align) * align;
00087    }
00088    
00089    memset(&tmp->list, 0, sizeof(tmp->list));
00090 
00091    AST_RWLIST_INSERT_HEAD(&formats, tmp, list);
00092    AST_RWLIST_UNLOCK(&formats);
00093    ast_verb(2, "Registered file format %s, extension(s) %s\n", f->name, f->exts);
00094 
00095    return 0;
00096 }

static void __fini_formats ( void   )  [static]

Definition at line 59 of file file.c.

00062 {

static void __init_formats ( void   )  [static]

Definition at line 59 of file file.c.

00062 {

int ast_applystream ( struct ast_channel chan,
struct ast_filestream s 
)

Applys a open stream to a channel.

Parameters:
chan channel to work
s ast_filestream to apply
Return values:
0 on success.
-1 on failure.

Definition at line 844 of file file.c.

References ast_filestream::owner.

Referenced by ast_streamfile(), handle_getoption(), handle_recordfile(), handle_streamfile(), and speech_streamfile().

00845 {
00846    s->owner = chan;
00847    return 0;
00848 }

int ast_closestream ( struct ast_filestream f  ) 

Closes a stream.

Parameters:
f filestream to close Close a playback or recording stream
Return values:
0 on success.
-1 on failure.

Definition at line 887 of file file.c.

References ao2_ref, AST_FORMAT_AUDIO_MASK, AST_SCHED_DEL, ast_settimeout(), ast_filestream::fmt, ast_format::format, ast_filestream::owner, ast_channel::sched, ast_channel::stream, ast_channel::streamid, ast_channel::vstream, and ast_channel::vstreamid.

Referenced by __ast_play_and_record(), ast_filehelper(), ast_hangup(), ast_moh_files_next(), ast_monitor_start(), ast_monitor_stop(), ast_readfile(), ast_stopstream(), ast_writefile(), dictate_exec(), filestream_destructor(), gen_closestream(), handle_cli_file_convert(), handle_recordfile(), local_ast_moh_stop(), mixmonitor_ds_close_fs(), moh_files_release(), record_exec(), recordthread(), and rpt().

00888 {
00889    /* This used to destroy the filestream, but it now just decrements a refcount.
00890     * We need to force the stream to quit queuing frames now, because we might
00891     * change the writeformat, which could result in a subsequent write error, if
00892     * the format is different. */
00893 
00894    /* Stop a running stream if there is one */
00895    if (f->owner) {
00896       if (f->fmt->format < AST_FORMAT_AUDIO_MASK) {
00897          f->owner->stream = NULL;
00898          AST_SCHED_DEL(f->owner->sched, f->owner->streamid);
00899          ast_settimeout(f->owner, 0, NULL, NULL);
00900       } else {
00901          f->owner->vstream = NULL;
00902          AST_SCHED_DEL(f->owner->sched, f->owner->vstreamid);
00903       }
00904    }
00905 
00906    ao2_ref(f, -1);
00907    return 0;
00908 }

int ast_file_init ( void   ) 

Provided by file.c

Definition at line 1394 of file file.c.

References ast_cli_register_multiple().

Referenced by main().

01395 {
01396    ast_cli_register_multiple(cli_file, sizeof(cli_file) / sizeof(struct ast_cli_entry));
01397    return 0;
01398 }

int ast_filecopy ( const char *  oldname,
const char *  newname,
const char *  fmt 
)

Copies a file.

Parameters:
oldname name of the file you wish to copy (minus extension)
newname name you wish the file to be copied to (minus extension)
fmt the format of the file Copy a given file in a given format, or if fmt is NULL, then do so for all

Definition at line 938 of file file.c.

References ACTION_COPY, and ast_filehelper().

Referenced by copy_plain_file(), and vm_forwardoptions().

00939 {
00940    return ast_filehelper(filename, filename2, fmt, ACTION_COPY);
00941 }

int ast_filedelete ( const char *  filename,
const char *  fmt 
)

Deletes a file.

Parameters:
filename name of the file you wish to delete (minus the extension)
fmt of the file Delete a given file in a given format, or if fmt is NULL, then do so for all

Definition at line 928 of file file.c.

References ACTION_DELETE, and ast_filehelper().

Referenced by __ast_play_and_record(), announce_thread(), ast_monitor_start(), ast_monitor_stop(), conf_free(), conf_run(), handle_cli_file_convert(), leave_voicemail(), play_record_review(), record_exec(), setup_privacy_args(), vm_delete(), and vm_forwardoptions().

00929 {
00930    return ast_filehelper(filename, NULL, fmt, ACTION_DELETE);
00931 }

int ast_fileexists ( const char *  filename,
const char *  fmt,
const char *  preflang 
)

Checks for the existence of a given file.

Parameters:
filename name of the file you wish to check, minus the extension
fmt the format you wish to check (the extension)
preflang (the preferred language you wisht to find the file in) See if a given file exists in a given format. If fmt is NULL, any format is accepted.
Returns:
-1 if file does not exist, non-zero positive otherwise.

Definition at line 914 of file file.c.

References buf, and fileexists_core().

Referenced by announce_thread(), app_exec(), ast_moh_files_next(), ast_monitor_start(), ast_monitor_stop(), common_exec(), eivr_comm(), forward_message(), function_playback(), invent_message(), leave_voicemail(), minivm_delete_exec(), play_message(), play_message_callerid(), record_exec(), retrydial_exec(), rpt_tele_thread(), say_character_str_full(), say_digit_str_full(), say_phonetic_str_full(), sayname(), saynode(), setup_privacy_args(), vm_intro(), vm_newuser(), vm_options(), and vm_tempgreeting().

00915 {
00916    char *buf;
00917    int buflen;
00918 
00919    if (preflang == NULL)
00920       preflang = "";
00921    buflen = strlen(preflang) + strlen(filename) + 4;  /* room for everything */
00922    buf = alloca(buflen);
00923    if (buf == NULL)
00924       return 0;
00925    return fileexists_core(filename, fmt, preflang, buf, buflen);
00926 }

static int ast_filehelper ( const char *  filename,
const void *  arg2,
const char *  fmt,
const enum file_action  action 
) [static]

perform various actions on a file. Second argument arg2 depends on the command: unused for EXISTS and DELETE destination file name (const char *) for COPY and RENAME struct ast_channel * for OPEN if fmt is NULL, OPEN will return the first matching entry, whereas other functions will run on all matching entries.

Definition at line 408 of file file.c.

References ACTION_COPY, ACTION_DELETE, ACTION_EXISTS, ACTION_OPEN, ACTION_RENAME, ast_closestream(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_VIDEO_MASK, ast_free, ast_log(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdupa, build_filename(), chan, copy(), errno, ext, ast_format::exts, exts_compare(), f, ast_filestream::filename, ast_filestream::fmt, ast_format::format, get_filestream(), ast_filestream::lasttimeout, ast_format::list, LOG_WARNING, open_wrapper(), s, ast_channel::stream, strsep(), ast_filestream::trans, ast_channel::vstream, and ast_channel::writeformat.

Referenced by ast_filecopy(), ast_filedelete(), ast_filerename(), ast_openstream_full(), ast_openvstream(), and fileexists_test().

00409 {
00410    struct ast_format *f;
00411    int res = (action == ACTION_EXISTS) ? 0 : -1;
00412 
00413    AST_RWLIST_RDLOCK(&formats);
00414    /* Check for a specific format */
00415    AST_RWLIST_TRAVERSE(&formats, f, list) {
00416       char *stringp, *ext = NULL;
00417 
00418       if (fmt && !exts_compare(f->exts, fmt))
00419          continue;
00420 
00421       /* Look for a file matching the supported extensions.
00422        * The file must exist, and for OPEN, must match
00423        * one of the formats supported by the channel.
00424        */
00425       stringp = ast_strdupa(f->exts);  /* this is in the stack so does not need to be freed */
00426       while ( (ext = strsep(&stringp, "|")) ) {
00427          struct stat st;
00428          char *fn = build_filename(filename, ext);
00429 
00430          if (fn == NULL)
00431             continue;
00432 
00433          if ( stat(fn, &st) ) { /* file not existent */
00434             ast_free(fn);
00435             continue;
00436          }
00437          /* for 'OPEN' we need to be sure that the format matches
00438           * what the channel can process
00439           */
00440          if (action == ACTION_OPEN) {
00441             struct ast_channel *chan = (struct ast_channel *)arg2;
00442             FILE *bfile;
00443             struct ast_filestream *s;
00444 
00445             if ( !(chan->writeformat & f->format) &&
00446                  !((f->format & AST_FORMAT_AUDIO_MASK && fmt) ||
00447                  (f->format & AST_FORMAT_VIDEO_MASK && fmt))) {
00448                ast_free(fn);
00449                continue;   /* not a supported format */
00450             }
00451             if ( (bfile = fopen(fn, "r")) == NULL) {
00452                ast_free(fn);
00453                continue;   /* cannot open file */
00454             }
00455             s = get_filestream(f, bfile);
00456             if (!s) {
00457                fclose(bfile);
00458                ast_free(fn);  /* cannot allocate descriptor */
00459                continue;
00460             }
00461             if (open_wrapper(s)) {
00462                ast_free(fn);
00463                ast_closestream(s);
00464                continue;   /* cannot run open on file */
00465             }
00466             if (st.st_size == 0) {
00467                ast_log(LOG_WARNING, "File %s detected to have zero size.\n", fn);
00468             }
00469             /* ok this is good for OPEN */
00470             res = 1; /* found */
00471             s->lasttimeout = -1;
00472             s->fmt = f;
00473             s->trans = NULL;
00474             s->filename = NULL;
00475             if (s->fmt->format & AST_FORMAT_AUDIO_MASK) {
00476                if (chan->stream)
00477                   ast_closestream(chan->stream);
00478                chan->stream = s;
00479             } else {
00480                if (chan->vstream)
00481                   ast_closestream(chan->vstream);
00482                chan->vstream = s;
00483             }
00484             ast_free(fn);
00485             break;
00486          }
00487          switch (action) {
00488          case ACTION_OPEN:
00489             break;   /* will never get here */
00490 
00491          case ACTION_EXISTS:  /* return the matching format */
00492             res |= f->format;
00493             break;
00494 
00495          case ACTION_DELETE:
00496             if ( (res = unlink(fn)) )
00497                ast_log(LOG_WARNING, "unlink(%s) failed: %s\n", fn, strerror(errno));
00498             break;
00499 
00500          case ACTION_RENAME:
00501          case ACTION_COPY: {
00502             char *nfn = build_filename((const char *)arg2, ext);
00503             if (!nfn)
00504                ast_log(LOG_WARNING, "Out of memory\n");
00505             else {
00506                res = action == ACTION_COPY ? copy(fn, nfn) : rename(fn, nfn);
00507                if (res)
00508                   ast_log(LOG_WARNING, "%s(%s,%s) failed: %s\n",
00509                      action == ACTION_COPY ? "copy" : "rename",
00510                       fn, nfn, strerror(errno));
00511                ast_free(nfn);
00512             }
00513              }
00514             break;
00515 
00516          default:
00517             ast_log(LOG_WARNING, "Unknown helper %d\n", action);
00518          }
00519          ast_free(fn);
00520       }
00521    }
00522    AST_RWLIST_UNLOCK(&formats);
00523    return res;
00524 }

int ast_filerename ( const char *  oldname,
const char *  newname,
const char *  fmt 
)

Renames a file.

Parameters:
oldname the name of the file you wish to act upon (minus the extension)
newname the name you wish to rename the file to (minus the extension)
fmt the format of the file Rename a given file in a given format, or if fmt is NULL, then do so for all
Returns:
-1 on failure

Definition at line 933 of file file.c.

References ACTION_RENAME, and ast_filehelper().

Referenced by __ast_play_and_record(), ast_monitor_stop(), leave_voicemail(), play_record_review(), and rename_file().

00934 {
00935    return ast_filehelper(filename, filename2, fmt, ACTION_RENAME);
00936 }

int ast_format_unregister ( const char *  name  ) 

Unregisters a file format.

Parameters:
name the name of the format you wish to unregister Unregisters a format based on the name of the format.
Return values:
0 on success
-1 on failure to unregister

Definition at line 98 of file file.c.

References ast_free, ast_log(), AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, ast_format::list, LOG_WARNING, and ast_format::name.

Referenced by unload_module().

00099 {
00100    struct ast_format *tmp;
00101    int res = -1;
00102 
00103    AST_RWLIST_WRLOCK(&formats);
00104    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&formats, tmp, list) {
00105       if (!strcasecmp(name, tmp->name)) {
00106          AST_RWLIST_REMOVE_CURRENT(list);
00107          ast_free(tmp);
00108          res = 0;
00109       }
00110    }
00111    AST_RWLIST_TRAVERSE_SAFE_END;
00112    AST_RWLIST_UNLOCK(&formats);
00113 
00114    if (!res)
00115       ast_verb(2, "Unregistered format %s\n", name);
00116    else
00117       ast_log(LOG_WARNING, "Tried to unregister format %s, already unregistered\n", name);
00118 
00119    return res;
00120 }

static int ast_fsread_audio ( const void *  data  )  [static]

Definition at line 784 of file file.c.

References ast_readaudio_callback(), and FSREAD_SUCCESS_SCHED.

Referenced by ast_readaudio_callback().

00785 {
00786    struct ast_filestream *fs = (struct ast_filestream *)data;
00787    enum fsread_res res;
00788 
00789    res = ast_readaudio_callback(fs);
00790 
00791    if (res == FSREAD_SUCCESS_SCHED)
00792       return 1;
00793    
00794    return 0;
00795 }

static int ast_fsread_video ( const void *  data  )  [static]

Definition at line 831 of file file.c.

References ast_readvideo_callback(), and FSREAD_SUCCESS_SCHED.

Referenced by ast_readvideo_callback().

00832 {
00833    struct ast_filestream *fs = (struct ast_filestream *)data;
00834    enum fsread_res res;
00835 
00836    res = ast_readvideo_callback(fs);
00837 
00838    if (res == FSREAD_SUCCESS_SCHED)
00839       return 1;
00840    
00841    return 0;
00842 }

struct ast_filestream* ast_openstream ( struct ast_channel chan,
const char *  filename,
const char *  preflang 
) [read]

Opens stream for use in seeking, playing.

Parameters:
chan channel to work with
filename to use
preflang prefered language to use
Return values:
a ast_filestream pointer if it opens the file.
NULL on error.

Definition at line 619 of file file.c.

References ast_openstream_full().

Referenced by ast_streamfile(), dictate_exec(), handle_getoption(), handle_streamfile(), and speech_streamfile().

00620 {
00621    return ast_openstream_full(chan, filename, preflang, 0);
00622 }

struct ast_filestream* ast_openstream_full ( struct ast_channel chan,
const char *  filename,
const char *  preflang,
int  asis 
) [read]

Opens stream for use in seeking, playing.

Parameters:
chan channel to work with
filename to use
preflang prefered language to use
asis if set, don't clear generators
Return values:
a ast_filestream pointer if it opens the file.
NULL on error.

Definition at line 624 of file file.c.

References ACTION_OPEN, ast_deactivate_generator(), ast_filehelper(), AST_FORMAT_AUDIO_MASK, ast_log(), ast_set_write_format(), ast_stopstream(), buf, fileexists_core(), ast_channel::generator, LOG_WARNING, ast_channel::oldwriteformat, ast_channel::stream, and ast_channel::writeformat.

Referenced by ast_moh_files_next(), ast_openstream(), and gen_nextfile().

00625 {
00626    /* 
00627     * Use fileexists_core() to find a file in a compatible
00628     * language and format, set up a suitable translator,
00629     * and open the stream.
00630     */
00631    int fmts, res, buflen;
00632    char *buf;
00633 
00634    if (!asis) {
00635       /* do this first, otherwise we detect the wrong writeformat */
00636       ast_stopstream(chan);
00637       if (chan->generator)
00638          ast_deactivate_generator(chan);
00639    }
00640    if (preflang == NULL)
00641       preflang = "";
00642    buflen = strlen(preflang) + strlen(filename) + 4;
00643    buf = alloca(buflen);
00644    if (buf == NULL)
00645       return NULL;
00646    fmts = fileexists_core(filename, NULL, preflang, buf, buflen);
00647    if (fmts > 0)
00648       fmts &= AST_FORMAT_AUDIO_MASK;
00649    if (fmts < 1) {
00650       ast_log(LOG_WARNING, "File %s does not exist in any format\n", filename);
00651       return NULL;
00652    }
00653    chan->oldwriteformat = chan->writeformat;
00654    /* Set the channel to a format we can work with */
00655    res = ast_set_write_format(chan, fmts);
00656    res = ast_filehelper(buf, chan, NULL, ACTION_OPEN);
00657    if (res >= 0)
00658       return chan->stream;
00659    return NULL;
00660 }

struct ast_filestream* ast_openvstream ( struct ast_channel chan,
const char *  filename,
const char *  preflang 
) [read]

Opens stream for use in seeking, playing.

Parameters:
chan channel to work with
filename to use
preflang prefered language to use
Return values:
a ast_filestream pointer if it opens the file.
NULL on error.

Definition at line 662 of file file.c.

References ACTION_OPEN, ast_filehelper(), AST_FORMAT_AUDIO_MASK, AST_FORMAT_VIDEO_MASK, ast_getformatname(), ast_log(), buf, fileexists_core(), ast_filestream::fmt, format, LOG_WARNING, ast_channel::nativeformats, and ast_channel::vstream.

Referenced by ast_streamfile(), handle_getoption(), and handle_streamfile().

00663 {
00664    /* As above, but for video. But here we don't have translators
00665     * so we must enforce a format.
00666     */
00667    unsigned int format;
00668    char *buf;
00669    int buflen;
00670 
00671    if (preflang == NULL)
00672       preflang = "";
00673    buflen = strlen(preflang) + strlen(filename) + 4;
00674    buf = alloca(buflen);
00675    if (buf == NULL)
00676       return NULL;
00677 
00678    for (format = AST_FORMAT_AUDIO_MASK + 1; format <= AST_FORMAT_VIDEO_MASK; format = format << 1) {
00679       int fd;
00680       const char *fmt;
00681 
00682       if (!(chan->nativeformats & format))
00683          continue;
00684       fmt = ast_getformatname(format);
00685       if ( fileexists_core(filename, fmt, preflang, buf, buflen) < 1)   /* no valid format */
00686          continue;
00687       fd = ast_filehelper(buf, chan, fmt, ACTION_OPEN);
00688       if (fd >= 0)
00689          return chan->vstream;
00690       ast_log(LOG_WARNING, "File %s has video but couldn't be opened\n", filename);
00691    }
00692    return NULL;
00693 }

int ast_playstream ( struct ast_filestream s  ) 

Play a open stream on a channel.

Parameters:
s filestream to play
Return values:
0 on success.
-1 on failure.

Definition at line 850 of file file.c.

References AST_FORMAT_AUDIO_MASK, ast_readaudio_callback(), ast_readvideo_callback(), ast_filestream::fmt, ast_format::format, and FSREAD_FAILURE.

Referenced by ast_streamfile(), handle_getoption(), handle_streamfile(), and speech_streamfile().

00851 {
00852    enum fsread_res res;
00853 
00854    if (s->fmt->format & AST_FORMAT_AUDIO_MASK)
00855       res = ast_readaudio_callback(s);
00856    else
00857       res = ast_readvideo_callback(s);
00858 
00859    return (res == FSREAD_FAILURE) ? -1 : 0;
00860 }

static enum fsread_res ast_readaudio_callback ( struct ast_filestream s  )  [static]

Definition at line 735 of file file.c.

References ast_format_rate(), ast_frfree, ast_fsread_audio(), ast_log(), ast_sched_add(), ast_settimeout(), ast_write(), ast_filestream::fmt, ast_format::format, FSREAD_FAILURE, FSREAD_SUCCESS_NOSCHED, FSREAD_SUCCESS_SCHED, ast_filestream::lasttimeout, LOG_WARNING, ast_channel::name, ast_filestream::orig_chan_name, ast_filestream::owner, read_frame(), ast_channel::sched, ast_channel::streamid, and ast_channel::timingfd.

Referenced by ast_fsread_audio(), and ast_playstream().

00736 {
00737    int whennext = 0;
00738 
00739    while (!whennext) {
00740       struct ast_frame *fr;
00741 
00742       if (s->orig_chan_name && strcasecmp(s->owner->name, s->orig_chan_name)) {
00743          goto return_failure;
00744       }
00745 
00746       fr = read_frame(s, &whennext);
00747 
00748       if (!fr /* stream complete */ || ast_write(s->owner, fr) /* error writing */) {
00749          if (fr) {
00750             ast_log(LOG_WARNING, "Failed to write frame\n");
00751             ast_frfree(fr);
00752          }
00753          goto return_failure;
00754       } 
00755 
00756       if (fr) {
00757          ast_frfree(fr);
00758       }
00759    }
00760 
00761    if (whennext != s->lasttimeout) {
00762       if (s->owner->timingfd > -1) {
00763          float samp_rate = (float) ast_format_rate(s->fmt->format);
00764          unsigned int rate;
00765 
00766          rate = (unsigned int) roundf(samp_rate / ((float) whennext));
00767 
00768          ast_settimeout(s->owner, rate, ast_fsread_audio, s);
00769       } else {
00770          s->owner->streamid = ast_sched_add(s->owner->sched, 
00771             whennext / (ast_format_rate(s->fmt->format) / 1000), ast_fsread_audio, s);
00772       }
00773       s->lasttimeout = whennext;
00774       return FSREAD_SUCCESS_NOSCHED;
00775    }
00776    return FSREAD_SUCCESS_SCHED;
00777 
00778 return_failure:
00779    s->owner->streamid = -1;
00780    ast_settimeout(s->owner, 0, NULL, NULL);
00781    return FSREAD_FAILURE;
00782 }

struct ast_filestream* ast_readfile ( const char *  filename,
const char *  type,
const char *  comment,
int  flags,
int  check,
mode_t  mode 
) [read]

Starts reading from a file.

Parameters:
filename the name of the file to read from
type format of file you wish to read from
comment comment to go with
flags file flags
check (unimplemented, hence negligible)
mode Open mode Open an incoming file stream. flags are flags for the open() command, and if check is non-zero, then it will not read a file if there are any files that start with that name and have an extension Please note, this is a blocking function. Program execution will not return until ast_waitstream completes it's execution.
Return values:
a struct ast_filestream on success.
NULL on failure.

Definition at line 985 of file file.c.

References ast_closestream(), ast_free, ast_log(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, build_filename(), errno, ast_format::exts, exts_compare(), f, ast_filestream::filename, ast_filestream::flags, ast_filestream::fmt, get_filestream(), LOG_WARNING, ast_filestream::mode, open_wrapper(), ast_filestream::trans, and ast_filestream::vfs.

Referenced by __ast_play_and_record(), and handle_cli_file_convert().

00986 {
00987    FILE *bfile;
00988    struct ast_format *f;
00989    struct ast_filestream *fs = NULL;
00990    char *fn;
00991    int format_found = 0;   
00992 
00993    AST_RWLIST_RDLOCK(&formats);
00994 
00995    AST_RWLIST_TRAVERSE(&formats, f, list) {
00996       fs = NULL;
00997       if (!exts_compare(f->exts, type))
00998          continue;
00999       else 
01000          format_found = 1;
01001 
01002       fn = build_filename(filename, type);
01003       errno = 0;
01004       bfile = fopen(fn, "r");
01005 
01006       if (!bfile || (fs = get_filestream(f, bfile)) == NULL || open_wrapper(fs) ) {
01007          ast_log(LOG_WARNING, "Unable to open %s\n", fn);
01008          if (fs) {
01009             ast_closestream(fs);
01010          }
01011          fs = NULL;
01012          bfile = NULL;
01013          ast_free(fn);
01014          break;            
01015       }
01016       /* found it */
01017       fs->trans = NULL;
01018       fs->fmt = f;
01019       fs->flags = flags;
01020       fs->mode = mode;
01021       fs->filename = ast_strdup(filename);
01022       fs->vfs = NULL;
01023       break;
01024    }
01025 
01026    AST_RWLIST_UNLOCK(&formats);
01027    if (!format_found)
01028       ast_log(LOG_WARNING, "No such format '%s'\n", type);
01029 
01030    return fs;
01031 }

struct ast_frame* ast_readframe ( struct ast_filestream s  )  [read]

Read a frame from a filestream.

Parameters:
s ast_filestream to act on
Returns:
a frame.
Return values:
NULL if read failed.

Definition at line 720 of file file.c.

References read_frame().

Referenced by __ast_play_and_record(), dictate_exec(), gen_readframe(), handle_cli_file_convert(), and moh_files_readframe().

00721 {
00722    int whennext = 0;
00723 
00724    return read_frame(s, &whennext);
00725 }

static enum fsread_res ast_readvideo_callback ( struct ast_filestream s  )  [static]

Definition at line 799 of file file.c.

References ast_format_rate(), ast_frfree, ast_fsread_video(), ast_log(), ast_sched_add(), ast_write(), ast_filestream::fmt, ast_format::format, FSREAD_FAILURE, FSREAD_SUCCESS_NOSCHED, FSREAD_SUCCESS_SCHED, ast_filestream::lasttimeout, LOG_WARNING, ast_filestream::owner, read_frame(), ast_channel::sched, and ast_channel::vstreamid.

Referenced by ast_fsread_video(), and ast_playstream().

00800 {
00801    int whennext = 0;
00802 
00803    while (!whennext) {
00804       struct ast_frame *fr = read_frame(s, &whennext);
00805 
00806       if (!fr /* stream complete */ || ast_write(s->owner, fr) /* error writing */) {
00807          if (fr) {
00808             ast_log(LOG_WARNING, "Failed to write frame\n");
00809             ast_frfree(fr);
00810          }
00811          s->owner->vstreamid = -1;
00812          return FSREAD_FAILURE;
00813       }
00814 
00815       if (fr) {
00816          ast_frfree(fr);
00817       }
00818    }
00819 
00820    if (whennext != s->lasttimeout) {
00821       s->owner->vstreamid = ast_sched_add(s->owner->sched, 
00822          whennext / (ast_format_rate(s->fmt->format) / 1000), 
00823          ast_fsread_video, s);
00824       s->lasttimeout = whennext;
00825       return FSREAD_SUCCESS_NOSCHED;
00826    }
00827 
00828    return FSREAD_SUCCESS_SCHED;
00829 }

int ast_seekstream ( struct ast_filestream fs,
off_t  sample_offset,
int  whence 
)

Seeks into stream.

Parameters:
fs ast_filestream to perform seek on
sample_offset numbers of samples to seek
whence SEEK_SET, SEEK_CUR, SEEK_END
Return values:
0 on success.
-1 on failure.

Definition at line 862 of file file.c.

References ast_filestream::fmt, and ast_format::seek.

Referenced by __ast_read(), ast_control_streamfile(), ast_moh_files_next(), ast_stream_fastforward(), ast_stream_rewind(), ast_streamfile(), ast_write(), dictate_exec(), handle_getoption(), handle_recordfile(), handle_streamfile(), and speech_streamfile().

00863 {
00864    return fs->fmt->seek(fs, sample_offset, whence);
00865 }

int ast_stopstream ( struct ast_channel c  ) 

Stops a stream.

Parameters:
c The channel you wish to stop playback on
Stop playback of a stream

Return values:
0 always
Note:
The channel does not need to be locked before calling this function.

Definition at line 122 of file file.c.

References ast_channel_lock, ast_channel_unlock, ast_closestream(), ast_log(), ast_set_write_format(), LOG_WARNING, ast_channel::oldwriteformat, ast_channel::stream, and ast_channel::vstream.

Referenced by _ast_adsi_transmit_message_full(), ast_control_streamfile(), ast_openstream_full(), ast_play_and_wait(), ast_readstring_full(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_enumeration_full_en(), ast_say_enumeration_full_he(), ast_say_number_full_cs(), ast_say_number_full_da(), ast_say_number_full_de(), ast_say_number_full_en(), ast_say_number_full_en_GB(), ast_say_number_full_es(), ast_say_number_full_fr(), ast_say_number_full_gr(), ast_say_number_full_he(), ast_say_number_full_hu(), ast_say_number_full_it(), ast_say_number_full_ka(), ast_say_number_full_nl(), ast_say_number_full_no(), ast_say_number_full_pt(), ast_say_number_full_ru(), ast_say_number_full_se(), ast_say_number_full_th(), ast_say_number_full_zh(), background_detect_exec(), builtin_blindtransfer(), conf_exec(), conf_run(), directory_exec(), handle_getoption(), handle_speechrecognize(), handle_streamfile(), ices_exec(), ivr_dispatch(), leave_voicemail(), minivm_greet_exec(), mp3_exec(), NBScat_exec(), parkandannounce_exec(), pbx_builtin_background(), pl_odtworz_plik(), play_file(), play_mailbox_owner(), playback_exec(), queue_exec(), read_exec(), readexten_exec(), record_exec(), recordthread(), rpt_tele_thread(), s_streamwait3(), say_character_str_full(), say_digit_str_full(), say_phonetic_str_full(), saycharstr(), sayfile(), saynum(), select_item_seq(), send_morse(), send_tone_telemetry(), send_waveform_to_channel(), speech_background(), vm_authenticate(), vm_execmain(), wait_for_winner(), waitstream_core(), and zapateller_exec().

00123 {
00124    ast_channel_lock(tmp);
00125 
00126    /* Stop a running stream if there is one */
00127    if (tmp->stream) {
00128       ast_closestream(tmp->stream);
00129       tmp->stream = NULL;
00130       if (tmp->oldwriteformat && ast_set_write_format(tmp, tmp->oldwriteformat))
00131          ast_log(LOG_WARNING, "Unable to restore format back to %d\n", tmp->oldwriteformat);
00132    }
00133    /* Stop the video stream too */
00134    if (tmp->vstream != NULL) {
00135       ast_closestream(tmp->vstream);
00136       tmp->vstream = NULL;
00137    }
00138 
00139    ast_channel_unlock(tmp);
00140 
00141    return 0;
00142 }

int ast_stream_and_wait ( struct ast_channel chan,
const char *  file,
const char *  digits 
)

stream file until digit If the file name is non-empty, try to play it.

Note:
If digits == "" then we can simply check for non-zero.
Returns:
0 if success.
Return values:
-1 if error.
digit if interrupted by a digit.

Definition at line 1342 of file file.c.

References ast_streamfile(), ast_strlen_zero(), ast_waitstream(), and ast_channel::language.

Referenced by __ast_play_and_record(), app_exec(), ast_record_review(), bridge_playfile(), builtin_atxfer(), builtin_automixmonitor(), builtin_blindtransfer(), directory_exec(), forward_message(), invent_message(), ivr_dispatch(), leave_voicemail(), masq_park_call(), park_exec_full(), play_mailbox_owner(), play_message_callerid(), play_message_in_bridged_call(), play_record_review(), sayname(), select_item_seq(), and wait_file2().

01343 {
01344    int res = 0;
01345    if (!ast_strlen_zero(file)) {
01346       res = ast_streamfile(chan, file, chan->language);
01347       if (!res) {
01348          res = ast_waitstream(chan, digits);
01349       }
01350    }
01351    return res;
01352 } 

int ast_stream_fastforward ( struct ast_filestream fs,
off_t  ms 
)

Fast forward stream ms.

Parameters:
fs filestream to act on
ms milliseconds to move
Return values:
0 on success.
-1 on failure.

Definition at line 877 of file file.c.

References ast_seekstream(), and DEFAULT_SAMPLES_PER_MS.

Referenced by waitstream_core().

00878 {
00879    return ast_seekstream(fs, ms * DEFAULT_SAMPLES_PER_MS, SEEK_CUR);
00880 }

int ast_stream_rewind ( struct ast_filestream fs,
off_t  ms 
)

Rewind stream ms.

Parameters:
fs filestream to act on
ms milliseconds to move
Return values:
0 on success.
-1 on failure.

Definition at line 882 of file file.c.

References ast_seekstream(), and DEFAULT_SAMPLES_PER_MS.

Referenced by __ast_play_and_record(), handle_recordfile(), record_exec(), and waitstream_core().

00883 {
00884    return ast_seekstream(fs, -ms * DEFAULT_SAMPLES_PER_MS, SEEK_CUR);
00885 }

int ast_streamfile ( struct ast_channel c,
const char *  filename,
const char *  preflang 
)

Streams a file.

Parameters:
c channel to stream the file to
filename the name of the file you wish to stream, minus the extension
preflang the preferred language you wish to have the file streamed to you in Prepares a channel for the streaming of a file. To start the stream, afterward do a ast_waitstream() on the channel Also, it will stop any existing streams on the channel.
Return values:
0 on success.
-1 on failure.

Definition at line 943 of file file.c.

References ast_applystream(), ast_debug, AST_FLAG_MASQ_NOSTREAM, ast_getformatname(), ast_getformatname_multiple(), ast_log(), ast_openstream(), ast_openvstream(), ast_playstream(), ast_seekstream(), ast_strdup, ast_test_flag, ast_verb, errno, ast_filestream::f, ast_filestream::fmt, ast_format::format, LOG_WARNING, ast_channel::name, ast_channel::nativeformats, ast_filestream::orig_chan_name, ast_filestream::vfs, and ast_channel::writeformat.

Referenced by action_bridge(), agent_call(), announce_thread(), app_exec(), ast_app_getdata(), ast_app_getdata_full(), ast_control_streamfile(), ast_play_and_wait(), ast_say_date_da(), ast_say_date_de(), ast_say_date_en(), ast_say_date_fr(), ast_say_date_gr(), ast_say_date_he(), ast_say_date_hu(), ast_say_date_ka(), ast_say_date_nl(), ast_say_date_th(), ast_say_date_with_format_gr(), ast_say_datetime_en(), ast_say_datetime_fr(), ast_say_datetime_from_now_en(), ast_say_datetime_from_now_fr(), ast_say_datetime_from_now_he(), ast_say_datetime_from_now_ka(), ast_say_datetime_gr(), ast_say_datetime_he(), ast_say_datetime_nl(), ast_say_datetime_pt(), ast_say_datetime_th(), ast_say_datetime_zh(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_enumeration_full_en(), ast_say_enumeration_full_he(), ast_say_number_full_cs(), ast_say_number_full_da(), ast_say_number_full_de(), ast_say_number_full_en(), ast_say_number_full_en_GB(), ast_say_number_full_es(), ast_say_number_full_fr(), ast_say_number_full_gr(), ast_say_number_full_he(), ast_say_number_full_hu(), ast_say_number_full_it(), ast_say_number_full_ka(), ast_say_number_full_nl(), ast_say_number_full_no(), ast_say_number_full_pt(), ast_say_number_full_ru(), ast_say_number_full_se(), ast_say_number_full_th(), ast_say_number_full_zh(), ast_say_time_de(), ast_say_time_en(), ast_say_time_fr(), ast_say_time_gr(), ast_say_time_hu(), ast_say_time_ka(), ast_say_time_nl(), ast_say_time_zh(), ast_stream_and_wait(), auth_exec(), background_detect_exec(), bridge_exec(), check_availability(), check_beep(), common_exec(), conf_exec(), conf_run(), dial_exec_full(), do_directory(), find_conf_realtime(), forward_message(), gr_say_number_female(), handle_recordfile(), invent_message(), leave_voicemail(), login_exec(), minivm_greet_exec(), page_exec(), park_exec_full(), parkandannounce_exec(), pbx_builtin_background(), pl_odtworz_plik(), play_and_wait(), play_file(), play_record_review(), playback_exec(), privacy_exec(), readexten_exec(), record_exec(), retrydial_exec(), rpt_tele_thread(), s_streamwait3(), say_character_str_full(), say_digit_str_full(), say_phonetic_str_full(), sayfile(), select_item_menu(), setup_privacy_args(), ss_thread(), vm_authenticate(), wait_file(), and wait_for_winner().

00944 {
00945    struct ast_filestream *fs;
00946    struct ast_filestream *vfs=NULL;
00947    char fmt[256];
00948    int seekattempt;
00949    int res;
00950 
00951    fs = ast_openstream(chan, filename, preflang);
00952    if (!fs) {
00953       ast_log(LOG_WARNING, "Unable to open %s (format %s): %s\n", filename, ast_getformatname_multiple(fmt, sizeof(fmt), chan->nativeformats), strerror(errno));
00954       return -1;
00955    }
00956 
00957    /* check to see if there is any data present (not a zero length file),
00958     * done this way because there is no where for ast_openstream_full to
00959     * return the file had no data. */
00960    seekattempt = fseek(fs->f, -1, SEEK_END);
00961    if (!seekattempt)
00962       ast_seekstream(fs, 0, SEEK_SET);
00963    else
00964       return 0;
00965 
00966    vfs = ast_openvstream(chan, filename, preflang);
00967    if (vfs) {
00968       ast_debug(1, "Ooh, found a video stream, too, format %s\n", ast_getformatname(vfs->fmt->format));
00969    }
00970 
00971    if (ast_test_flag(chan, AST_FLAG_MASQ_NOSTREAM))
00972       fs->orig_chan_name = ast_strdup(chan->name);
00973    if (ast_applystream(chan, fs))
00974       return -1;
00975    if (vfs && ast_applystream(chan, vfs))
00976       return -1;
00977    res = ast_playstream(fs);
00978    if (!res && vfs)
00979       res = ast_playstream(vfs);
00980    ast_verb(3, "<%s> Playing '%s.%s' (language '%s')\n", chan->name, filename, ast_getformatname(chan->writeformat), preflang ? preflang : "default");
00981 
00982    return res;
00983 }

off_t ast_tellstream ( struct ast_filestream fs  ) 

Tell where we are in a stream.

Parameters:
fs fs to act on
Returns:
a long as a sample offset into stream

Definition at line 872 of file file.c.

References ast_filestream::fmt, and ast_format::tell.

Referenced by __ast_play_and_record(), ast_control_streamfile(), handle_getoption(), handle_recordfile(), handle_speechrecognize(), and handle_streamfile().

00873 {
00874    return fs->fmt->tell(fs);
00875 }

int ast_truncstream ( struct ast_filestream fs  ) 

Trunc stream at current location.

Parameters:
fs filestream to act on
Return values:
0 on success.
-1 on failure.

Definition at line 867 of file file.c.

References ast_filestream::fmt, and ast_format::trunc.

Referenced by __ast_play_and_record(), handle_recordfile(), and record_exec().

00868 {
00869    return fs->fmt->trunc(fs);
00870 }

int ast_waitstream ( struct ast_channel c,
const char *  breakon 
)

Waits for a stream to stop or digit to be pressed.

Parameters:
c channel to waitstream on
breakon string of DTMF digits to break upon Begins playback of a stream... Wait for a stream to stop or for any one of a given digit to arrive,
Return values:
0 if the stream finishes
the character if it was interrupted,
-1 on error

Definition at line 1315 of file file.c.

References waitstream_core().

Referenced by action_bridge(), agent_call(), announce_thread(), app_exec(), ast_play_and_wait(), ast_say_date_da(), ast_say_date_de(), ast_say_date_en(), ast_say_date_fr(), ast_say_date_gr(), ast_say_date_he(), ast_say_date_hu(), ast_say_date_ka(), ast_say_date_nl(), ast_say_date_th(), ast_say_date_with_format_gr(), ast_say_datetime_en(), ast_say_datetime_fr(), ast_say_datetime_from_now_en(), ast_say_datetime_from_now_fr(), ast_say_datetime_from_now_he(), ast_say_datetime_from_now_ka(), ast_say_datetime_gr(), ast_say_datetime_he(), ast_say_datetime_nl(), ast_say_datetime_pt(), ast_say_datetime_th(), ast_say_datetime_zh(), ast_say_enumeration_full_da(), ast_say_enumeration_full_de(), ast_say_enumeration_full_en(), ast_say_enumeration_full_he(), ast_say_number_full_cs(), ast_say_number_full_da(), ast_say_number_full_de(), ast_say_number_full_en(), ast_say_number_full_en_GB(), ast_say_number_full_es(), ast_say_number_full_fr(), ast_say_number_full_gr(), ast_say_number_full_he(), ast_say_number_full_hu(), ast_say_number_full_it(), ast_say_number_full_ka(), ast_say_number_full_nl(), ast_say_number_full_no(), ast_say_number_full_pt(), ast_say_number_full_ru(), ast_say_number_full_se(), ast_say_number_full_th(), ast_say_number_full_zh(), ast_say_time_de(), ast_say_time_en(), ast_say_time_gr(), ast_say_time_he(), ast_say_time_hu(), ast_say_time_ka(), ast_say_time_nl(), ast_say_time_zh(), ast_stream_and_wait(), auth_exec(), bridge_exec(), check_availability(), check_beep(), common_exec(), conf_exec(), conf_run(), dial_exec_full(), directory_exec(), find_conf_realtime(), gr_say_number_female(), handle_recordfile(), invent_message(), leave_voicemail(), login_exec(), minivm_greet_exec(), page_exec(), park_exec_full(), parkandannounce_exec(), pbx_builtin_background(), pl_odtworz_plik(), play_and_wait(), play_file(), play_record_review(), playback_exec(), privacy_exec(), record_exec(), retrydial_exec(), rpt_tele_thread(), s_streamwait3(), say_character_str_full(), say_digit_str_full(), say_phonetic_str_full(), saycharstr(), sayfile(), saynum(), select_item_menu(), send_morse(), send_tone_telemetry(), setup_privacy_args(), ss_thread(), vm_authenticate(), and wait_file().

01316 {
01317    return waitstream_core(c, breakon, NULL, NULL, 0, -1, -1, NULL);
01318 }

int ast_waitstream_exten ( struct ast_channel c,
const char *  context 
)

Waits for a stream to stop or digit matching a valid one digit exten to be pressed.

Parameters:
c channel to waitstream on
context string of context to match digits to break upon Begins playback of a stream... Wait for a stream to stop or for any one of a valid extension digit to arrive,
Return values:
0 if the stream finishes.
the character if it was interrupted.
-1 on error.

Definition at line 1326 of file file.c.

References ast_channel::context, and waitstream_core().

Referenced by pbx_builtin_background().

01327 {
01328    /* Waitstream, with return in the case of a valid 1 digit extension */
01329    /* in the current or specified context being pressed */
01330 
01331    if (!context)
01332       context = c->context;
01333    return waitstream_core(c, NULL, NULL, NULL, 0,
01334       -1, -1, context);
01335 }

int ast_waitstream_fr ( struct ast_channel c,
const char *  breakon,
const char *  forward,
const char *  rewind,
int  ms 
)

Same as waitstream but allows stream to be forwarded or rewound.

Parameters:
c channel to waitstream on
breakon string of DTMF digits to break upon
forward DTMF digit to fast forward upon
rewind DTMF digit to rewind upon
ms How many miliseconds to skip forward/back Begins playback of a stream... Wait for a stream to stop or for any one of a given digit to arrive,
Return values:
0 if the stream finishes.
the character if it was interrupted.
-1 on error.

Definition at line 1309 of file file.c.

References waitstream_core().

Referenced by ast_control_streamfile().

01310 {
01311    return waitstream_core(c, breakon, forward, reverse, ms,
01312       -1 /* no audiofd */, -1 /* no cmdfd */, NULL /* no context */);
01313 }

int ast_waitstream_full ( struct ast_channel c,
const char *  breakon,
int  audiofd,
int  monfd 
)

struct ast_filestream* ast_writefile ( const char *  filename,
const char *  type,
const char *  comment,
int  flags,
int  check,
mode_t  mode 
) [read]

Starts writing a file.

Parameters:
filename the name of the file to write to
type format of file you wish to write out to
comment comment to go with
flags output file flags
check (unimplemented, hence negligible)
mode Open mode Create an outgoing file stream. oflags are flags for the open() command, and if check is non-zero, then it will not write a file if there are any files that start with that name and have an extension Please note, this is a blocking function. Program execution will not return until ast_waitstream completes it's execution.
Return values:
a struct ast_filestream on success.
NULL on failure.

Definition at line 1033 of file file.c.

References ast_closestream(), ast_free, ast_log(), ast_malloc, ast_opt_cache_record_files, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_strdupa, buf, build_filename(), errno, ast_format::exts, exts_compare(), ast_filestream::f, f, ast_filestream::filename, ast_filestream::flags, ast_filestream::fmt, get_filestream(), LOG_WARNING, ast_filestream::mode, ast_filestream::realfilename, record_cache_dir, rewrite_wrapper(), ast_format::seek, ast_filestream::trans, ast_filestream::vfs, and ast_filestream::write_buffer.

Referenced by __ast_play_and_record(), ast_monitor_start(), ast_writestream(), dictate_exec(), handle_cli_file_convert(), handle_recordfile(), mixmonitor_thread(), record_exec(), recordthread(), and rpt().

01034 {
01035    int fd, myflags = 0;
01036    /* compiler claims this variable can be used before initialization... */
01037    FILE *bfile = NULL;
01038    struct ast_format *f;
01039    struct ast_filestream *fs = NULL;
01040    char *buf = NULL;
01041    size_t size = 0;
01042    int format_found = 0;
01043 
01044    AST_RWLIST_RDLOCK(&formats);
01045 
01046    /* set the O_TRUNC flag if and only if there is no O_APPEND specified */
01047    /* We really can't use O_APPEND as it will break WAV header updates */
01048    if (flags & O_APPEND) { 
01049       flags &= ~O_APPEND;
01050    } else {
01051       myflags = O_TRUNC;
01052    }
01053    
01054    myflags |= O_WRONLY | O_CREAT;
01055 
01056    /* XXX need to fix this - we should just do the fopen,
01057     * not open followed by fdopen()
01058     */
01059    AST_RWLIST_TRAVERSE(&formats, f, list) {
01060       char *fn, *orig_fn = NULL;
01061       if (fs)
01062          break;
01063 
01064       if (!exts_compare(f->exts, type))
01065          continue;
01066       else
01067          format_found = 1;
01068 
01069       fn = build_filename(filename, type);
01070       fd = open(fn, flags | myflags, mode);
01071       if (fd > -1) {
01072          /* fdopen() the resulting file stream */
01073          bfile = fdopen(fd, ((flags | myflags) & O_RDWR) ? "w+" : "w");
01074          if (!bfile) {
01075             ast_log(LOG_WARNING, "Whoa, fdopen failed: %s!\n", strerror(errno));
01076             close(fd);
01077             fd = -1;
01078          }
01079       }
01080       
01081       if (ast_opt_cache_record_files && (fd > -1)) {
01082          char *c;
01083 
01084          fclose(bfile); /* this also closes fd */
01085          /*
01086            We touch orig_fn just as a place-holder so other things (like vmail) see the file is there.
01087            What we are really doing is writing to record_cache_dir until we are done then we will mv the file into place.
01088          */
01089          orig_fn = ast_strdupa(fn);
01090          for (c = fn; *c; c++)
01091             if (*c == '/')
01092                *c = '_';
01093 
01094          size = strlen(fn) + strlen(record_cache_dir) + 2;
01095          buf = alloca(size);
01096          strcpy(buf, record_cache_dir);
01097          strcat(buf, "/");
01098          strcat(buf, fn);
01099          ast_free(fn);
01100          fn = buf;
01101          fd = open(fn, flags | myflags, mode);
01102          if (fd > -1) {
01103             /* fdopen() the resulting file stream */
01104             bfile = fdopen(fd, ((flags | myflags) & O_RDWR) ? "w+" : "w");
01105             if (!bfile) {
01106                ast_log(LOG_WARNING, "Whoa, fdopen failed: %s!\n", strerror(errno));
01107                close(fd);
01108                fd = -1;
01109             }
01110          }
01111       }
01112       if (fd > -1) {
01113          errno = 0;
01114          fs = get_filestream(f, bfile);
01115          if (!fs || rewrite_wrapper(fs, comment)) {
01116             ast_log(LOG_WARNING, "Unable to rewrite %s\n", fn);
01117             close(fd);
01118             if (orig_fn) {
01119                unlink(fn);
01120                unlink(orig_fn);
01121             }
01122             if (fs) {
01123                ast_closestream(fs);
01124                fs = NULL;
01125             }
01126             continue;
01127          }
01128          fs->trans = NULL;
01129          fs->fmt = f;
01130          fs->flags = flags;
01131          fs->mode = mode;
01132          if (orig_fn) {
01133             fs->realfilename = ast_strdup(orig_fn);
01134             fs->filename = ast_strdup(fn);
01135          } else {
01136             fs->realfilename = NULL;
01137             fs->filename = ast_strdup(filename);
01138          }
01139          fs->vfs = NULL;
01140          /* If truncated, we'll be at the beginning; if not truncated, then append */
01141 
01142          if ((fs->write_buffer = ast_malloc(32768))){
01143             setvbuf(fs->f, fs->write_buffer, _IOFBF, 32768);
01144          }
01145 
01146          f->seek(fs, 0, SEEK_END);
01147       } else if (errno != EEXIST) {
01148          ast_log(LOG_WARNING, "Unable to open file %s: %s\n", fn, strerror(errno));
01149          if (orig_fn)
01150             unlink(orig_fn);
01151       }
01152       /* if buf != NULL then fn is already free and pointing to it */
01153       if (!buf)
01154          ast_free(fn);
01155    }
01156 
01157    AST_RWLIST_UNLOCK(&formats);
01158 
01159    if (!format_found)
01160       ast_log(LOG_WARNING, "No such format '%s'\n", type);
01161 
01162    return fs;
01163 }

int ast_writestream ( struct ast_filestream fs,
struct ast_frame f 
)

Writes a frame to a stream.

Parameters:
fs filestream to write to
f frame to write to the filestream Send a frame to a filestream -- note: does NOT free the frame, call ast_frfree manually
Return values:
0 on success.
-1 on failure.

Definition at line 144 of file file.c.

References ast_debug, AST_FORMAT_AUDIO_MASK, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_getformatname(), AST_LIST_NEXT, ast_log(), ast_translate(), ast_translator_build_path(), ast_translator_free_path(), ast_writefile(), ast_writestream(), ast_filestream::filename, ast_filestream::flags, ast_filestream::fmt, ast_format::format, ast_frame::frame_list, ast_frame::frametype, ast_filestream::lastwriteformat, LOG_WARNING, ast_filestream::mode, ast_format::name, ast_frame::subclass, ast_filestream::trans, type, ast_filestream::vfs, and ast_format::write.

Referenced by __ast_play_and_record(), __ast_read(), ast_write(), ast_writestream(), dictate_exec(), handle_cli_file_convert(), handle_recordfile(), mixmonitor_thread(), record_exec(), recordthread(), and rpt().

00145 {
00146    int res = -1;
00147    int alt = 0;
00148    if (f->frametype == AST_FRAME_VIDEO) {
00149       if (fs->fmt->format & AST_FORMAT_AUDIO_MASK) {
00150          /* This is the audio portion.  Call the video one... */
00151          if (!fs->vfs && fs->filename) {
00152             const char *type = ast_getformatname(f->subclass & ~0x1);
00153             fs->vfs = ast_writefile(fs->filename, type, NULL, fs->flags, 0, fs->mode);
00154             ast_debug(1, "Opened video output file\n");
00155          }
00156          if (fs->vfs)
00157             return ast_writestream(fs->vfs, f);
00158          /* else ignore */
00159          return 0;            
00160       } else {
00161          /* Might / might not have mark set */
00162          alt = 1;
00163       }
00164    } else if (f->frametype != AST_FRAME_VOICE) {
00165       ast_log(LOG_WARNING, "Tried to write non-voice frame\n");
00166       return -1;
00167    }
00168    if (((fs->fmt->format | alt) & f->subclass) == f->subclass) {
00169       res =  fs->fmt->write(fs, f);
00170       if (res < 0) 
00171          ast_log(LOG_WARNING, "Natural write failed\n");
00172       else if (res > 0)
00173          ast_log(LOG_WARNING, "Huh??\n");
00174    } else {
00175       /* XXX If they try to send us a type of frame that isn't the normal frame, and isn't
00176              the one we've setup a translator for, we do the "wrong thing" XXX */
00177       if (fs->trans && f->subclass != fs->lastwriteformat) {
00178          ast_translator_free_path(fs->trans);
00179          fs->trans = NULL;
00180       }
00181       if (!fs->trans) 
00182          fs->trans = ast_translator_build_path(fs->fmt->format, f->subclass);
00183       if (!fs->trans)
00184          ast_log(LOG_WARNING, "Unable to translate to format %s, source format %s\n",
00185             fs->fmt->name, ast_getformatname(f->subclass));
00186       else {
00187          struct ast_frame *trf;
00188          fs->lastwriteformat = f->subclass;
00189          /* Get the translated frame but don't consume the original in case they're using it on another stream */
00190          if ((trf = ast_translate(fs->trans, f, 0))) {
00191             struct ast_frame *cur;
00192 
00193             /* the translator may have returned multiple frames, so process them */
00194             for (cur = trf; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
00195                if ((res = fs->fmt->write(fs, trf))) {
00196                   ast_log(LOG_WARNING, "Translated frame write failed\n");
00197                   break;
00198                }
00199             }
00200             ast_frfree(trf);
00201          } else {
00202             res = 0;
00203          }
00204       }
00205    }
00206    return res;
00207 }

static char* build_filename ( const char *  filename,
const char *  ext 
) [static]

construct a filename. Absolute pathnames are preserved, relative names are prefixed by the sounds/ directory. The wav49 suffix is replaced by 'WAV'. Returns a malloc'ed string to be freed by the caller.

Definition at line 252 of file file.c.

References asprintf, ast_config_AST_DATA_DIR, ast_log(), errno, and LOG_WARNING.

Referenced by ast_filehelper(), ast_readfile(), and ast_writefile().

00253 {
00254    char *fn = NULL;
00255 
00256    if (!strcmp(ext, "wav49"))
00257       ext = "WAV";
00258 
00259    if (filename[0] == '/') {
00260       if (asprintf(&fn, "%s.%s", filename, ext) < 0) {
00261          ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
00262          fn = NULL;
00263       }
00264    } else {
00265       if (asprintf(&fn, "%s/sounds/%s.%s",
00266               ast_config_AST_DATA_DIR, filename, ext) < 0) {
00267          ast_log(LOG_WARNING, "asprintf() failed: %s\n", strerror(errno));
00268          fn = NULL;
00269       }
00270    }
00271    return fn;
00272 }

static int copy ( const char *  infile,
const char *  outfile 
) [static]

Definition at line 209 of file file.c.

References AST_FILE_MODE, ast_log(), buf, errno, len(), and LOG_WARNING.

Referenced by ast_filehelper(), ast_func_read(), ast_func_write(), copy_plain_file(), and iax2_register().

00210 {
00211    int ifd, ofd, len;
00212    char buf[4096];   /* XXX make it lerger. */
00213 
00214    if ((ifd = open(infile, O_RDONLY)) < 0) {
00215       ast_log(LOG_WARNING, "Unable to open %s in read-only mode\n", infile);
00216       return -1;
00217    }
00218    if ((ofd = open(outfile, O_WRONLY | O_TRUNC | O_CREAT, AST_FILE_MODE)) < 0) {
00219       ast_log(LOG_WARNING, "Unable to open %s in write-only mode\n", outfile);
00220       close(ifd);
00221       return -1;
00222    }
00223    while ( (len = read(ifd, buf, sizeof(buf)) ) ) {
00224       int res;
00225       if (len < 0) {
00226          ast_log(LOG_WARNING, "Read failed on %s: %s\n", infile, strerror(errno));
00227          break;
00228       }
00229       /* XXX handle partial writes */
00230       res = write(ofd, buf, len);
00231       if (res != len) {
00232          ast_log(LOG_WARNING, "Write failed on %s (%d of %d): %s\n", outfile, res, len, strerror(errno));
00233          len = -1; /* error marker */
00234          break;
00235       }
00236    }
00237    close(ifd);
00238    close(ofd);
00239    if (len < 0) {
00240       unlink(outfile);
00241       return -1; /* error */
00242    }
00243    return 0;   /* success */
00244 }

static int exts_compare ( const char *  exts,
const char *  type 
) [static]

Definition at line 276 of file file.c.

References ast_copy_string(), ext, and strsep().

Referenced by ast_filehelper(), ast_readfile(), and ast_writefile().

00277 {
00278    char tmp[256];
00279    char *stringp = tmp, *ext;
00280 
00281    ast_copy_string(tmp, exts, sizeof(tmp));
00282    while ((ext = strsep(&stringp, "|"))) {
00283       if (!strcmp(ext, type))
00284          return 1;
00285    }
00286 
00287    return 0;
00288 }

static int fileexists_core ( const char *  filename,
const char *  fmt,
const char *  preflang,
char *  buf,
int  buflen 
) [static]

helper routine to locate a file with a given format and language preference. Try preflang, preflang with stripped '_' suffix, or NULL. In the standard asterisk, language goes just before the last component. In an alternative configuration, the language should be a prefix to the actual filename.

The last parameter(s) point to a buffer of sufficient size, which on success is filled with the matching filename.

Definition at line 568 of file file.c.

References ast_strdupa, ast_strlen_zero(), DEFAULT_LANGUAGE, fileexists_test(), and strsep().

Referenced by ast_fileexists(), ast_openstream_full(), and ast_openvstream().

00570 {
00571    int res = -1;
00572    char *lang = NULL;
00573 
00574    if (buf == NULL) {
00575       return -1;
00576    }
00577 
00578    /* We try languages in the following order:
00579     *    preflang (may include dialect)
00580     *    lang (preflang without dialect - if any)
00581     *    <none>
00582     *    default (unless the same as preflang or lang without dialect)
00583     */
00584 
00585    /* Try preferred language */
00586    if (!ast_strlen_zero(preflang)) {
00587       /* try the preflang exactly as it was requested */
00588       if ((res = fileexists_test(filename, fmt, preflang, buf, buflen)) > 0) {
00589          return res;
00590       } else {
00591          /* try without a dialect */
00592          char *postfix = NULL;
00593          postfix = lang = ast_strdupa(preflang);
00594 
00595          strsep(&postfix, "_");
00596          if (postfix) {
00597             if ((res = fileexists_test(filename, fmt, lang, buf, buflen)) > 0) {
00598                return res;
00599             }
00600          }
00601       }
00602    }
00603 
00604    /* Try without any language */
00605    if ((res = fileexists_test(filename, fmt, NULL, buf, buflen)) > 0) {
00606       return res;
00607    }
00608 
00609    /* Finally try the default language unless it was already tried before */
00610    if ((ast_strlen_zero(preflang) || strcmp(preflang, DEFAULT_LANGUAGE)) && (ast_strlen_zero(lang) || strcmp(lang, DEFAULT_LANGUAGE))) {
00611       if ((res = fileexists_test(filename, fmt, DEFAULT_LANGUAGE, buf, buflen)) > 0) {
00612          return res;
00613       }
00614    }
00615 
00616    return 0;
00617 }

static int fileexists_test ( const char *  filename,
const char *  fmt,
const char *  lang,
char *  buf,
int  buflen 
) [static]

Definition at line 531 of file file.c.

References ACTION_EXISTS, ast_filehelper(), and is_absolute_path().

Referenced by fileexists_core().

00533 {
00534    if (buf == NULL) {
00535       return -1;
00536    }
00537 
00538    if (ast_language_is_prefix && !is_absolute_path(filename)) { /* new layout */
00539       if (lang) {
00540          snprintf(buf, buflen, "%s/%s", lang, filename);
00541       } else {
00542          snprintf(buf, buflen, "%s", filename);
00543       }
00544    } else { /* old layout */
00545       strcpy(buf, filename);  /* first copy the full string */
00546       if (lang) {
00547          /* insert the language and suffix if needed */
00548          const char *c = strrchr(filename, '/');
00549          int offset = c ? c - filename + 1 : 0; /* points right after the last '/' */
00550          snprintf(buf + offset, buflen - offset, "%s/%s", lang, filename + offset);
00551       }
00552    }
00553 
00554    return ast_filehelper(buf, NULL, fmt, ACTION_EXISTS);
00555 }

static void filestream_destructor ( void *  arg  )  [static]

Definition at line 290 of file file.c.

References ast_closestream(), AST_FORMAT_AUDIO_MASK, ast_free, ast_module_unref(), ast_safe_system(), AST_SCHED_DEL, ast_settimeout(), ast_translator_free_path(), ast_format::close, ast_filestream::f, f, ast_filestream::filename, ast_filestream::fmt, ast_format::format, free, ast_format::module, ast_filestream::orig_chan_name, ast_filestream::owner, ast_filestream::realfilename, ast_channel::sched, ast_channel::stream, ast_channel::streamid, ast_filestream::trans, ast_filestream::vfs, ast_channel::vstream, ast_channel::vstreamid, and ast_filestream::write_buffer.

Referenced by get_filestream().

00291 {
00292    char *cmd = NULL;
00293    size_t size = 0;
00294    struct ast_filestream *f = arg;
00295 
00296    /* Stop a running stream if there is one */
00297    if (f->owner) {
00298       if (f->fmt->format < AST_FORMAT_AUDIO_MASK) {
00299          f->owner->stream = NULL;
00300          AST_SCHED_DEL(f->owner->sched, f->owner->streamid);
00301          ast_settimeout(f->owner, 0, NULL, NULL);
00302       } else {
00303          f->owner->vstream = NULL;
00304          AST_SCHED_DEL(f->owner->sched, f->owner->vstreamid);
00305       }
00306    }
00307    /* destroy the translator on exit */
00308    if (f->trans)
00309       ast_translator_free_path(f->trans);
00310 
00311    if (f->realfilename && f->filename) {
00312          size = strlen(f->filename) + strlen(f->realfilename) + 15;
00313          cmd = alloca(size);
00314          memset(cmd,0,size);
00315          snprintf(cmd,size,"/bin/mv -f %s %s",f->filename,f->realfilename);
00316          ast_safe_system(cmd);
00317    }
00318 
00319    if (f->filename)
00320       free(f->filename);
00321    if (f->realfilename)
00322       free(f->realfilename);
00323    if (f->fmt->close) {
00324       void (*closefn)(struct ast_filestream *) = f->fmt->close;
00325       closefn(f);
00326    }
00327    if (f->f)
00328       fclose(f->f);
00329    if (f->vfs)
00330       ast_closestream(f->vfs);
00331    if (f->write_buffer) {
00332       ast_free(f->write_buffer);
00333    }
00334    if (f->orig_chan_name)
00335       free((void *) f->orig_chan_name);
00336    ast_module_unref(f->fmt->module);
00337 }

static int fn_wrapper ( struct ast_filestream s,
const char *  comment,
enum wrap_fn  mode 
) [static]

Definition at line 363 of file file.c.

References ast_log(), ast_module_ref(), f, ast_filestream::fmt, LOG_WARNING, ast_format::module, ast_format::name, ast_format::open, ast_format::rewrite, WRAP_OPEN, and WRAP_REWRITE.

Referenced by open_wrapper(), and rewrite_wrapper().

00364 {
00365    struct ast_format *f = s->fmt;
00366    int ret = -1;
00367    int (*openfn)(struct ast_filestream *s);
00368 
00369    if (mode == WRAP_OPEN && (openfn = f->open) && openfn(s))
00370       ast_log(LOG_WARNING, "Unable to open format %s\n", f->name);
00371    else if (mode == WRAP_REWRITE && f->rewrite && f->rewrite(s, comment))
00372       ast_log(LOG_WARNING, "Unable to rewrite format %s\n", f->name);
00373    else {
00374       /* preliminary checks succeed. update usecount */
00375       ast_module_ref(f->module);
00376       ret = 0;
00377    }
00378    return ret;
00379 }

static struct ast_filestream* get_filestream ( struct ast_format fmt,
FILE *  bfile 
) [static, read]

Definition at line 339 of file file.c.

References ast_filestream::_private, ao2_alloc, ast_filestream::buf, ast_format::buf_size, ast_format::desc_size, ast_filestream::f, filestream_destructor(), ast_filestream::fmt, ast_filestream::fr, ast_format::name, s, and ast_frame::src.

Referenced by ast_filehelper(), ast_readfile(), and ast_writefile().

00340 {
00341    struct ast_filestream *s;
00342 
00343    int l = sizeof(*s) + fmt->buf_size + fmt->desc_size;  /* total allocation size */
00344    if ( (s = ao2_alloc(l, filestream_destructor)) == NULL)
00345       return NULL;
00346    s->fmt = fmt;
00347    s->f = bfile;
00348 
00349    if (fmt->desc_size)
00350       s->_private = ((char *)(s + 1)) + fmt->buf_size;
00351    if (fmt->buf_size)
00352       s->buf = (char *)(s + 1);
00353    s->fr.src = fmt->name;
00354    return s;
00355 }

static char* handle_cli_core_show_file_formats ( struct ast_cli_entry e,
int  cmd,
struct ast_cli_args a 
) [static]

Definition at line 1354 of file file.c.

References ast_cli_args::argc, ast_cli(), ast_getformatname(), AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_format::exts, f, ast_cli_args::fd, ast_format::format, FORMAT, FORMAT2, ast_format::list, ast_format::name, and ast_cli_entry::usage.

01355 {
01356 #define FORMAT "%-10s %-10s %-20s\n"
01357 #define FORMAT2 "%-10s %-10s %-20s\n"
01358    struct ast_format *f;
01359    int count_fmt = 0;
01360 
01361    switch (cmd) {
01362    case CLI_INIT:
01363       e->command = "core show file formats";
01364       e->usage =
01365          "Usage: core show file formats\n"
01366          "       Displays currently registered file formats (if any).\n";
01367       return NULL;
01368    case CLI_GENERATE:
01369       return NULL;
01370    }
01371 
01372    if (a->argc != 4)
01373       return CLI_SHOWUSAGE;
01374 
01375    ast_cli(a->fd, FORMAT, "Format", "Name", "Extensions");
01376    ast_cli(a->fd, FORMAT, "------", "----", "----------");
01377 
01378    AST_RWLIST_RDLOCK(&formats);
01379    AST_RWLIST_TRAVERSE(&formats, f, list) {
01380       ast_cli(a->fd, FORMAT2, ast_getformatname(f->format), f->name, f->exts);
01381       count_fmt++;
01382    }
01383    AST_RWLIST_UNLOCK(&formats);
01384    ast_cli(a->fd, "%d file formats registered.\n", count_fmt);
01385    return CLI_SUCCESS;
01386 #undef FORMAT
01387 #undef FORMAT2
01388 }

static int is_absolute_path ( const char *  filename  )  [static]

Definition at line 526 of file file.c.

Referenced by fileexists_test().

00527 {
00528    return filename[0] == '/';
00529 }

static int open_wrapper ( struct ast_filestream s  )  [static]

Definition at line 386 of file file.c.

References fn_wrapper(), and WRAP_OPEN.

Referenced by ast_filehelper(), and ast_readfile().

00387 {
00388    return fn_wrapper(s, NULL, WRAP_OPEN);
00389 }

static struct ast_frame* read_frame ( struct ast_filestream s,
int *  whennext 
) [static, read]

Definition at line 695 of file file.c.

References ast_frfree, ast_frisolate(), ast_filestream::fmt, and ast_format::read.

Referenced by ast_audiohook_read_frame(), ast_readaudio_callback(), ast_readframe(), and ast_readvideo_callback().

00696 {
00697    struct ast_frame *fr, *new_fr;
00698 
00699    if (!s || !s->fmt) {
00700       return NULL;
00701    }
00702 
00703    if (!(fr = s->fmt->read(s, whennext))) {
00704       return NULL;
00705    }
00706 
00707    if (!(new_fr = ast_frisolate(fr))) {
00708       ast_frfree(fr);
00709       return NULL;
00710    }
00711 
00712    if (new_fr != fr) {
00713       ast_frfree(fr);
00714       fr = new_fr;
00715    }
00716 
00717    return fr;
00718 }

static int rewrite_wrapper ( struct ast_filestream s,
const char *  comment 
) [static]

Definition at line 381 of file file.c.

References fn_wrapper(), and WRAP_REWRITE.

Referenced by ast_writefile().

00382 {
00383    return fn_wrapper(s, comment, WRAP_REWRITE);
00384 }

static int waitstream_core ( struct ast_channel c,
const char *  breakon,
const char *  forward,
const char *  reverse,
int  skip_ms,
int  audiofd,
int  cmdfd,
const char *  context 
) [static]

the core of all waitstream() functions

Definition at line 1168 of file file.c.

References ast_channel::_softhangup, ast_clear_flag, AST_CONTROL_ANSWER, AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_HOLD, AST_CONTROL_RINGING, AST_CONTROL_SRCUPDATE, AST_CONTROL_UNHOLD, AST_CONTROL_VIDUPDATE, ast_exists_extension(), AST_FLAG_END_DTMF_ONLY, AST_FLAG_MASQ_NOSTREAM, AST_FRAME_CONTROL, AST_FRAME_DTMF_END, AST_FRAME_VOICE, ast_frfree, ast_log(), ast_read(), ast_sched_runq(), ast_sched_wait(), ast_set_flag, ast_stopstream(), ast_strdupa, ast_stream_fastforward(), ast_stream_rewind(), ast_test_flag, ast_waitfor(), ast_waitfor_nandfds(), ast_channel::cid, ast_callerid::cid_num, ast_frame::data, ast_frame::datalen, errno, exten, ast_filestream::f, ast_frame::frametype, LOG_WARNING, ast_channel::name, ast_filestream::orig_chan_name, ast_frame::ptr, ast_channel::sched, ast_channel::stream, and ast_frame::subclass.

Referenced by ast_waitstream(), ast_waitstream_exten(), ast_waitstream_fr(), and ast_waitstream_full().

01171 {
01172    const char *orig_chan_name = NULL;
01173    int err = 0;
01174 
01175    if (!breakon)
01176       breakon = "";
01177    if (!forward)
01178       forward = "";
01179    if (!reverse)
01180       reverse = "";
01181 
01182    /* Switch the channel to end DTMF frame only. waitstream_core doesn't care about the start of DTMF. */
01183    ast_set_flag(c, AST_FLAG_END_DTMF_ONLY);
01184 
01185    if (ast_test_flag(c, AST_FLAG_MASQ_NOSTREAM))
01186       orig_chan_name = ast_strdupa(c->name);
01187 
01188    while (c->stream) {
01189       int res;
01190       int ms;
01191 
01192       if (orig_chan_name && strcasecmp(orig_chan_name, c->name)) {
01193          ast_stopstream(c);
01194          err = 1;
01195          break;
01196       }
01197 
01198       ms = ast_sched_wait(c->sched);
01199 
01200       if (ms < 0 && !c->timingfunc) {
01201          ast_stopstream(c);
01202          break;
01203       }
01204       if (ms < 0)
01205          ms = 1000;
01206       if (cmdfd < 0) {
01207          res = ast_waitfor(c, ms);
01208          if (res < 0) {
01209             ast_log(LOG_WARNING, "Select failed (%s)\n", strerror(errno));
01210             ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01211             return res;
01212          }
01213       } else {
01214          int outfd;
01215          struct ast_channel *rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
01216          if (!rchan && (outfd < 0) && (ms)) {
01217             /* Continue */
01218             if (errno == EINTR)
01219                continue;
01220             ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
01221             ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01222             return -1;
01223          } else if (outfd > -1) { /* this requires cmdfd set */
01224             /* The FD we were watching has something waiting */
01225             ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01226             return 1;
01227          }
01228          /* if rchan is set, it is 'c' */
01229          res = rchan ? 1 : 0; /* map into 'res' values */
01230       }
01231       if (res > 0) {
01232          struct ast_frame *fr = ast_read(c);
01233          if (!fr) {
01234             ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01235             return -1;
01236          }
01237          switch (fr->frametype) {
01238          case AST_FRAME_DTMF_END:
01239             if (context) {
01240                const char exten[2] = { fr->subclass, '\0' };
01241                if (ast_exists_extension(c, context, exten, 1, c->cid.cid_num)) {
01242                   res = fr->subclass;
01243                   ast_frfree(fr);
01244                   ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01245                   return res;
01246                }
01247             } else {
01248                res = fr->subclass;
01249                if (strchr(forward, res)) {
01250                   int eoftest;
01251                   ast_stream_fastforward(c->stream, skip_ms);
01252                   eoftest = fgetc(c->stream->f);
01253                   if (feof(c->stream->f)) {
01254                      ast_stream_rewind(c->stream, skip_ms);
01255                   } else {
01256                      ungetc(eoftest, c->stream->f);
01257                   }
01258                } else if (strchr(reverse, res)) {
01259                   ast_stream_rewind(c->stream, skip_ms);
01260                } else if (strchr(breakon, res)) {
01261                   ast_frfree(fr);
01262                   ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01263                   return res;
01264                }              
01265             }
01266             break;
01267          case AST_FRAME_CONTROL:
01268             switch (fr->subclass) {
01269             case AST_CONTROL_HANGUP:
01270             case AST_CONTROL_BUSY:
01271             case AST_CONTROL_CONGESTION:
01272                ast_frfree(fr);
01273                ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01274                return -1;
01275             case AST_CONTROL_RINGING:
01276             case AST_CONTROL_ANSWER:
01277             case AST_CONTROL_VIDUPDATE:
01278             case AST_CONTROL_SRCUPDATE:
01279             case AST_CONTROL_HOLD:
01280             case AST_CONTROL_UNHOLD:
01281             case -1:
01282                /* Unimportant */
01283                break;
01284             default:
01285                ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", fr->subclass);
01286             }
01287             break;
01288          case AST_FRAME_VOICE:
01289             /* Write audio if appropriate */
01290             if (audiofd > -1) {
01291                if (write(audiofd, fr->data.ptr, fr->datalen) < 0) {
01292                   ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
01293                }
01294             }
01295          default:
01296             /* Ignore all others */
01297             break;
01298          }
01299          ast_frfree(fr);
01300       }
01301       ast_sched_runq(c->sched);
01302    }
01303 
01304    ast_clear_flag(c, AST_FLAG_END_DTMF_ONLY);
01305 
01306    return (err || c->_softhangup) ? -1 : 0;
01307 }


Variable Documentation

Definition at line 57 of file file.c.

Referenced by ast_readconfig(), handle_show_settings(), and main().

Initial value:

 {
   AST_CLI_DEFINE(handle_cli_core_show_file_formats, "Displays file formats")
}

Definition at line 1390 of file file.c.


Generated on Wed Oct 28 11:52:24 2009 for Asterisk - the Open Source PBX by  doxygen 1.5.6