2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2006, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
8 * See http://www.asterisk.org for more information about
9 * the Asterisk project. Please do not directly contact
10 * any of the maintainers of this project for assistance;
11 * the project provides a web site, mailing lists and IRC
12 * channels for your use.
14 * This program is free software, distributed under the terms of
15 * the GNU General Public License Version 2. See the LICENSE file
16 * at the top of the source tree.
21 * \brief Generic File Format Support.
23 * \author Mark Spencer <markster@digium.com>
26 #include <sys/types.h>
34 #include <sys/types.h>
39 ASTERISK_FILE_VERSION(__FILE__
, "$Revision$")
41 #include "asterisk/frame.h"
42 #include "asterisk/file.h"
43 #include "asterisk/cli.h"
44 #include "asterisk/logger.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/sched.h"
47 #include "asterisk/options.h"
48 #include "asterisk/translate.h"
49 #include "asterisk/utils.h"
50 #include "asterisk/lock.h"
51 #include "asterisk/app.h"
52 #include "asterisk/pbx.h"
53 #include "asterisk/linkedlists.h"
55 #include "asterisk/module.h" /* ast_update_use_count() */
58 * The following variable controls the layout of localized sound files.
59 * If 0, use the historical layout with prefix just before the filename
60 * (i.e. digits/en/1.gsm , digits/it/1.gsm or default to digits/1.gsm),
61 * if 1 put the prefix at the beginning of the filename
62 * (i.e. en/digits/1.gsm, it/digits/1.gsm or default to digits/1.gsm).
63 * The latter permits a language to be entirely in one directory.
65 int ast_language_is_prefix
;
67 static AST_LIST_HEAD_STATIC(formats
, ast_format
);
69 int ast_format_register(const struct ast_format
*f
)
71 struct ast_format
*tmp
;
73 if (f
->module
== NULL
) {
74 ast_log(LOG_WARNING
, "Missing module pointer, you need to supply one\n");
77 if (AST_LIST_LOCK(&formats
)) {
78 ast_log(LOG_WARNING
, "Unable to lock format list\n");
81 AST_LIST_TRAVERSE(&formats
, tmp
, list
) {
82 if (!strcasecmp(f
->name
, tmp
->name
)) {
83 AST_LIST_UNLOCK(&formats
);
84 ast_log(LOG_WARNING
, "Tried to register '%s' format, already registered\n", f
->name
);
88 tmp
= ast_calloc(1, sizeof(struct ast_format
));
90 AST_LIST_UNLOCK(&formats
);
96 * Align buf_size properly, rounding up to the machine-specific
97 * alignment for pointers.
99 struct _test_align
{ void *a
, *b
; } p
;
100 int align
= (char *)&p
.b
- (char *)&p
.a
;
101 tmp
->buf_size
= ((f
->buf_size
+ align
- 1)/align
)*align
;
104 memset(&tmp
->list
, 0, sizeof(tmp
->list
));
106 AST_LIST_INSERT_HEAD(&formats
, tmp
, list
);
107 AST_LIST_UNLOCK(&formats
);
108 if (option_verbose
> 1)
109 ast_verbose( VERBOSE_PREFIX_2
"Registered file format %s, extension(s) %s\n", f
->name
, f
->exts
);
113 int ast_format_unregister(const char *name
)
115 struct ast_format
*tmp
;
118 if (AST_LIST_LOCK(&formats
)) {
119 ast_log(LOG_WARNING
, "Unable to lock format list\n");
122 AST_LIST_TRAVERSE_SAFE_BEGIN(&formats
, tmp
, list
) {
123 if (!strcasecmp(name
, tmp
->name
)) {
124 AST_LIST_REMOVE_CURRENT(&formats
, list
);
129 AST_LIST_TRAVERSE_SAFE_END
130 AST_LIST_UNLOCK(&formats
);
133 if (option_verbose
> 1)
134 ast_verbose( VERBOSE_PREFIX_2
"Unregistered format %s\n", name
);
136 ast_log(LOG_WARNING
, "Tried to unregister format %s, already unregistered\n", name
);
141 int ast_stopstream(struct ast_channel
*tmp
)
143 /* Stop a running stream if there is one */
145 ast_closestream(tmp
->stream
);
147 if (tmp
->oldwriteformat
&& ast_set_write_format(tmp
, tmp
->oldwriteformat
))
148 ast_log(LOG_WARNING
, "Unable to restore format back to %d\n", tmp
->oldwriteformat
);
153 int ast_writestream(struct ast_filestream
*fs
, struct ast_frame
*f
)
157 if (f
->frametype
== AST_FRAME_VIDEO
) {
158 if (fs
->fmt
->format
< AST_FORMAT_MAX_AUDIO
) {
159 /* This is the audio portion. Call the video one... */
160 if (!fs
->vfs
&& fs
->filename
) {
161 const char *type
= ast_getformatname(f
->subclass
& ~0x1);
162 fs
->vfs
= ast_writefile(fs
->filename
, type
, NULL
, fs
->flags
, 0, fs
->mode
);
163 ast_log(LOG_DEBUG
, "Opened video output file\n");
166 return ast_writestream(fs
->vfs
, f
);
170 /* Might / might not have mark set */
173 } else if (f
->frametype
!= AST_FRAME_VOICE
) {
174 ast_log(LOG_WARNING
, "Tried to write non-voice frame\n");
177 if (((fs
->fmt
->format
| alt
) & f
->subclass
) == f
->subclass
) {
178 res
= fs
->fmt
->write(fs
, f
);
180 ast_log(LOG_WARNING
, "Natural write failed\n");
182 ast_log(LOG_WARNING
, "Huh??\n");
184 /* XXX If they try to send us a type of frame that isn't the normal frame, and isn't
185 the one we've setup a translator for, we do the "wrong thing" XXX */
186 if (fs
->trans
&& f
->subclass
!= fs
->lastwriteformat
) {
187 ast_translator_free_path(fs
->trans
);
191 fs
->trans
= ast_translator_build_path(fs
->fmt
->format
, f
->subclass
);
193 ast_log(LOG_WARNING
, "Unable to translate to format %s, source format %s\n",
194 fs
->fmt
->name
, ast_getformatname(f
->subclass
));
196 struct ast_frame
*trf
;
197 fs
->lastwriteformat
= f
->subclass
;
198 /* Get the translated frame but don't consume the original in case they're using it on another stream */
199 trf
= ast_translate(fs
->trans
, f
, 0);
201 res
= fs
->fmt
->write(fs
, trf
);
203 ast_log(LOG_WARNING
, "Translated frame write failed\n");
211 static int copy(const char *infile
, const char *outfile
)
214 char buf
[4096]; /* XXX make it lerger. */
216 if ((ifd
= open(infile
, O_RDONLY
)) < 0) {
217 ast_log(LOG_WARNING
, "Unable to open %s in read-only mode\n", infile
);
220 if ((ofd
= open(outfile
, O_WRONLY
| O_TRUNC
| O_CREAT
, 0600)) < 0) {
221 ast_log(LOG_WARNING
, "Unable to open %s in write-only mode\n", outfile
);
225 while ( (len
= read(ifd
, buf
, sizeof(buf
)) ) ) {
228 ast_log(LOG_WARNING
, "Read failed on %s: %s\n", infile
, strerror(errno
));
231 /* XXX handle partial writes */
232 res
= write(ofd
, buf
, len
);
234 ast_log(LOG_WARNING
, "Write failed on %s (%d of %d): %s\n", outfile
, res
, len
, strerror(errno
));
235 len
= -1; /* error marker */
243 return -1; /* error */
245 return 0; /* success */
249 * \brief construct a filename. Absolute pathnames are preserved,
250 * relative names are prefixed by the sounds/ directory.
251 * The wav49 suffix is replaced by 'WAV'.
252 * Returns a malloc'ed string to be freed by the caller.
254 static char *build_filename(const char *filename
, const char *ext
)
258 if (!strcmp(ext
, "wav49"))
261 if (filename
[0] == '/')
262 asprintf(&fn
, "%s.%s", filename
, ext
);
264 asprintf(&fn
, "%s/sounds/%s.%s",
265 ast_config_AST_DATA_DIR
, filename
, ext
);
269 /* compare type against the list 'exts' */
270 /* XXX need a better algorithm */
271 static int exts_compare(const char *exts
, const char *type
)
274 char *stringp
= tmp
, *ext
;
276 ast_copy_string(tmp
, exts
, sizeof(tmp
));
277 while ((ext
= strsep(&stringp
, "|"))) {
278 if (!strcmp(ext
, type
))
285 static struct ast_filestream
*get_filestream(struct ast_format
*fmt
, FILE *bfile
)
287 struct ast_filestream
*s
;
289 int l
= sizeof(*s
) + fmt
->buf_size
+ fmt
->desc_size
; /* total allocation size */
290 if ( (s
= ast_calloc(1, l
)) == NULL
)
296 s
->private = ((char *)(s
+1)) + fmt
->buf_size
;
298 s
->buf
= (char *)(s
+1);
299 s
->fr
.src
= fmt
->name
;
304 * Default implementations of open and rewrite.
305 * Only use them if you don't have expensive stuff to do.
307 enum wrap_fn
{ WRAP_OPEN
, WRAP_REWRITE
};
309 static int fn_wrapper(struct ast_filestream
*s
, const char *comment
, enum wrap_fn mode
)
311 struct ast_format
*f
= s
->fmt
;
314 if (mode
== WRAP_OPEN
&& f
->open
&& f
->open(s
))
315 ast_log(LOG_WARNING
, "Unable to open format %s\n", f
->name
);
316 else if (mode
== WRAP_REWRITE
&& f
->rewrite
&& f
->rewrite(s
, comment
))
317 ast_log(LOG_WARNING
, "Unable to rewrite format %s\n", f
->name
);
319 /* preliminary checks succeed. update usecount */
320 ast_atomic_fetchadd_int(&f
->module
->usecnt
, +1);
322 ast_update_use_count();
327 static int rewrite_wrapper(struct ast_filestream
*s
, const char *comment
)
329 return fn_wrapper(s
, comment
, WRAP_REWRITE
);
332 static int open_wrapper(struct ast_filestream
*s
)
334 return fn_wrapper(s
, NULL
, WRAP_OPEN
);
338 ACTION_EXISTS
= 1, /* return matching format if file exists, 0 otherwise */
339 ACTION_DELETE
, /* delete file, return 0 on success, -1 on error */
340 ACTION_RENAME
, /* rename file. return 0 on success, -1 on error */
342 ACTION_COPY
/* copy file. return 0 on success, -1 on error */
346 * \brief perform various actions on a file. Second argument
347 * arg2 depends on the command:
348 * unused for EXISTS and DELETE
349 * destination file name (const char *) for COPY and RENAME
350 * struct ast_channel * for OPEN
351 * if fmt is NULL, OPEN will return the first matching entry,
352 * whereas other functions will run on all matching entries.
354 static int ast_filehelper(const char *filename
, const void *arg2
, const char *fmt
, const enum file_action action
)
356 struct ast_format
*f
;
357 int res
= (action
== ACTION_EXISTS
) ? 0 : -1;
359 if (AST_LIST_LOCK(&formats
)) {
360 ast_log(LOG_WARNING
, "Unable to lock format list\n");
363 /* Check for a specific format */
364 AST_LIST_TRAVERSE(&formats
, f
, list
) {
365 char *stringp
, *ext
= NULL
;
367 if (fmt
&& !exts_compare(f
->exts
, fmt
))
370 /* Look for a file matching the supported extensions.
371 * The file must exist, and for OPEN, must match
372 * one of the formats supported by the channel.
374 stringp
= ast_strdupa(f
->exts
); /* this is in the stack so does not need to be freed */
375 while ( (ext
= strsep(&stringp
, "|")) ) {
377 char *fn
= build_filename(filename
, ext
);
382 if ( stat(fn
, &st
) ) { /* file not existent */
386 /* for 'OPEN' we need to be sure that the format matches
387 * what the channel can process
389 if (action
== ACTION_OPEN
) {
390 struct ast_channel
*chan
= (struct ast_channel
*)arg2
;
392 struct ast_filestream
*s
;
394 if ( !(chan
->writeformat
& f
->format
) &&
395 !(f
->format
>= AST_FORMAT_MAX_AUDIO
&& fmt
)) {
397 continue; /* not a supported format */
399 if ( (bfile
= fopen(fn
, "r")) == NULL
) {
401 continue; /* cannot open file */
403 s
= get_filestream(f
, bfile
);
406 free(fn
); /* cannot allocate descriptor */
409 if (open_wrapper(s
)) {
413 continue; /* cannot run open on file */
415 /* ok this is good for OPEN */
421 if (s
->fmt
->format
< AST_FORMAT_MAX_AUDIO
)
429 break; /* will never get here */
431 case ACTION_EXISTS
: /* return the matching format */
436 if ( (res
= unlink(fn
)) )
437 ast_log(LOG_WARNING
, "unlink(%s) failed: %s\n", fn
, strerror(errno
));
442 char *nfn
= build_filename((const char *)arg2
, ext
);
444 ast_log(LOG_WARNING
, "Out of memory\n");
446 res
= action
== ACTION_COPY
? copy(fn
, nfn
) : rename(fn
, nfn
);
448 ast_log(LOG_WARNING
, "%s(%s,%s) failed: %s\n",
449 action
== ACTION_COPY
? "copy" : "rename",
450 fn
, nfn
, strerror(errno
));
457 ast_log(LOG_WARNING
, "Unknown helper %d\n", action
);
462 AST_LIST_UNLOCK(&formats
);
467 * \brief helper routine to locate a file with a given format
468 * and language preference.
469 * Try preflang, preflang with stripped '_' suffix, or NULL.
470 * In the standard asterisk, language goes just before the last component.
471 * In an alternative configuration, the language should be a prefix
472 * to the actual filename.
474 * The last parameter(s) point to a buffer of sufficient size,
475 * which on success is filled with the matching filename.
477 static int fileexists_core(const char *filename
, const char *fmt
, const char *preflang
,
478 char *buf
, int buflen
)
481 int langlen
; /* length of language string */
482 const char *c
= strrchr(filename
, '/');
483 int offset
= c
? c
- filename
+ 1 : 0; /* points right after the last '/' */
485 if (preflang
== NULL
)
487 langlen
= strlen(preflang
);
489 if (buflen
< langlen
+ strlen(filename
) + 2) {
490 ast_log(LOG_WARNING
, "buffer too small\n");
491 buf
[0] = '\0'; /* set to empty */
492 buf
= alloca(langlen
+ strlen(filename
) + 2); /* room for everything */
498 if (ast_language_is_prefix
) { /* new layout */
500 strcpy(buf
, preflang
);
502 strcpy(buf
+ langlen
+ 1, filename
);
504 strcpy(buf
, filename
); /* first copy the full string */
505 } else { /* old layout */
506 strcpy(buf
, filename
); /* first copy the full string */
508 /* insert the language and suffix if needed */
509 strcpy(buf
+ offset
, preflang
);
510 sprintf(buf
+ offset
+ langlen
, "/%s", filename
+ offset
);
513 res
= ast_filehelper(buf
, NULL
, fmt
, ACTION_EXISTS
);
514 if (res
> 0) /* found format */
516 if (langlen
== 0) /* no more formats */
518 if (preflang
[langlen
] == '_') /* we are on the local suffix */
519 langlen
= 0; /* try again with no language */
521 langlen
= (c
= strchr(preflang
, '_')) ? c
- preflang
: 0;
526 struct ast_filestream
*ast_openstream(struct ast_channel
*chan
, const char *filename
, const char *preflang
)
528 return ast_openstream_full(chan
, filename
, preflang
, 0);
531 struct ast_filestream
*ast_openstream_full(struct ast_channel
*chan
, const char *filename
, const char *preflang
, int asis
)
534 * Use fileexists_core() to find a file in a compatible
535 * language and format, set up a suitable translator,
536 * and open the stream.
538 int fmts
, res
, buflen
;
542 /* do this first, otherwise we detect the wrong writeformat */
543 ast_stopstream(chan
);
545 ast_deactivate_generator(chan
);
547 if (preflang
== NULL
)
549 buflen
= strlen(preflang
) + strlen(filename
) + 2;
550 buf
= alloca(buflen
);
553 fmts
= fileexists_core(filename
, NULL
, preflang
, buf
, buflen
);
555 fmts
&= AST_FORMAT_AUDIO_MASK
;
557 ast_log(LOG_WARNING
, "File %s does not exist in any format\n", filename
);
560 chan
->oldwriteformat
= chan
->writeformat
;
561 /* Set the channel to a format we can work with */
562 res
= ast_set_write_format(chan
, fmts
);
563 res
= ast_filehelper(buf
, chan
, NULL
, ACTION_OPEN
);
569 struct ast_filestream
*ast_openvstream(struct ast_channel
*chan
, const char *filename
, const char *preflang
)
571 /* As above, but for video. But here we don't have translators
572 * so we must enforce a format.
578 if (preflang
== NULL
)
580 buflen
= strlen(preflang
) + strlen(filename
) + 2;
581 buf
= alloca(buflen
);
585 for (format
= AST_FORMAT_MAX_AUDIO
<< 1; format
<= AST_FORMAT_MAX_VIDEO
; format
= format
<< 1) {
589 if (!(chan
->nativeformats
& format
))
591 fmt
= ast_getformatname(format
);
592 if ( fileexists_core(filename
, fmt
, preflang
, buf
, buflen
) < 1) /* no valid format */
594 fd
= ast_filehelper(buf
, chan
, fmt
, ACTION_OPEN
);
596 return chan
->vstream
;
597 ast_log(LOG_WARNING
, "File %s has video but couldn't be opened\n", filename
);
602 struct ast_frame
*ast_readframe(struct ast_filestream
*s
)
604 struct ast_frame
*f
= NULL
;
607 f
= s
->fmt
->read(s
, &whennext
);
611 static int ast_readaudio_callback(void *data
)
613 struct ast_filestream
*s
= data
;
617 struct ast_frame
*fr
= s
->fmt
->read(s
, &whennext
);
618 if (!fr
/* stream complete */ || ast_write(s
->owner
, fr
) /* error writing */) {
620 ast_log(LOG_WARNING
, "Failed to write frame\n");
621 s
->owner
->streamid
= -1;
623 ast_settimeout(s
->owner
, 0, NULL
, NULL
);
628 if (whennext
!= s
->lasttimeout
) {
630 if (s
->owner
->timingfd
> -1)
631 ast_settimeout(s
->owner
, whennext
, ast_readaudio_callback
, s
);
634 s
->owner
->streamid
= ast_sched_add(s
->owner
->sched
, whennext
/8, ast_readaudio_callback
, s
);
635 s
->lasttimeout
= whennext
;
641 static int ast_readvideo_callback(void *data
)
643 struct ast_filestream
*s
= data
;
647 struct ast_frame
*fr
= s
->fmt
->read(s
, &whennext
);
648 if (!fr
|| ast_write(s
->owner
, fr
)) { /* no stream or error, as above */
650 ast_log(LOG_WARNING
, "Failed to write frame\n");
651 s
->owner
->vstreamid
= -1;
655 if (whennext
!= s
->lasttimeout
) {
656 s
->owner
->vstreamid
= ast_sched_add(s
->owner
->sched
, whennext
/8, ast_readvideo_callback
, s
);
657 s
->lasttimeout
= whennext
;
663 int ast_applystream(struct ast_channel
*chan
, struct ast_filestream
*s
)
669 int ast_playstream(struct ast_filestream
*s
)
671 if (s
->fmt
->format
< AST_FORMAT_MAX_AUDIO
)
672 ast_readaudio_callback(s
);
674 ast_readvideo_callback(s
);
678 int ast_seekstream(struct ast_filestream
*fs
, off_t sample_offset
, int whence
)
680 return fs
->fmt
->seek(fs
, sample_offset
, whence
);
683 int ast_truncstream(struct ast_filestream
*fs
)
685 return fs
->fmt
->trunc(fs
);
688 off_t
ast_tellstream(struct ast_filestream
*fs
)
690 return fs
->fmt
->tell(fs
);
693 int ast_stream_fastforward(struct ast_filestream
*fs
, off_t ms
)
695 return ast_seekstream(fs
, ms
* DEFAULT_SAMPLES_PER_MS
, SEEK_CUR
);
698 int ast_stream_rewind(struct ast_filestream
*fs
, off_t ms
)
700 return ast_seekstream(fs
, -ms
* DEFAULT_SAMPLES_PER_MS
, SEEK_CUR
);
703 int ast_closestream(struct ast_filestream
*f
)
707 /* Stop a running stream if there is one */
709 if (f
->fmt
->format
< AST_FORMAT_MAX_AUDIO
) {
710 f
->owner
->stream
= NULL
;
711 if (f
->owner
->streamid
> -1)
712 ast_sched_del(f
->owner
->sched
, f
->owner
->streamid
);
713 f
->owner
->streamid
= -1;
715 ast_settimeout(f
->owner
, 0, NULL
, NULL
);
718 f
->owner
->vstream
= NULL
;
719 if (f
->owner
->vstreamid
> -1)
720 ast_sched_del(f
->owner
->sched
, f
->owner
->vstreamid
);
721 f
->owner
->vstreamid
= -1;
724 /* destroy the translator on exit */
726 ast_translator_free_path(f
->trans
);
728 if (f
->realfilename
&& f
->filename
) {
729 size
= strlen(f
->filename
) + strlen(f
->realfilename
) + 15;
732 snprintf(cmd
,size
,"/bin/mv -f %s %s",f
->filename
,f
->realfilename
);
733 ast_safe_system(cmd
);
739 free(f
->realfilename
);
744 ast_closestream(f
->vfs
);
745 ast_atomic_fetchadd_int(&f
->fmt
->module
->usecnt
, -1);
746 ast_update_use_count();
753 * Look the various language-specific places where a file could exist.
755 int ast_fileexists(const char *filename
, const char *fmt
, const char *preflang
)
760 if (preflang
== NULL
)
762 buflen
= strlen(preflang
) + strlen(filename
) + 2; /* room for everything */
763 buf
= alloca(buflen
);
766 return fileexists_core(filename
, fmt
, preflang
, buf
, buflen
);
769 int ast_filedelete(const char *filename
, const char *fmt
)
771 return ast_filehelper(filename
, NULL
, fmt
, ACTION_DELETE
);
774 int ast_filerename(const char *filename
, const char *filename2
, const char *fmt
)
776 return ast_filehelper(filename
, filename2
, fmt
, ACTION_RENAME
);
779 int ast_filecopy(const char *filename
, const char *filename2
, const char *fmt
)
781 return ast_filehelper(filename
, filename2
, fmt
, ACTION_COPY
);
784 int ast_streamfile(struct ast_channel
*chan
, const char *filename
, const char *preflang
)
786 struct ast_filestream
*fs
;
787 struct ast_filestream
*vfs
=NULL
;
790 fs
= ast_openstream(chan
, filename
, preflang
);
792 vfs
= ast_openvstream(chan
, filename
, preflang
);
794 ast_log(LOG_DEBUG
, "Ooh, found a video stream, too, format %s\n", ast_getformatname(vfs
->fmt
->format
));
796 if (ast_applystream(chan
, fs
))
798 if (vfs
&& ast_applystream(chan
, vfs
))
800 if (ast_playstream(fs
))
802 if (vfs
&& ast_playstream(vfs
))
805 if (option_verbose
> 2)
806 ast_verbose(VERBOSE_PREFIX_3
"Playing '%s' (language '%s')\n", filename
, preflang
? preflang
: "default");
810 ast_log(LOG_WARNING
, "Unable to open %s (format %s): %s\n", filename
, ast_getformatname_multiple(fmt
, sizeof(fmt
), chan
->nativeformats
), strerror(errno
));
814 struct ast_filestream
*ast_readfile(const char *filename
, const char *type
, const char *comment
, int flags
, int check
, mode_t mode
)
817 struct ast_format
*f
;
818 struct ast_filestream
*fs
= NULL
;
821 if (AST_LIST_LOCK(&formats
)) {
822 ast_log(LOG_WARNING
, "Unable to lock format list\n");
826 AST_LIST_TRAVERSE(&formats
, f
, list
) {
828 if (!exts_compare(f
->exts
, type
))
831 fn
= build_filename(filename
, type
);
833 bfile
= fopen(fn
, "r");
834 if (!bfile
|| (fs
= get_filestream(f
, bfile
)) == NULL
||
836 ast_log(LOG_WARNING
, "Unable to open %s\n", fn
);
848 fs
->filename
= strdup(filename
);
853 AST_LIST_UNLOCK(&formats
);
855 ast_log(LOG_WARNING
, "No such format '%s'\n", type
);
860 struct ast_filestream
*ast_writefile(const char *filename
, const char *type
, const char *comment
, int flags
, int check
, mode_t mode
)
863 /* compiler claims this variable can be used before initialization... */
865 struct ast_format
*f
;
866 struct ast_filestream
*fs
= NULL
;
870 if (AST_LIST_LOCK(&formats
)) {
871 ast_log(LOG_WARNING
, "Unable to lock format list\n");
875 /* set the O_TRUNC flag if and only if there is no O_APPEND specified */
876 /* We really can't use O_APPEND as it will break WAV header updates */
877 if (flags
& O_APPEND
) {
883 myflags
|= O_WRONLY
| O_CREAT
;
885 /* XXX need to fix this - we should just do the fopen,
886 * not open followed by fdopen()
888 AST_LIST_TRAVERSE(&formats
, f
, list
) {
889 char *fn
, *orig_fn
= NULL
;
893 if (!exts_compare(f
->exts
, type
))
896 fn
= build_filename(filename
, type
);
897 fd
= open(fn
, flags
| myflags
, mode
);
899 /* fdopen() the resulting file stream */
900 bfile
= fdopen(fd
, ((flags
| myflags
) & O_RDWR
) ? "w+" : "w");
902 ast_log(LOG_WARNING
, "Whoa, fdopen failed: %s!\n", strerror(errno
));
908 if (ast_opt_cache_record_files
&& (fd
> -1)) {
911 fclose(bfile
); /* this also closes fd */
913 We touch orig_fn just as a place-holder so other things (like vmail) see the file is there.
914 What we are really doing is writing to record_cache_dir until we are done then we will mv the file into place.
916 orig_fn
= ast_strdupa(fn
);
917 for (c
= fn
; *c
; c
++)
921 size
= strlen(fn
) + strlen(record_cache_dir
) + 2;
923 strcpy(buf
, record_cache_dir
);
928 fd
= open(fn
, flags
| myflags
, mode
);
930 /* fdopen() the resulting file stream */
931 bfile
= fdopen(fd
, ((flags
| myflags
) & O_RDWR
) ? "w+" : "w");
933 ast_log(LOG_WARNING
, "Whoa, fdopen failed: %s!\n", strerror(errno
));
941 fs
= get_filestream(f
, bfile
);
942 if (!fs
|| rewrite_wrapper(fs
, comment
)) {
943 ast_log(LOG_WARNING
, "Unable to rewrite %s\n", fn
);
957 fs
->realfilename
= strdup(orig_fn
);
958 fs
->filename
= strdup(fn
);
960 fs
->realfilename
= NULL
;
961 fs
->filename
= strdup(filename
);
964 /* If truncated, we'll be at the beginning; if not truncated, then append */
965 f
->seek(fs
, 0, SEEK_END
);
966 } else if (errno
!= EEXIST
) {
967 ast_log(LOG_WARNING
, "Unable to open file %s: %s\n", fn
, strerror(errno
));
971 /* if buf != NULL then fn is already free and pointing to it */
976 AST_LIST_UNLOCK(&formats
);
978 ast_log(LOG_WARNING
, "No such format '%s'\n", type
);
984 * \brief the core of all waitstream() functions
986 static int waitstream_core(struct ast_channel
*c
, const char *breakon
,
987 const char *forward
, const char *rewind
, int skip_ms
,
988 int audiofd
, int cmdfd
, const char *context
)
999 int ms
= ast_sched_wait(c
->sched
);
1000 if (ms
< 0 && !c
->timingfunc
) {
1007 res
= ast_waitfor(c
, ms
);
1009 ast_log(LOG_WARNING
, "Select failed (%s)\n", strerror(errno
));
1014 struct ast_channel
*rchan
= ast_waitfor_nandfds(&c
, 1, &cmdfd
, (cmdfd
> -1) ? 1 : 0, NULL
, &outfd
, &ms
);
1015 if (!rchan
&& (outfd
< 0) && (ms
)) {
1019 ast_log(LOG_WARNING
, "Wait failed (%s)\n", strerror(errno
));
1021 } else if (outfd
> -1) { /* this requires cmdfd set */
1022 /* The FD we were watching has something waiting */
1025 /* if rchan is set, it is 'c' */
1026 res
= rchan
? 1 : 0; /* map into 'res' values */
1029 struct ast_frame
*fr
= ast_read(c
);
1032 switch(fr
->frametype
) {
1033 case AST_FRAME_DTMF
:
1035 const char exten
[2] = { fr
->subclass
, '\0' };
1036 if (ast_exists_extension(c
, context
, exten
, 1, c
->cid
.cid_num
)) {
1042 if (strchr(forward
,res
)) {
1043 ast_stream_fastforward(c
->stream
, skip_ms
);
1044 } else if (strchr(rewind
,res
)) {
1045 ast_stream_rewind(c
->stream
, skip_ms
);
1046 } else if (strchr(breakon
, res
)) {
1052 case AST_FRAME_CONTROL
:
1053 switch(fr
->subclass
) {
1054 case AST_CONTROL_HANGUP
:
1057 case AST_CONTROL_RINGING
:
1058 case AST_CONTROL_ANSWER
:
1059 case AST_CONTROL_VIDUPDATE
:
1063 ast_log(LOG_WARNING
, "Unexpected control subclass '%d'\n", fr
->subclass
);
1065 case AST_FRAME_VOICE
:
1066 /* Write audio if appropriate */
1068 write(audiofd
, fr
->data
, fr
->datalen
);
1070 /* Ignore all others */
1073 ast_sched_runq(c
->sched
);
1075 return (c
->_softhangup
? -1 : 0);
1078 int ast_waitstream_fr(struct ast_channel
*c
, const char *breakon
, const char *forward
, const char *rewind
, int ms
)
1080 return waitstream_core(c
, breakon
, forward
, rewind
, ms
,
1081 -1 /* no audiofd */, -1 /* no cmdfd */, NULL
/* no context */);
1084 int ast_waitstream(struct ast_channel
*c
, const char *breakon
)
1086 return waitstream_core(c
, breakon
, NULL
, NULL
, 0, -1, -1, NULL
);
1089 int ast_waitstream_full(struct ast_channel
*c
, const char *breakon
, int audiofd
, int cmdfd
)
1091 return waitstream_core(c
, breakon
, NULL
, NULL
, 0,
1092 audiofd
, cmdfd
, NULL
/* no context */);
1095 int ast_waitstream_exten(struct ast_channel
*c
, const char *context
)
1097 /* Waitstream, with return in the case of a valid 1 digit extension */
1098 /* in the current or specified context being pressed */
1101 context
= c
->context
;
1102 return waitstream_core(c
, NULL
, NULL
, NULL
, 0,
1107 * if the file name is non-empty, try to play it.
1108 * Return 0 if success, -1 if error, digit if interrupted by a digit.
1109 * If digits == "" then we can simply check for non-zero.
1111 int ast_stream_and_wait(struct ast_channel
*chan
, const char *file
,
1112 const char *language
, const char *digits
)
1115 if (!ast_strlen_zero(file
)) {
1116 res
= ast_streamfile(chan
, file
, language
);
1118 res
= ast_waitstream(chan
, digits
);
1123 static int show_file_formats(int fd
, int argc
, char *argv
[])
1125 #define FORMAT "%-10s %-10s %-20s\n"
1126 #define FORMAT2 "%-10s %-10s %-20s\n"
1127 struct ast_format
*f
;
1131 return RESULT_SHOWUSAGE
;
1132 ast_cli(fd
, FORMAT
, "Format", "Name", "Extensions");
1134 if (AST_LIST_LOCK(&formats
)) {
1135 ast_log(LOG_WARNING
, "Unable to lock format list\n");
1139 AST_LIST_TRAVERSE(&formats
, f
, list
) {
1140 ast_cli(fd
, FORMAT2
, ast_getformatname(f
->format
), f
->name
, f
->exts
);
1143 AST_LIST_UNLOCK(&formats
);
1144 ast_cli(fd
, "%d file formats registered.\n", count_fmt
);
1145 return RESULT_SUCCESS
;
1150 struct ast_cli_entry show_file
=
1152 { "show", "file", "formats" },
1154 "Displays file formats",
1155 "Usage: show file formats\n"
1156 " displays currently registered file formats (if any)\n"
1159 int ast_file_init(void)
1161 ast_cli_register(&show_file
);