Asterisk - The Open Source Telephony Project  GIT-master-0190e70
file.c
Go to the documentation of this file.
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
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.
13  *
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.
17  */
18 
19 /*! \file
20  *
21  * \brief Generic File Format Support.
22  *
23  * \author Mark Spencer <markster@digium.com>
24  */
25 
26 /*** MODULEINFO
27  <support_level>core</support_level>
28  ***/
29 
30 #include "asterisk.h"
31 
32 #include <dirent.h>
33 #include <sys/stat.h>
34 #include <sys/wait.h>
35 #include <math.h>
36 
37 #include "asterisk/_private.h" /* declare ast_file_init() */
38 #include "asterisk/paths.h" /* use ast_config_AST_DATA_DIR */
39 #include "asterisk/mod_format.h"
40 #include "asterisk/cli.h"
41 #include "asterisk/channel.h"
42 #include "asterisk/sched.h"
43 #include "asterisk/translate.h"
44 #include "asterisk/utils.h"
45 #include "asterisk/lock.h"
46 #include "asterisk/app.h"
47 #include "asterisk/pbx.h"
48 #include "asterisk/linkedlists.h"
49 #include "asterisk/module.h"
50 #include "asterisk/astobj2.h"
51 #include "asterisk/test.h"
52 #include "asterisk/stasis.h"
53 #include "asterisk/json.h"
54 #include "asterisk/stasis_system.h"
55 #include "asterisk/media_cache.h"
56 
57 /*! \brief
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.
64  *
65  * This is settable in asterisk.conf.
66  */
68 
70 
73 
74 static struct ast_json *json_array_from_list(const char *list, const char *sep)
75 {
77  char *stringp, *ext;
78 
79  stringp = ast_strdupa(list); /* this is in the stack so does not need to be freed */
80  if (!array || !stringp) {
81  return NULL;
82  }
83 
84  while ((ext = strsep(&stringp, sep))) {
86  return NULL;
87  }
88  }
89 
90  return ast_json_ref(array);
91 }
92 
93 static int publish_format_update(const struct ast_format_def *f, struct stasis_message_type *type)
94 {
95  RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
96  RAII_VAR(struct ast_json_payload *, json_payload, NULL, ao2_cleanup);
97  RAII_VAR(struct ast_json *, json_object, NULL, ast_json_unref);
98 
99  if (!type) {
100  return -1;
101  }
102 
103  json_object = ast_json_pack("{s: s, s: o}",
104  "format", f->name,
105  "extensions", json_array_from_list(f->exts, "|"));
106  if (!json_object) {
107  return -1;
108  }
109 
110  json_payload = ast_json_payload_create(json_object);
111  if (!json_payload) {
112  return -1;
113  }
114 
115  msg = stasis_message_create(type, json_payload);
116  if (!msg) {
117  return -1;
118  }
119 
121  return 0;
122 }
123 
124 int __ast_format_def_register(const struct ast_format_def *f, struct ast_module *mod)
125 {
126  struct ast_format_def *tmp;
127 
130  if (!strcasecmp(f->name, tmp->name)) {
132  ast_log(LOG_WARNING, "Tried to register '%s' format, already registered\n", f->name);
133  return -1;
134  }
135  }
136  if (!(tmp = ast_calloc(1, sizeof(*tmp)))) {
138  return -1;
139  }
140  *tmp = *f;
141  tmp->module = mod;
142  if (tmp->buf_size) {
143  /*
144  * Align buf_size properly, rounding up to the machine-specific
145  * alignment for pointers.
146  */
147  struct _test_align { void *a, *b; } p;
148  int align = (char *)&p.b - (char *)&p.a;
149  tmp->buf_size = ((f->buf_size + align - 1) / align) * align;
150  }
151 
152  memset(&tmp->list, 0, sizeof(tmp->list));
153 
154  AST_RWLIST_INSERT_HEAD(&formats, tmp, list);
156  ast_verb(2, "Registered file format %s, extension(s) %s\n", f->name, f->exts);
158 
159  return 0;
160 }
161 
163 {
164  struct ast_format_def *tmp;
165  int res = -1;
166 
169  if (!strcasecmp(name, tmp->name)) {
172  ast_free(tmp);
173  res = 0;
174  }
175  }
178 
179  if (!res)
180  ast_verb(2, "Unregistered format %s\n", name);
181  else
182  ast_log(LOG_WARNING, "Tried to unregister format %s, already unregistered\n", name);
183 
184  return res;
185 }
186 
188 {
189  ast_channel_lock(tmp);
190 
191  /* Stop a running stream if there is one */
192  if (ast_channel_stream(tmp)) {
196  ast_log(LOG_WARNING, "Unable to restore format back to %s\n", ast_format_get_name(ast_channel_oldwriteformat(tmp)));
197  }
198  /* Stop the video stream too */
199  if (ast_channel_vstream(tmp) != NULL) {
202  }
203 
204  ast_channel_unlock(tmp);
205 
206  return 0;
207 }
208 
209 int ast_writestream(struct ast_filestream *fs, struct ast_frame *f)
210 {
211  int res = -1;
212  if (f->frametype == AST_FRAME_VIDEO) {
214  /* This is the audio portion. Call the video one... */
215  if (!fs->vfs && fs->filename) {
216  const char *type = ast_format_get_name(f->subclass.format);
217  fs->vfs = ast_writefile(fs->filename, type, NULL, fs->flags, 0, fs->mode);
218  ast_debug(1, "Opened video output file\n");
219  }
220  if (fs->vfs)
221  return ast_writestream(fs->vfs, f);
222  /* else ignore */
223  return 0;
224  }
225  } else if (f->frametype != AST_FRAME_VOICE) {
226  ast_log(LOG_WARNING, "Tried to write non-voice frame\n");
227  return -1;
228  }
230  res = fs->fmt->write(fs, f);
231  if (res < 0)
232  ast_log(LOG_WARNING, "Natural write failed\n");
233  else if (res > 0)
234  ast_log(LOG_WARNING, "Huh??\n");
235  } else {
236  /* XXX If they try to send us a type of frame that isn't the normal frame, and isn't
237  the one we've setup a translator for, we do the "wrong thing" XXX */
240  fs->trans = NULL;
241  }
242  if (!fs->trans) {
244  }
245  if (!fs->trans) {
246  ast_log(LOG_WARNING, "Unable to translate to format %s, source format %s\n",
248  } else {
249  struct ast_frame *trf;
251  /* Get the translated frame but don't consume the original in case they're using it on another stream */
252  if ((trf = ast_translate(fs->trans, f, 0))) {
253  struct ast_frame *cur;
254 
255  /* the translator may have returned multiple frames, so process them */
256  for (cur = trf; cur; cur = AST_LIST_NEXT(cur, frame_list)) {
257  if ((res = fs->fmt->write(fs, trf))) {
258  ast_log(LOG_WARNING, "Translated frame write failed\n");
259  break;
260  }
261  }
262  ast_frfree(trf);
263  } else {
264  res = 0;
265  }
266  }
267  }
268  return res;
269 }
270 
271 static int copy(const char *infile, const char *outfile)
272 {
273  int ifd, ofd, len;
274  char buf[4096]; /* XXX make it lerger. */
275 
276  if ((ifd = open(infile, O_RDONLY)) < 0) {
277  ast_log(LOG_WARNING, "Unable to open %s in read-only mode\n", infile);
278  return -1;
279  }
280  if ((ofd = open(outfile, O_WRONLY | O_TRUNC | O_CREAT, AST_FILE_MODE)) < 0) {
281  ast_log(LOG_WARNING, "Unable to open %s in write-only mode\n", outfile);
282  close(ifd);
283  return -1;
284  }
285  while ( (len = read(ifd, buf, sizeof(buf)) ) ) {
286  int res;
287  if (len < 0) {
288  ast_log(LOG_WARNING, "Read failed on %s: %s\n", infile, strerror(errno));
289  break;
290  }
291  /* XXX handle partial writes */
292  res = write(ofd, buf, len);
293  if (res != len) {
294  ast_log(LOG_WARNING, "Write failed on %s (%d of %d): %s\n", outfile, res, len, strerror(errno));
295  len = -1; /* error marker */
296  break;
297  }
298  }
299  close(ifd);
300  close(ofd);
301  if (len < 0) {
302  unlink(outfile);
303  return -1; /* error */
304  }
305  return 0; /* success */
306 }
307 
308 /*!
309  * \brief construct a filename. Absolute pathnames are preserved,
310  * relative names are prefixed by the sounds/ directory.
311  * The wav49 suffix is replaced by 'WAV'.
312  * Returns a malloc'ed string to be freed by the caller.
313  */
314 static char *build_filename(const char *filename, const char *ext)
315 {
316  char *fn = NULL;
317 
318  /* The wav49 -> WAV translation is duplicated in apps/app_mixmonitor.c, so
319  if you change it here you need to change it there as well */
320  if (!strcmp(ext, "wav49"))
321  ext = "WAV";
322 
323  if (filename[0] == '/') {
324  if (ast_asprintf(&fn, "%s.%s", filename, ext) < 0) {
325  fn = NULL;
326  }
327  } else {
328  if (ast_asprintf(&fn, "%s/sounds/%s.%s",
329  ast_config_AST_DATA_DIR, filename, ext) < 0) {
330  fn = NULL;
331  }
332  }
333  return fn;
334 }
335 
336 /* compare type against the list 'exts' */
337 /* XXX need a better algorithm */
338 static int type_in_list(const char *list, const char *type, int (*cmp)(const char *s1, const char *s2))
339 {
340  char *stringp = ast_strdupa(list), *item;
341 
342  while ((item = strsep(&stringp, "|"))) {
343  if (!cmp(item, type)) {
344  return 1;
345  }
346  }
347 
348  return 0;
349 }
350 
351 #define exts_compare(list, type) (type_in_list((list), (type), strcmp))
352 
353 /*!
354  * \internal
355  * \brief Close the file stream by canceling any pending read / write callbacks
356  */
357 static void filestream_close(struct ast_filestream *f)
358 {
359  enum ast_media_type format_type = ast_format_get_type(f->fmt->format);
360 
361  if (!f->owner) {
362  return;
363  }
364 
365  /* Stop a running stream if there is one */
366  switch (format_type)
367  {
371  ast_settimeout(f->owner, 0, NULL, NULL);
372  break;
376  break;
377  default:
378  ast_log(AST_LOG_WARNING, "Unable to schedule deletion of filestream with unsupported type %s\n", f->fmt->name);
379  break;
380  }
381 }
382 
383 static void filestream_destructor(void *arg)
384 {
385  struct ast_filestream *f = arg;
386  int status;
387  int pid = -1;
388 
389  /* Stop a running stream if there is one */
390  filestream_close(f);
391 
392  /* destroy the translator on exit */
393  if (f->trans)
395 
396  if (f->fmt->close) {
397  void (*closefn)(struct ast_filestream *) = f->fmt->close;
398  closefn(f);
399  }
400 
401  if (f->f) {
402  fclose(f->f);
403  }
404 
405  if (f->realfilename && f->filename) {
406  pid = ast_safe_fork(0);
407  if (!pid) {
408  execl("/bin/mv", "mv", "-f", f->filename, f->realfilename, SENTINEL);
409  _exit(1);
410  }
411  else if (pid > 0) {
412  /* Block the parent until the move is complete.*/
413  waitpid(pid, &status, 0);
414  }
415  }
416 
417  ast_free(f->filename);
419  if (f->vfs)
420  ast_closestream(f->vfs);
422  ast_free((void *)f->orig_chan_name);
426 }
427 
428 static struct ast_filestream *get_filestream(struct ast_format_def *fmt, FILE *bfile)
429 {
430  struct ast_filestream *s;
431  int l = sizeof(*s) + fmt->buf_size + fmt->desc_size; /* total allocation size */
432 
433  if (!ast_module_running_ref(fmt->module)) {
434  return NULL;
435  }
436 
438  if (!s) {
439  ast_module_unref(fmt->module);
440  return NULL;
441  }
442  s->fmt = fmt;
443  s->f = bfile;
444 
445  if (fmt->desc_size)
446  s->_private = ((char *)(s + 1)) + fmt->buf_size;
447  if (fmt->buf_size)
448  s->buf = (char *)(s + 1);
449  s->fr.src = fmt->name;
450 
453  } else if (ast_format_get_type(fmt->format) == AST_MEDIA_TYPE_VIDEO) {
455  }
456  s->fr.mallocd = 0;
457  s->fr.subclass.format = ao2_bump(fmt->format);
458 
459  return s;
460 }
461 
462 /*
463  * Default implementations of open and rewrite.
464  * Only use them if you don't have expensive stuff to do.
465  */
467 
468 static int fn_wrapper(struct ast_filestream *s, const char *comment, enum wrap_fn mode)
469 {
470  struct ast_format_def *f = s->fmt;
471  int ret = -1;
472  int (*openfn)(struct ast_filestream *s);
473 
474  if (mode == WRAP_OPEN && (openfn = f->open) && openfn(s))
475  ast_log(LOG_WARNING, "Unable to open format %s\n", f->name);
476  else if (mode == WRAP_REWRITE && f->rewrite && f->rewrite(s, comment))
477  ast_log(LOG_WARNING, "Unable to rewrite format %s\n", f->name);
478  else {
479  /* preliminary checks succeed. */
480  ret = 0;
481  }
482  return ret;
483 }
484 
485 static int rewrite_wrapper(struct ast_filestream *s, const char *comment)
486 {
487  return fn_wrapper(s, comment, WRAP_REWRITE);
488 }
489 
490 static int open_wrapper(struct ast_filestream *s)
491 {
492  return fn_wrapper(s, NULL, WRAP_OPEN);
493 }
494 
496  ACTION_EXISTS = 1, /* return matching format if file exists, 0 otherwise */
497  ACTION_DELETE, /* delete file, return 0 on success, -1 on error */
498  ACTION_RENAME, /* rename file. return 0 on success, -1 on error */
500  ACTION_COPY /* copy file. return 0 on success, -1 on error */
501 };
502 
503 /*!
504  * \internal
505  * \brief perform various actions on a file. Second argument
506  * \note arg2 depends on the command:
507  * unused for DELETE
508  * optional ast_format_cap holding all the formats found for a file, for EXISTS.
509  * destination file name (const char *) for COPY and RENAME
510  * struct ast_channel * for OPEN
511  * if fmt is NULL, OPEN will return the first matching entry,
512  * whereas other functions will run on all matching entries.
513  */
514 static int filehelper(const char *filename, const void *arg2, const char *fmt, const enum file_action action)
515 {
516  struct ast_format_def *f;
517  int res = (action == ACTION_EXISTS) ? 0 : -1;
518 
520  /* Check for a specific format */
521  AST_RWLIST_TRAVERSE(&formats, f, list) {
522  char *ext = NULL;
523  char storage[strlen(f->exts) + 1];
524  char *stringp;
525 
526  if (fmt && !exts_compare(f->exts, fmt))
527  continue;
528 
529  /* Look for a file matching the supported extensions.
530  * The file must exist, and for OPEN, must match
531  * one of the formats supported by the channel.
532  */
533  strcpy(storage, f->exts); /* safe - this is in the stack so does not need to be freed */
534  stringp = storage;
535  while ( (ext = strsep(&stringp, "|")) ) {
536  struct stat st;
537  char *fn = build_filename(filename, ext);
538 
539  if (fn == NULL)
540  continue;
541 
542  if ( stat(fn, &st) ) { /* file not existent */
543  ast_free(fn);
544  continue;
545  }
546  /* for 'OPEN' we need to be sure that the format matches
547  * what the channel can process
548  */
549  if (action == ACTION_OPEN) {
550  struct ast_channel *chan = (struct ast_channel *)arg2;
551  FILE *bfile;
552  struct ast_filestream *s;
553 
555  !(((ast_format_get_type(f->format) == AST_MEDIA_TYPE_AUDIO) && fmt) ||
556  ((ast_format_get_type(f->format) == AST_MEDIA_TYPE_VIDEO) && fmt))) {
557  ast_free(fn);
558  continue; /* not a supported format */
559  }
560  if ( (bfile = fopen(fn, "r")) == NULL) {
561  ast_free(fn);
562  continue; /* cannot open file */
563  }
564  s = get_filestream(f, bfile);
565  if (!s) {
566  fclose(bfile);
567  ast_free(fn); /* cannot allocate descriptor */
568  continue;
569  }
570  if (open_wrapper(s)) {
571  ast_free(fn);
572  ast_closestream(s);
573  continue; /* cannot run open on file */
574  }
575  if (st.st_size == 0) {
576  ast_log(LOG_WARNING, "File %s detected to have zero size.\n", fn);
577  }
578  /* ok this is good for OPEN */
579  res = 1; /* found */
580  s->lasttimeout = -1;
581  s->fmt = f;
582  s->trans = NULL;
583  s->filename = NULL;
585  if (ast_channel_stream(chan))
587  ast_channel_stream_set(chan, s);
588  } else {
589  if (ast_channel_vstream(chan))
591  ast_channel_vstream_set(chan, s);
592  }
593  ast_free(fn);
594  break;
595  }
596  switch (action) {
597  case ACTION_OPEN:
598  break; /* will never get here */
599 
600  case ACTION_EXISTS: /* return the matching format */
601  /* if arg2 is present, it is a format capabilities structure.
602  * Add this format to the set of formats this file can be played in */
603  if (arg2) {
604  ast_format_cap_append((struct ast_format_cap *) arg2, f->format, 0);
605  }
606  res = 1; /* file does exist and format it exists in is returned in arg2 */
607  break;
608 
609  case ACTION_DELETE:
610  if ( (res = unlink(fn)) )
611  ast_log(LOG_WARNING, "unlink(%s) failed: %s\n", fn, strerror(errno));
612  break;
613 
614  case ACTION_RENAME:
615  case ACTION_COPY: {
616  char *nfn = build_filename((const char *)arg2, ext);
617  if (!nfn)
618  ast_log(LOG_WARNING, "Out of memory\n");
619  else {
620  res = action == ACTION_COPY ? copy(fn, nfn) : rename(fn, nfn);
621  if (res)
622  ast_log(LOG_WARNING, "%s(%s,%s) failed: %s\n",
623  action == ACTION_COPY ? "copy" : "rename",
624  fn, nfn, strerror(errno));
625  ast_free(nfn);
626  }
627  }
628  break;
629 
630  default:
631  ast_log(LOG_WARNING, "Unknown helper %u\n", action);
632  }
633  ast_free(fn);
634  }
635  }
637  return res;
638 }
639 
640 static int is_absolute_path(const char *filename)
641 {
642  return filename[0] == '/';
643 }
644 
645 static int is_remote_path(const char *filename)
646 {
647  return strstr(filename, "://") ? 1 : 0;
648 }
649 
650 /*!
651  * \brief test if a file exists for a given format.
652  * \note result_cap is OPTIONAL
653  * \retval 1, true and result_cap represents format capabilities file exists in.
654  * \retval 0, false
655  */
656 static int fileexists_test(const char *filename, const char *fmt, const char *lang,
657  char *buf, int buflen, struct ast_format_cap *result_cap)
658 {
659  if (buf == NULL) {
660  return 0;
661  }
662 
663  if (is_remote_path(filename) && !ast_media_cache_retrieve(filename, NULL, buf, buflen)) {
664  return filehelper(buf, result_cap, NULL, ACTION_EXISTS);
665  }
666 
667  if (ast_language_is_prefix && !is_absolute_path(filename)) { /* new layout */
668  if (lang) {
669  snprintf(buf, buflen, "%s/%s", lang, filename);
670  } else {
671  snprintf(buf, buflen, "%s", filename);
672  }
673  } else { /* old layout */
674  strcpy(buf, filename); /* first copy the full string */
675  if (lang) {
676  /* insert the language and suffix if needed */
677  const char *c = strrchr(filename, '/');
678  int offset = c ? c - filename + 1 : 0; /* points right after the last '/' */
679  snprintf(buf + offset, buflen - offset, "%s/%s", lang, filename + offset);
680  }
681  }
682 
683  return filehelper(buf, result_cap, fmt, ACTION_EXISTS);
684 }
685 
686 /*!
687  * \brief helper routine to locate a file with a given format
688  * and language preference.
689  *
690  * \note Try preflang, preflang with stripped '_' suffices, or NULL.
691  *
692  * \note The last parameter(s) point to a buffer of sufficient size,
693  * which on success is filled with the matching filename.
694  *
695  * \param filename Name of the file.
696  * \param fmt Format to look for the file in. OPTIONAL
697  * \param preflang The perfered language
698  * \param buf Returns the matching filename
699  * \param buflen Size of the buf
700  * \param result_cap OPTIONAL format capabilities result structure
701  * returns what formats the file was found in.
702  *
703  * \retval 1, true. file exists and result format is set
704  * \retval 0, false. file does not exist.
705  */
706 static int fileexists_core(const char *filename, const char *fmt, const char *preflang,
707  char *buf, int buflen, struct ast_format_cap *result_cap)
708 {
709  char *lang;
710 
711  if (buf == NULL) {
712  return 0;
713  }
714 
715  /* We try languages in the following order:
716  * preflang (may include dialect and style codes)
717  * lang (preflang without dialect - if any)
718  * <none>
719  * default (unless the same as preflang or lang without dialect)
720  */
721 
722  lang = ast_strdupa(preflang);
723 
724  /* Try preferred language, including removing any style or dialect codes */
725  while (!ast_strlen_zero(lang)) {
726  char *end;
727 
728  if (fileexists_test(filename, fmt, lang, buf, buflen, result_cap)) {
729  return 1;
730  }
731 
732  if ((end = strrchr(lang, '_')) != NULL) {
733  *end = '\0';
734  continue;
735  }
736 
737  break;
738  }
739 
740  /* Try without any language */
741  if (fileexists_test(filename, fmt, NULL, buf, buflen, result_cap)) {
742  return 1;
743  }
744 
745  /* Finally try the default language unless it was already tried before */
746  if ((ast_strlen_zero(preflang) || strcmp(preflang, DEFAULT_LANGUAGE)) && (ast_strlen_zero(lang) || strcmp(lang, DEFAULT_LANGUAGE))) {
747  if ((fileexists_test(filename, fmt, DEFAULT_LANGUAGE, buf, buflen, result_cap)) > 0) {
748  return 1;
749  }
750  }
751 
752  return 0;
753 }
754 
755 struct ast_filestream *ast_openstream(struct ast_channel *chan, const char *filename, const char *preflang)
756 {
757  return ast_openstream_full(chan, filename, preflang, 0);
758 }
759 
760 struct ast_filestream *ast_openstream_full(struct ast_channel *chan, const char *filename, const char *preflang, int asis)
761 {
762  /*
763  * Use fileexists_core() to find a file in a compatible
764  * language and format, set up a suitable translator,
765  * and open the stream.
766  */
767  struct ast_format_cap *file_fmt_cap;
768  int res;
769  int buflen;
770  char *buf;
771 
772  if (!asis) {
773  /* do this first, otherwise we detect the wrong writeformat */
774  ast_stopstream(chan);
775  if (ast_channel_generator(chan))
777  }
778  if (preflang == NULL)
779  preflang = "";
780  buflen = strlen(preflang) + strlen(filename) + 4;
781  buf = ast_alloca(buflen);
782 
783  if (!(file_fmt_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
784  return NULL;
785  }
786  if (!fileexists_core(filename, NULL, preflang, buf, buflen, file_fmt_cap) ||
788 
789  ast_log(LOG_WARNING, "File %s does not exist in any format\n", filename);
790  ao2_ref(file_fmt_cap, -1);
791  return NULL;
792  }
793 
794  /* Set the channel to a format we can work with and save off the previous format. */
795  ast_channel_lock(chan);
797  /* Set the channel to the best format that exists for the file. */
798  res = ast_set_write_format_from_cap(chan, file_fmt_cap);
799  ast_channel_unlock(chan);
800  /* don't need this anymore now that the channel's write format is set. */
801  ao2_ref(file_fmt_cap, -1);
802 
803  if (res == -1) { /* No format available that works with this channel */
804  return NULL;
805  }
806  res = filehelper(buf, chan, NULL, ACTION_OPEN);
807  if (res >= 0)
808  return ast_channel_stream(chan);
809  return NULL;
810 }
811 
812 struct ast_filestream *ast_openvstream(struct ast_channel *chan, const char *filename, const char *preflang)
813 {
814  /* As above, but for video. But here we don't have translators
815  * so we must enforce a format.
816  */
817  struct ast_format_cap *nativeformats, *tmp_cap;
818  char *buf;
819  int buflen;
820  int i, fd;
821 
822  if (preflang == NULL) {
823  preflang = "";
824  }
825  buflen = strlen(preflang) + strlen(filename) + 4;
826  buf = ast_alloca(buflen);
827 
828  ast_channel_lock(chan);
829  nativeformats = ao2_bump(ast_channel_nativeformats(chan));
830  ast_channel_unlock(chan);
831 
832  /* is the channel capable of video without translation ?*/
833  if (!ast_format_cap_has_type(nativeformats, AST_MEDIA_TYPE_VIDEO)) {
834  ao2_cleanup(nativeformats);
835  return NULL;
836  }
838  ao2_cleanup(nativeformats);
839  return NULL;
840  }
841  /* Video is supported, so see what video formats exist for this file */
842  if (!fileexists_core(filename, NULL, preflang, buf, buflen, tmp_cap)) {
843  ao2_ref(tmp_cap, -1);
844  ao2_cleanup(nativeformats);
845  return NULL;
846  }
847 
848  /* iterate over file formats and pick the first one compatible with the channel's native formats */
849  for (i = 0; i < ast_format_cap_count(tmp_cap); ++i) {
850  struct ast_format *format = ast_format_cap_get_format(tmp_cap, i);
851 
852  if ((ast_format_get_type(format) != AST_MEDIA_TYPE_VIDEO) ||
853  !ast_format_cap_iscompatible(nativeformats, tmp_cap)) {
854  ao2_ref(format, -1);
855  continue;
856  }
857 
858  fd = filehelper(buf, chan, ast_format_get_name(format), ACTION_OPEN);
859  if (fd >= 0) {
860  ao2_ref(format, -1);
861  ao2_ref(tmp_cap, -1);
862  ao2_cleanup(nativeformats);
863  return ast_channel_vstream(chan);
864  }
865  ast_log(LOG_WARNING, "File %s has video but couldn't be opened\n", filename);
866  ao2_ref(format, -1);
867  }
868  ao2_ref(tmp_cap, -1);
869  ao2_cleanup(nativeformats);
870 
871  return NULL;
872 }
873 
874 static struct ast_frame *read_frame(struct ast_filestream *s, int *whennext)
875 {
876  struct ast_frame *fr, *new_fr;
877 
878  if (!s || !s->fmt) {
879  return NULL;
880  }
881 
882  if (!(fr = s->fmt->read(s, whennext))) {
883  return NULL;
884  }
885 
886  if (!(new_fr = ast_frisolate(fr))) {
887  ast_frfree(fr);
888  return NULL;
889  }
890 
891  if (new_fr != fr) {
892  ast_frfree(fr);
893  fr = new_fr;
894  }
895 
896  return fr;
897 }
898 
900 {
901  int whennext = 0;
902 
903  return read_frame(s, &whennext);
904 }
905 
910 };
911 
912 static int ast_fsread_audio(const void *data);
913 
915 {
916  int whennext = 0;
917 
918  while (!whennext) {
919  struct ast_frame *fr;
920 
921  if (s->orig_chan_name && strcasecmp(ast_channel_name(s->owner), s->orig_chan_name)) {
922  goto return_failure;
923  }
924 
925  fr = read_frame(s, &whennext);
926 
927  if (!fr /* stream complete */ || ast_write(s->owner, fr) /* error writing */) {
928  if (fr) {
929  ast_debug(2, "Failed to write frame\n");
930  ast_frfree(fr);
931  }
932  goto return_failure;
933  }
934 
935  if (fr) {
936  ast_frfree(fr);
937  }
938  }
939 
940  if (whennext != s->lasttimeout) {
941  if (ast_channel_timingfd(s->owner) > -1) {
942  float samp_rate = (float) ast_format_get_sample_rate(s->fmt->format);
943  unsigned int rate;
944 
945  rate = (unsigned int) roundf(samp_rate / ((float) whennext));
946 
947  ast_settimeout_full(s->owner, rate, ast_fsread_audio, s, 1);
948  } else {
950  }
951  s->lasttimeout = whennext;
952  return FSREAD_SUCCESS_NOSCHED;
953  }
954  return FSREAD_SUCCESS_SCHED;
955 
956 return_failure:
958  ast_settimeout(s->owner, 0, NULL, NULL);
959  return FSREAD_FAILURE;
960 }
961 
962 static int ast_fsread_audio(const void *data)
963 {
964  struct ast_filestream *fs = (struct ast_filestream *)data;
965  enum fsread_res res;
966 
967  res = ast_readaudio_callback(fs);
968 
969  if (res == FSREAD_SUCCESS_SCHED)
970  return 1;
971 
972  return 0;
973 }
974 
975 static int ast_fsread_video(const void *data);
976 
978 {
979  int whennext = 0;
980 
981  while (!whennext) {
982  struct ast_frame *fr = read_frame(s, &whennext);
983 
984  if (!fr /* stream complete */ || ast_write(s->owner, fr) /* error writing */) {
985  if (fr) {
986  ast_debug(2, "Failed to write frame\n");
987  ast_frfree(fr);
988  }
990  return FSREAD_FAILURE;
991  }
992 
993  if (fr) {
994  ast_frfree(fr);
995  }
996  }
997 
998  if (whennext != s->lasttimeout) {
999  ast_channel_vstreamid_set(s->owner, ast_sched_add(ast_channel_sched(s->owner), whennext / (ast_format_get_sample_rate(s->fmt->format) / 1000), ast_fsread_video, s));
1000  s->lasttimeout = whennext;
1001  return FSREAD_SUCCESS_NOSCHED;
1002  }
1003 
1004  return FSREAD_SUCCESS_SCHED;
1005 }
1006 
1007 static int ast_fsread_video(const void *data)
1008 {
1009  struct ast_filestream *fs = (struct ast_filestream *)data;
1010  enum fsread_res res;
1011 
1012  res = ast_readvideo_callback(fs);
1013 
1014  if (res == FSREAD_SUCCESS_SCHED)
1015  return 1;
1016 
1017  return 0;
1018 }
1019 
1020 int ast_applystream(struct ast_channel *chan, struct ast_filestream *s)
1021 {
1022  s->owner = chan;
1023  return 0;
1024 }
1025 
1027 {
1028  enum fsread_res res;
1029 
1031  res = ast_readaudio_callback(s);
1032  else
1033  res = ast_readvideo_callback(s);
1034 
1035  return (res == FSREAD_FAILURE) ? -1 : 0;
1036 }
1037 
1038 int ast_seekstream(struct ast_filestream *fs, off_t sample_offset, int whence)
1039 {
1040  return fs->fmt->seek(fs, sample_offset, whence);
1041 }
1042 
1044 {
1045  return fs->fmt->trunc(fs);
1046 }
1047 
1049 {
1050  return fs->fmt->tell(fs);
1051 }
1052 
1054 {
1055  return ast_format_get_sample_rate(fs->fmt->format);
1056 }
1057 
1058 int ast_stream_fastforward(struct ast_filestream *fs, off_t ms)
1059 {
1060  return ast_seekstream(fs, ms * DEFAULT_SAMPLES_PER_MS, SEEK_CUR);
1061 }
1062 
1063 int ast_stream_rewind(struct ast_filestream *fs, off_t ms)
1064 {
1065  return ast_seekstream(fs, -ms * DEFAULT_SAMPLES_PER_MS, SEEK_CUR);
1066 }
1067 
1069 {
1070  /* This used to destroy the filestream, but it now just decrements a refcount.
1071  * We close the stream in order to quit queuing frames now, because we might
1072  * change the writeformat, which could result in a subsequent write error, if
1073  * the format is different. */
1074  if (f == NULL) {
1075  return 0;
1076  }
1077  filestream_close(f);
1078  ao2_ref(f, -1);
1079  return 0;
1080 }
1081 
1082 
1083 /*
1084  * Look the various language-specific places where a file could exist.
1085  */
1086 int ast_fileexists(const char *filename, const char *fmt, const char *preflang)
1087 {
1088  char *buf;
1089  int buflen;
1090 
1091  if (preflang == NULL)
1092  preflang = "";
1093  buflen = strlen(preflang) + strlen(filename) + 4; /* room for everything */
1094  buf = ast_alloca(buflen);
1095  return fileexists_core(filename, fmt, preflang, buf, buflen, NULL) ? 1 : 0;
1096 }
1097 
1098 int ast_filedelete(const char *filename, const char *fmt)
1099 {
1100  return filehelper(filename, NULL, fmt, ACTION_DELETE);
1101 }
1102 
1103 int ast_filerename(const char *filename, const char *filename2, const char *fmt)
1104 {
1105  return filehelper(filename, filename2, fmt, ACTION_RENAME);
1106 }
1107 
1108 int ast_filecopy(const char *filename, const char *filename2, const char *fmt)
1109 {
1110  return filehelper(filename, filename2, fmt, ACTION_COPY);
1111 }
1112 
1113 static int __ast_file_read_dirs(const char *path, ast_file_on_file on_file,
1114  void *obj, int max_depth)
1115 {
1116  DIR *dir;
1117  struct dirent *entry;
1118  int res;
1119 
1120  if (!(dir = opendir(path))) {
1121  ast_log(LOG_ERROR, "Error opening directory - %s: %s\n",
1122  path, strerror(errno));
1123  return -1;
1124  }
1125 
1126  --max_depth;
1127 
1128  res = 0;
1129 
1130  while ((entry = readdir(dir)) != NULL && !errno) {
1131  int is_file = 0;
1132  int is_dir = 0;
1133  RAII_VAR(char *, full_path, NULL, ast_free);
1134 
1135  if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
1136  continue;
1137  }
1138 
1139 /*
1140  * If the dirent structure has a d_type use it to determine if we are dealing with
1141  * a file or directory. Unfortunately if it doesn't have it, or if the type is
1142  * unknown, or a link then we'll need to use the stat function instead.
1143  */
1144 #ifdef _DIRENT_HAVE_D_TYPE
1145  if (entry->d_type != DT_UNKNOWN && entry->d_type != DT_LNK) {
1146  is_file = entry->d_type == DT_REG;
1147  is_dir = entry->d_type == DT_DIR;
1148  } else
1149 #endif
1150  {
1151  struct stat statbuf;
1152 
1153  /*
1154  * Don't use alloca or we risk blowing out the stack if recursing
1155  * into subdirectories.
1156  */
1157  full_path = ast_malloc(strlen(path) + strlen(entry->d_name) + 2);
1158  if (!full_path) {
1159  return -1;
1160  }
1161  sprintf(full_path, "%s/%s", path, entry->d_name);
1162 
1163  if (stat(full_path, &statbuf)) {
1164  ast_log(LOG_ERROR, "Error reading path stats - %s: %s\n",
1165  full_path, strerror(errno));
1166  /*
1167  * Output an error, but keep going. It could just be
1168  * a broken link and other files could be fine.
1169  */
1170  continue;
1171  }
1172 
1173  is_file = S_ISREG(statbuf.st_mode);
1174  is_dir = S_ISDIR(statbuf.st_mode);
1175  }
1176 
1177  if (is_file) {
1178  /* If the handler returns non-zero then stop */
1179  if ((res = on_file(path, entry->d_name, obj))) {
1180  break;
1181  }
1182  /* Otherwise move on to next item in directory */
1183  continue;
1184  }
1185 
1186  if (!is_dir) {
1187  ast_debug(5, "Skipping %s: not a regular file or directory\n", full_path);
1188  continue;
1189  }
1190 
1191  /* Only re-curse into sub-directories if not at the max depth */
1192  if (max_depth != 0) {
1193  if (!full_path) {
1194  /* Don't use alloca. See note above. */
1195  full_path = ast_malloc(strlen(path) + strlen(entry->d_name) + 2);
1196  if (!full_path) {
1197  return -1;
1198  }
1199  sprintf(full_path, "%s/%s", path, entry->d_name);
1200  }
1201 
1202  if ((res = __ast_file_read_dirs(full_path, on_file, obj, max_depth))) {
1203  break;
1204  }
1205  }
1206  }
1207 
1208  closedir(dir);
1209 
1210  if (!res && errno) {
1211  ast_log(LOG_ERROR, "Error while reading directories - %s: %s\n",
1212  path, strerror(errno));
1213  res = -1;
1214  }
1215 
1216  return res;
1217 }
1218 
1219 #if !defined(__GLIBC__)
1220 /*!
1221  * \brief Lock to hold when iterating over directories.
1222  *
1223  * Currently, 'readdir' is not required to be thread-safe. In most modern implementations
1224  * it should be safe to make concurrent calls into 'readdir' that specify different directory
1225  * streams (glibc would be one of these). However, since it is potentially unsafe for some
1226  * implementations we'll use our own locking in order to achieve synchronization for those.
1227  */
1229 #endif
1230 
1231 int ast_file_read_dirs(const char *dir_name, ast_file_on_file on_file, void *obj, int max_depth)
1232 {
1233  int res;
1234 
1235  errno = 0;
1236 
1237 #if !defined(__GLIBC__)
1239 #endif
1240 
1241  res = __ast_file_read_dirs(dir_name, on_file, obj, max_depth);
1242 
1243 #if !defined(__GLIBC__)
1245 #endif
1246 
1247  return res;
1248 }
1249 
1250 int ast_streamfile(struct ast_channel *chan, const char *filename, const char *preflang)
1251 {
1252  struct ast_filestream *fs;
1253  struct ast_filestream *vfs=NULL;
1254  off_t pos;
1255  int seekattempt;
1256  int res;
1257 
1258  fs = ast_openstream(chan, filename, preflang);
1259  if (!fs) {
1260  struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
1261  ast_channel_lock(chan);
1262  ast_log(LOG_WARNING, "Unable to open %s (format %s): %s\n",
1263  filename, ast_format_cap_get_names(ast_channel_nativeformats(chan), &codec_buf), strerror(errno));
1264  ast_channel_unlock(chan);
1265  return -1;
1266  }
1267 
1268  /* check to see if there is any data present (not a zero length file),
1269  * done this way because there is no where for ast_openstream_full to
1270  * return the file had no data. */
1271  pos = ftello(fs->f);
1272  seekattempt = fseeko(fs->f, -1, SEEK_END);
1273  if (seekattempt) {
1274  if (errno == EINVAL) {
1275  /* Zero-length file, as opposed to a pipe */
1276  return 0;
1277  } else {
1278  ast_seekstream(fs, 0, SEEK_SET);
1279  }
1280  } else {
1281  fseeko(fs->f, pos, SEEK_SET);
1282  }
1283 
1284  vfs = ast_openvstream(chan, filename, preflang);
1285  if (vfs) {
1286  ast_debug(1, "Ooh, found a video stream, too, format %s\n", ast_format_get_name(vfs->fmt->format));
1287  }
1288 
1291  if (ast_applystream(chan, fs))
1292  return -1;
1293  if (vfs && ast_applystream(chan, vfs))
1294  return -1;
1295  ast_test_suite_event_notify("PLAYBACK", "Message: %s\r\nChannel: %s", filename, ast_channel_name(chan));
1296  res = ast_playstream(fs);
1297  if (!res && vfs)
1298  res = ast_playstream(vfs);
1299 
1300  if (VERBOSITY_ATLEAST(3)) {
1301  ast_channel_lock(chan);
1302  ast_verb(3, "<%s> Playing '%s.%s' (language '%s')\n", ast_channel_name(chan), filename, ast_format_get_name(ast_channel_writeformat(chan)), preflang ? preflang : "default");
1303  ast_channel_unlock(chan);
1304  }
1305 
1306  return res;
1307 }
1308 
1309 struct ast_filestream *ast_readfile(const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
1310 {
1311  FILE *bfile;
1312  struct ast_format_def *f;
1313  struct ast_filestream *fs = NULL;
1314  char *fn;
1315  int format_found = 0;
1316 
1318 
1319  AST_RWLIST_TRAVERSE(&formats, f, list) {
1320  fs = NULL;
1321  if (!exts_compare(f->exts, type))
1322  continue;
1323  else
1324  format_found = 1;
1325 
1326  fn = build_filename(filename, type);
1327  if (!fn) {
1328  continue;
1329  }
1330  errno = 0;
1331  bfile = fopen(fn, "r");
1332 
1333  if (!bfile || (fs = get_filestream(f, bfile)) == NULL || open_wrapper(fs) ) {
1334  ast_log(LOG_WARNING, "Unable to open %s\n", fn);
1335  if (fs) {
1336  ast_closestream(fs);
1337  }
1338  fs = NULL;
1339  bfile = NULL;
1340  ast_free(fn);
1341  break;
1342  }
1343  /* found it */
1344  fs->trans = NULL;
1345  fs->fmt = f;
1346  fs->flags = flags;
1347  fs->mode = mode;
1348  fs->filename = ast_strdup(filename);
1349  fs->vfs = NULL;
1350  ast_free(fn);
1351  break;
1352  }
1353 
1355  if (!format_found)
1356  ast_log(LOG_WARNING, "No such format '%s'\n", type);
1357 
1358  return fs;
1359 }
1360 
1361 struct ast_filestream *ast_writefile(const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
1362 {
1363  int fd, myflags = 0;
1364  /* compiler claims this variable can be used before initialization... */
1365  FILE *bfile = NULL;
1366  struct ast_format_def *f;
1367  struct ast_filestream *fs = NULL;
1368  char *buf = NULL;
1369  size_t size = 0;
1370  int format_found = 0;
1371 
1373 
1374  /* set the O_TRUNC flag if and only if there is no O_APPEND specified */
1375  /* We really can't use O_APPEND as it will break WAV header updates */
1376  if (flags & O_APPEND) {
1377  flags &= ~O_APPEND;
1378  } else {
1379  myflags = O_TRUNC;
1380  }
1381 
1382  myflags |= O_WRONLY | O_CREAT;
1383 
1384  /* XXX need to fix this - we should just do the fopen,
1385  * not open followed by fdopen()
1386  */
1387  AST_RWLIST_TRAVERSE(&formats, f, list) {
1388  char *fn, *orig_fn = NULL;
1389  if (fs)
1390  break;
1391 
1392  if (!exts_compare(f->exts, type))
1393  continue;
1394  else
1395  format_found = 1;
1396 
1397  fn = build_filename(filename, type);
1398  if (!fn) {
1399  continue;
1400  }
1401  fd = open(fn, flags | myflags, mode);
1402  if (fd > -1) {
1403  /* fdopen() the resulting file stream */
1404  bfile = fdopen(fd, ((flags | myflags) & O_RDWR) ? "w+" : "w");
1405  if (!bfile) {
1406  ast_log(LOG_WARNING, "Whoa, fdopen failed: %s!\n", strerror(errno));
1407  close(fd);
1408  fd = -1;
1409  }
1410  }
1411 
1412  if (ast_opt_cache_record_files && (fd > -1)) {
1413  char *c;
1414 
1415  fclose(bfile); /* this also closes fd */
1416  /*
1417  We touch orig_fn just as a place-holder so other things (like vmail) see the file is there.
1418  What we are really doing is writing to record_cache_dir until we are done then we will mv the file into place.
1419  */
1420  orig_fn = ast_strdup(fn);
1421  for (c = fn; *c; c++)
1422  if (*c == '/')
1423  *c = '_';
1424 
1425  size = strlen(fn) + strlen(record_cache_dir) + 2;
1426  buf = ast_malloc(size);
1427  strcpy(buf, record_cache_dir);
1428  strcat(buf, "/");
1429  strcat(buf, fn);
1430  ast_free(fn);
1431  fn = buf;
1432  fd = open(fn, flags | myflags, mode);
1433  if (fd > -1) {
1434  /* fdopen() the resulting file stream */
1435  bfile = fdopen(fd, ((flags | myflags) & O_RDWR) ? "w+" : "w");
1436  if (!bfile) {
1437  ast_log(LOG_WARNING, "Whoa, fdopen failed: %s!\n", strerror(errno));
1438  close(fd);
1439  fd = -1;
1440  }
1441  }
1442  }
1443  if (fd > -1) {
1444  errno = 0;
1445  fs = get_filestream(f, bfile);
1446  if (fs) {
1447  if ((fs->write_buffer = ast_malloc(32768))) {
1448  setvbuf(fs->f, fs->write_buffer, _IOFBF, 32768);
1449  }
1450  }
1451  if (!fs || rewrite_wrapper(fs, comment)) {
1452  ast_log(LOG_WARNING, "Unable to rewrite %s\n", fn);
1453  close(fd);
1454  if (orig_fn) {
1455  unlink(fn);
1456  unlink(orig_fn);
1457  ast_free(orig_fn);
1458  }
1459  if (fs) {
1460  ast_closestream(fs);
1461  fs = NULL;
1462  }
1463  /*
1464  * 'fn' was has either been allocated from build_filename, or that was freed
1465  * and now 'fn' points to memory allocated for 'buf'. Either way the memory
1466  * now needs to be released.
1467  */
1468  ast_free(fn);
1469  continue;
1470  }
1471  fs->trans = NULL;
1472  fs->fmt = f;
1473  fs->flags = flags;
1474  fs->mode = mode;
1475  if (orig_fn) {
1476  fs->realfilename = orig_fn;
1477  fs->filename = fn;
1478  /*
1479  * The above now manages the memory allocated for 'orig_fn' and 'fn', so
1480  * set them to NULL, so they don't get released at the end of the loop.
1481  */
1482  orig_fn = NULL;
1483  fn = NULL;
1484  } else {
1485  fs->realfilename = NULL;
1486  fs->filename = ast_strdup(filename);
1487  }
1488  fs->vfs = NULL;
1489  /* If truncated, we'll be at the beginning; if not truncated, then append */
1490  f->seek(fs, 0, SEEK_END);
1491  } else if (errno != EEXIST) {
1492  ast_log(LOG_WARNING, "Unable to open file %s: %s\n", fn, strerror(errno));
1493  if (orig_fn)
1494  unlink(orig_fn);
1495  }
1496  /* Free 'fn', or if 'fn' points to 'buf' then free 'buf' */
1497  ast_free(fn);
1498  ast_free(orig_fn);
1499  }
1500 
1502 
1503  if (!format_found)
1504  ast_log(LOG_WARNING, "No such format '%s'\n", type);
1505 
1506  return fs;
1507 }
1508 
1509 static void waitstream_control(struct ast_channel *c,
1510  enum ast_waitstream_fr_cb_values type,
1512  int skip_ms)
1513 {
1514  switch (type)
1515  {
1517  {
1518  int eoftest;
1520  eoftest = fgetc(ast_channel_stream(c)->f);
1521  if (feof(ast_channel_stream(c)->f)) {
1523  } else {
1524  ungetc(eoftest, ast_channel_stream(c)->f);
1525  }
1526  }
1527  break;
1530  break;
1531  default:
1532  break;
1533  }
1534 
1535  if (cb) {
1537  cb(c, ms_len, type);
1538  }
1539 
1540  ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
1541  "Control: %s\r\n"
1542  "SkipMs: %d\r\n",
1543  ast_channel_name(c),
1544  (type == AST_WAITSTREAM_CB_FASTFORWARD) ? "FastForward" : "Rewind",
1545  skip_ms);
1546 }
1547 
1548 /*!
1549  * \brief the core of all waitstream() functions
1550  */
1551 static int waitstream_core(struct ast_channel *c,
1552  const char *breakon,
1553  const char *forward,
1554  const char *reverse,
1555  int skip_ms,
1556  int audiofd,
1557  int cmdfd,
1558  const char *context,
1560 {
1561  const char *orig_chan_name = NULL;
1562 
1563  int err = 0;
1564 
1565  if (!breakon)
1566  breakon = "";
1567  if (!forward)
1568  forward = "";
1569  if (!reverse)
1570  reverse = "";
1571 
1572  /* Switch the channel to end DTMF frame only. waitstream_core doesn't care about the start of DTMF. */
1574 
1576  orig_chan_name = ast_strdupa(ast_channel_name(c));
1577 
1578  if (ast_channel_stream(c) && cb) {
1580  cb(c, ms_len, AST_WAITSTREAM_CB_START);
1581  }
1582 
1583  while (ast_channel_stream(c)) {
1584  int res;
1585  int ms;
1586 
1587  if (orig_chan_name && strcasecmp(orig_chan_name, ast_channel_name(c))) {
1588  ast_stopstream(c);
1589  err = 1;
1590  break;
1591  }
1592 
1594 
1595  if (ms < 0 && !ast_channel_timingfunc(c)) {
1596  ast_stopstream(c);
1597  break;
1598  }
1599  if (ms < 0)
1600  ms = 1000;
1601  if (cmdfd < 0) {
1602  res = ast_waitfor(c, ms);
1603  if (res < 0) {
1604  ast_log(LOG_WARNING, "Select failed (%s)\n", strerror(errno));
1606  return res;
1607  }
1608  } else {
1609  int outfd;
1610  struct ast_channel *rchan = ast_waitfor_nandfds(&c, 1, &cmdfd, (cmdfd > -1) ? 1 : 0, NULL, &outfd, &ms);
1611  if (!rchan && (outfd < 0) && (ms)) {
1612  /* Continue */
1613  if (errno == EINTR)
1614  continue;
1615  ast_log(LOG_WARNING, "Wait failed (%s)\n", strerror(errno));
1617  return -1;
1618  } else if (outfd > -1) { /* this requires cmdfd set */
1619  /* The FD we were watching has something waiting */
1621  return 1;
1622  }
1623  /* if rchan is set, it is 'c' */
1624  res = rchan ? 1 : 0; /* map into 'res' values */
1625  }
1626  if (res > 0) {
1627  struct ast_frame *fr = ast_read(c);
1628  if (!fr) {
1630  return -1;
1631  }
1632  switch (fr->frametype) {
1633  case AST_FRAME_DTMF_END:
1634  if (context) {
1635  const char exten[2] = { fr->subclass.integer, '\0' };
1636  if (ast_exists_extension(c, context, exten, 1,
1637  S_COR(ast_channel_caller(c)->id.number.valid, ast_channel_caller(c)->id.number.str, NULL))) {
1638  res = fr->subclass.integer;
1639  ast_frfree(fr);
1641  return res;
1642  }
1643  } else {
1644  res = fr->subclass.integer;
1645  if (strchr(forward, res)) {
1647  } else if (strchr(reverse, res)) {
1649  } else if (strchr(breakon, res)) {
1650  ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
1651  "Control: %s\r\n",
1652  ast_channel_name(c),
1653  "Break");
1654 
1655  ast_frfree(fr);
1657  return res;
1658  }
1659  }
1660  break;
1661  case AST_FRAME_CONTROL:
1662  switch (fr->subclass.integer) {
1666  /* Fall-through and break out */
1667  ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
1668  "Control: %s\r\n",
1669  ast_channel_name(c),
1670  "Break");
1671  res = fr->subclass.integer;
1672  ast_frfree(fr);
1674  return res;
1676  if (!skip_ms) {
1677  skip_ms = 3000;
1678  }
1680  break;
1682  if (!skip_ms) {
1683  skip_ms = 3000;
1684  }
1686  break;
1687  case AST_CONTROL_HANGUP:
1688  case AST_CONTROL_BUSY:
1690  ast_frfree(fr);
1692  return -1;
1693  case AST_CONTROL_RINGING:
1694  case AST_CONTROL_ANSWER:
1695  case AST_CONTROL_VIDUPDATE:
1696  case AST_CONTROL_SRCUPDATE:
1697  case AST_CONTROL_SRCCHANGE:
1698  case AST_CONTROL_HOLD:
1699  case AST_CONTROL_UNHOLD:
1702  case AST_CONTROL_AOC:
1705  case -1:
1706  /* Unimportant */
1707  break;
1708  default:
1709  ast_log(LOG_WARNING, "Unexpected control subclass '%d'\n", fr->subclass.integer);
1710  }
1711  break;
1712  case AST_FRAME_VOICE:
1713  /* Write audio if appropriate */
1714  if (audiofd > -1) {
1715  if (write(audiofd, fr->data.ptr, fr->datalen) < 0) {
1716  ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
1717  }
1718  }
1719  default:
1720  /* Ignore all others */
1721  break;
1722  }
1723  ast_frfree(fr);
1724  }
1726  }
1727 
1729 
1730  return (err || ast_channel_softhangup_internal_flag(c)) ? -1 : 0;
1731 }
1732 
1734  const char *breakon,
1735  const char *forward,
1736  const char *reverse,
1737  int ms,
1739 {
1740  return waitstream_core(c, breakon, forward, reverse, ms,
1741  -1 /* no audiofd */, -1 /* no cmdfd */, NULL /* no context */, cb);
1742 }
1743 
1744 int ast_waitstream_fr(struct ast_channel *c, const char *breakon, const char *forward, const char *reverse, int ms)
1745 {
1746  return waitstream_core(c, breakon, forward, reverse, ms,
1747  -1 /* no audiofd */, -1 /* no cmdfd */, NULL /* no context */, NULL /* no callback */);
1748 }
1749 
1750 /*! \internal
1751  * \brief Clean up the return value of a waitstream call
1752  *
1753  * It's possible for a control frame to come in from an external source and break the
1754  * playback. From a consumer of most ast_waitstream_* function callers, this should
1755  * appear like normal playback termination, i.e., return 0 and not the value of the
1756  * control frame.
1757  */
1758 static int sanitize_waitstream_return(int return_value)
1759 {
1760  switch (return_value) {
1764  /* Fall through and set return_value to 0 */
1765  return_value = 0;
1766  break;
1767  default:
1768  /* Do nothing */
1769  break;
1770  }
1771 
1772  return return_value;
1773 }
1774 
1775 int ast_waitstream(struct ast_channel *c, const char *breakon)
1776 {
1777  int res;
1778 
1779  res = waitstream_core(c, breakon, NULL, NULL, 0, -1, -1, NULL, NULL /* no callback */);
1780 
1781  return sanitize_waitstream_return(res);
1782 }
1783 
1784 int ast_waitstream_full(struct ast_channel *c, const char *breakon, int audiofd, int cmdfd)
1785 {
1786  int res;
1787 
1788  res = waitstream_core(c, breakon, NULL, NULL, 0,
1789  audiofd, cmdfd, NULL /* no context */, NULL /* no callback */);
1790 
1791  return sanitize_waitstream_return(res);
1792 }
1793 
1794 int ast_waitstream_exten(struct ast_channel *c, const char *context)
1795 {
1796  int res;
1797 
1798  /* Waitstream, with return in the case of a valid 1 digit extension */
1799  /* in the current or specified context being pressed */
1800  if (!context)
1801  context = ast_channel_context(c);
1802  res = waitstream_core(c, NULL, NULL, NULL, 0,
1803  -1, -1, context, NULL /* no callback */);
1804 
1805  return sanitize_waitstream_return(res);
1806 }
1807 
1808 /*
1809  * if the file name is non-empty, try to play it.
1810  * Return 0 if success, -1 if error, digit if interrupted by a digit.
1811  * If digits == "" then we can simply check for non-zero.
1812  */
1813 int ast_stream_and_wait(struct ast_channel *chan, const char *file, const char *digits)
1814 {
1815  int res = 0;
1816  if (!ast_strlen_zero(file)) {
1817  res = ast_streamfile(chan, file, ast_channel_language(chan));
1818  if (!res) {
1819  res = ast_waitstream(chan, digits);
1820  }
1821  }
1822  return res;
1823 }
1824 
1825 char *ast_format_str_reduce(char *fmts)
1826 {
1827  struct ast_format_def *f;
1828  struct ast_format_def *fmts_ptr[AST_MAX_FORMATS];
1829  char *fmts_str[AST_MAX_FORMATS];
1830  char *stringp, *type;
1831  char *orig = fmts;
1832  int i, j, x, first, found = 0;
1833  int len = strlen(fmts) + 1;
1834  int res;
1835 
1836  if (AST_RWLIST_RDLOCK(&formats)) {
1837  ast_log(LOG_WARNING, "Unable to lock format list\n");
1838  return NULL;
1839  }
1840 
1841  stringp = ast_strdupa(fmts);
1842 
1843  for (x = 0; (type = strsep(&stringp, "|")) && x < AST_MAX_FORMATS; x++) {
1844  AST_RWLIST_TRAVERSE(&formats, f, list) {
1845  if (exts_compare(f->exts, type)) {
1846  found = 1;
1847  break;
1848  }
1849  }
1850 
1851  fmts_str[x] = type;
1852  if (found) {
1853  fmts_ptr[x] = f;
1854  } else {
1855  fmts_ptr[x] = NULL;
1856  }
1857  }
1859 
1860  first = 1;
1861  for (i = 0; i < x; i++) {
1862  /* ignore invalid entries */
1863  if (!fmts_ptr[i]) {
1864  ast_log(LOG_WARNING, "ignoring unknown format '%s'\n", fmts_str[i]);
1865  continue;
1866  }
1867 
1868  /* special handling for the first entry */
1869  if (first) {
1870  res = snprintf(fmts, len, "%s", fmts_str[i]);
1871  fmts += res;
1872  len -= res;
1873  first = 0;
1874  continue;
1875  }
1876 
1877  found = 0;
1878  for (j = 0; j < i; j++) {
1879  /* this is a duplicate */
1880  if (fmts_ptr[j] == fmts_ptr[i]) {
1881  found = 1;
1882  break;
1883  }
1884  }
1885 
1886  if (!found) {
1887  res = snprintf(fmts, len, "|%s", fmts_str[i]);
1888  fmts += res;
1889  len -= res;
1890  }
1891  }
1892 
1893  if (first) {
1894  ast_log(LOG_WARNING, "no known formats found in format list (%s)\n", orig);
1895  return NULL;
1896  }
1897 
1898  return orig;
1899 }
1900 
1901 static char *handle_cli_core_show_file_formats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1902 {
1903 #define FORMAT "%-10s %-10s %-20s\n"
1904 #define FORMAT2 "%-10s %-10s %-20s\n"
1905  struct ast_format_def *f;
1906  int count_fmt = 0;
1907 
1908  switch (cmd) {
1909  case CLI_INIT:
1910  e->command = "core show file formats";
1911  e->usage =
1912  "Usage: core show file formats\n"
1913  " Displays currently registered file formats (if any).\n";
1914  return NULL;
1915  case CLI_GENERATE:
1916  return NULL;
1917  }
1918 
1919  if (a->argc != 4)
1920  return CLI_SHOWUSAGE;
1921 
1922  ast_cli(a->fd, FORMAT, "Format", "Name", "Extensions");
1923  ast_cli(a->fd, FORMAT, "------", "----", "----------");
1924 
1926  AST_RWLIST_TRAVERSE(&formats, f, list) {
1927  ast_cli(a->fd, FORMAT2, ast_format_get_name(f->format), f->name, f->exts);
1928  count_fmt++;
1929  }
1931  ast_cli(a->fd, "%d file formats registered.\n", count_fmt);
1932  return CLI_SUCCESS;
1933 #undef FORMAT
1934 #undef FORMAT2
1935 }
1936 
1937 struct ast_format *ast_get_format_for_file_ext(const char *file_ext)
1938 {
1939  struct ast_format_def *f;
1941  AST_RWLIST_TRAVERSE(&formats, f, list) {
1942  if (exts_compare(f->exts, file_ext)) {
1943  return f->format;
1944  }
1945  }
1946 
1947  return NULL;
1948 }
1949 
1950 int ast_get_extension_for_mime_type(const char *mime_type, char *buffer, size_t capacity)
1951 {
1952  struct ast_format_def *f;
1954 
1955  ast_assert(buffer && capacity);
1956 
1957  AST_RWLIST_TRAVERSE(&formats, f, list) {
1958  if (type_in_list(f->mime_types, mime_type, strcasecmp)) {
1959  size_t item_len = strcspn(f->exts, "|");
1960  size_t bytes_written = snprintf(buffer, capacity, ".%.*s", (int) item_len, f->exts);
1961  if (bytes_written < capacity) {
1962  /* Only return success if we didn't truncate */
1963  return 1;
1964  }
1965  }
1966  }
1967 
1968  return 0;
1969 }
1970 
1971 static struct ast_cli_entry cli_file[] = {
1972  AST_CLI_DEFINE(handle_cli_core_show_file_formats, "Displays file formats")
1973 };
1974 
1975 static void file_shutdown(void)
1976 {
1977  ast_cli_unregister_multiple(cli_file, ARRAY_LEN(cli_file));
1980 }
1981 
1982 int ast_file_init(void)
1983 {
1986  ast_cli_register_multiple(cli_file, ARRAY_LEN(cli_file));
1988  return 0;
1989 }
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
char exts[80]
Definition: mod_format.h:45
static enum fsread_res ast_readvideo_callback(struct ast_filestream *s)
Definition: file.c:977
static const char type[]
Definition: chan_ooh323.c:109
int ast_channel_vstreamid(const struct ast_channel *chan)
#define ast_channel_lock(chan)
Definition: channel.h:2890
static char exten[AST_MAX_EXTENSION]
Definition: chan_alsa.c:118
Main Channel structure associated with a channel.
#define AST_CLI_DEFINE(fn, txt,...)
Definition: cli.h:197
struct ast_json * ast_json_ref(struct ast_json *value)
Increase refcount on value.
Definition: json.c:67
enum ast_media_type ast_format_get_type(const struct ast_format *format)
Get the media type of a format.
Definition: format.c:354
Asterisk locking-related definitions:
Asterisk main include file. File version handling, generic pbx functions.
int ast_seekstream(struct ast_filestream *fs, off_t sample_offset, int whence)
Seeks into stream.
Definition: file.c:1038
#define ARRAY_LEN(a)
Definition: isdn_lib.c:42
struct ast_filestream * ast_channel_vstream(const struct ast_channel *chan)
struct ast_json * ast_json_pack(char const *format,...)
Helper for creating complex JSON values.
Definition: json.c:591
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, ast_waitstream_fr_cb cb)
the core of all waitstream() functions
Definition: file.c:1551
int ast_waitstream_full(struct ast_channel *c, const char *breakon, int audiofd, int cmdfd)
Definition: file.c:1784
#define AST_RWLIST_HEAD_STATIC(name, type)
Defines a structure to be used to hold a read/write list of specified type, statically initialized...
Definition: linkedlists.h:332
int ast_sched_runq(struct ast_sched_context *con)
Runs the queue.
Definition: sched.c:755
void ast_channel_set_oldwriteformat(struct ast_channel *chan, struct ast_format *format)
int ast_cli_unregister_multiple(struct ast_cli_entry *e, int len)
Unregister multiple commands.
Definition: clicompat.c:30
int ast_filecopy(const char *filename, const char *filename2, const char *fmt)
Copies a file.
Definition: file.c:1108
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.
Definition: file.c:1794
struct ast_json_payload * ast_json_payload_create(struct ast_json *json)
Create an ao2 object to pass json blobs as data payloads for stasis.
Definition: json.c:735
#define ast_test_flag(p, flag)
Definition: utils.h:63
Support for translation of data formats. translate.c.
static struct ast_cli_entry cli_file[]
Definition: file.c:1971
#define exts_compare(list, type)
Definition: file.c:351
void(* close)(struct ast_filestream *)
Definition: mod_format.h:77
void ast_json_unref(struct ast_json *value)
Decrease refcount on value. If refcount reaches zero, value is freed.
Definition: json.c:73
char buf[BUFSIZE]
Definition: eagi_proxy.c:66
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition: stasis.h:1501
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition: linkedlists.h:51
static void filestream_close(struct ast_filestream *f)
Definition: file.c:357
Stasis Message Bus API. See Stasis Message Bus API for detailed documentation.
descriptor for a cli entry.
Definition: cli.h:171
const int argc
Definition: cli.h:160
#define LOG_WARNING
Definition: logger.h:274
#define AST_FORMAT_CAP_NAMES_LEN
Definition: format_cap.h:326
union ast_frame::@257 data
#define VERBOSITY_ATLEAST(level)
Definition: logger.h:453
static int tmp()
Definition: bt_open.c:389
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
Definition: linkedlists.h:150
struct ast_format * ast_channel_oldwriteformat(struct ast_channel *chan)
int ast_settimeout_full(struct ast_channel *c, unsigned int rate, int(*func)(const void *data), void *data, unsigned int is_ao2_obj)
Definition: channel.c:3180
#define AST_LOG_WARNING
Definition: logger.h:279
int ast_stream_rewind(struct ast_filestream *fs, off_t ms)
Rewind stream ms.
Definition: file.c:1063
static struct ast_filestream * get_filestream(struct ast_format_def *fmt, FILE *bfile)
Definition: file.c:428
void ast_channel_vstream_set(struct ast_channel *chan, struct ast_filestream *value)
void ast_channel_clear_flag(struct ast_channel *chan, unsigned int flag)
Definition: channel.c:11089
#define AST_LIST_NEXT(elm, field)
Returns the next entry in the list after the given entry.
Definition: linkedlists.h:438
static int rewrite_wrapper(struct ast_filestream *s, const char *comment)
Definition: file.c:485
Test Framework API.
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
Definition: channel.c:4271
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition: stasis.h:1523
Definition: cli.h:152
if(!yyg->yy_init)
Definition: ast_expr2f.c:868
static int fileexists_core(const char *filename, const char *fmt, const char *preflang, char *buf, int buflen, struct ast_format_cap *result_cap)
helper routine to locate a file with a given format and language preference.
Definition: file.c:706
Definition of a media format.
Definition: format.c:43
ast_waitstream_fr_cb_values
Definition: file.h:54
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition: cli.h:265
static char * handle_cli_core_show_file_formats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition: file.c:1901
static struct aco_type item
Definition: test_config.c:1463
int ast_filedelete(const char *filename, const char *fmt)
Deletes a file.
Definition: file.c:1098
static ast_mutex_t read_dirs_lock
Lock to hold when iterating over directories.
Definition: file.c:1228
size_t ast_format_cap_count(const struct ast_format_cap *cap)
Get the number of formats present within the capabilities structure.
Definition: format_cap.c:395
char * realfilename
Definition: mod_format.h:108
#define ast_assert(a)
Definition: utils.h:650
#define ast_mutex_lock(a)
Definition: lock.h:187
struct ast_frame * ast_translate(struct ast_trans_pvt *tr, struct ast_frame *f, int consume)
translates one or more frames Apply an input frame into the translator and receive zero or one output...
Definition: translate.c:559
static struct test_val c
#define ast_str_alloca(init_len)
Definition: strings.h:800
const char * ast_format_get_name(const struct ast_format *format)
Get the name associated with a format.
Definition: format.c:334
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:243
int ast_closestream(struct ast_filestream *f)
Closes a stream.
Definition: file.c:1068
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.
Definition: file.c:1744
int ast_playstream(struct ast_filestream *s)
Play a open stream on a channel.
Definition: file.c:1026
#define NULL
Definition: resample.c:96
ast_rwlock_t lock
Definition: file.c:69
Each supported file format is described by the following structure.
Definition: mod_format.h:43
char * end
Definition: eagi_proxy.c:73
void ast_cli(int fd, const char *fmt,...)
Definition: clicompat.c:6
static void file_shutdown(void)
Definition: file.c:1975
const char * ext
Definition: http.c:147
#define AST_FILE_MODE
Definition: asterisk.h:32
struct ast_channel * ast_waitfor_nandfds(struct ast_channel **chan, int n, int *fds, int nfds, int *exception, int *outfd, int *ms)
Waits for activity on a group of channels.
Definition: channel.c:2983
#define ast_verb(level,...)
Definition: logger.h:455
int(* seek)(struct ast_filestream *, off_t, int)
Definition: mod_format.h:68
static int ast_fsread_video(const void *data)
Definition: file.c:1007
struct ast_frame_subclass subclass
Header for providers of file and format handling routines. Clients of these routines should include "...
static int open_wrapper(struct ast_filestream *s)
Definition: file.c:490
Utility functions.
#define ast_asprintf(ret, fmt,...)
A wrapper for asprintf()
Definition: astmm.h:269
#define ast_module_unref(mod)
Release a reference to the module.
Definition: module.h:469
void ast_channel_stream_set(struct ast_channel *chan, struct ast_filestream *value)
char * write_buffer
Definition: mod_format.h:126
int(* open)(struct ast_filestream *s)
Prepare an input stream for playback.
Definition: mod_format.h:56
Number structure.
Definition: app_followme.c:154
struct ast_filestream * ast_openstream(struct ast_channel *chan, const char *filename, const char *preflang)
Opens stream for use in seeking, playing.
Definition: file.c:755
int ast_filerename(const char *filename, const char *filename2, const char *fmt)
Renames a file.
Definition: file.c:1103
#define ao2_bump(obj)
Definition: astobj2.h:491
#define SCOPED_RDLOCK(varname, lock)
scoped lock specialization for read locks
Definition: lock.h:592
struct ast_module * module
Definition: mod_format.h:93
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition: linkedlists.h:77
#define AST_RWLIST_INSERT_HEAD
Definition: linkedlists.h:717
int ast_writestream(struct ast_filestream *fs, struct ast_frame *f)
Writes a frame to a stream.
Definition: file.c:209
struct ast_filestream * ast_openstream_full(struct ast_channel *chan, const char *filename, const char *preflang, int asis)
Opens stream for use in seeking, playing.
Definition: file.c:760
struct ast_filestream * ast_writefile(const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
Starts writing a file.
Definition: file.c:1361
int ast_waitstream(struct ast_channel *c, const char *breakon)
Waits for a stream to stop or digit to be pressed.
Definition: file.c:1775
#define ast_debug(level,...)
Log a DEBUG message.
Definition: logger.h:444
int ast_set_write_format_from_cap(struct ast_channel *chan, struct ast_format_cap *formats)
Sets write format on channel chan Set write format for channel to whichever component of "format" is ...
Definition: channel.c:5807
#define ast_log
Definition: astobj2.c:42
int ast_fileexists(const char *filename, const char *fmt, const char *preflang)
Checks for the existence of a given file.
Definition: file.c:1086
off_t ast_tellstream(struct ast_filestream *fs)
Tell where we are in a stream.
Definition: file.c:1048
static char * build_filename(const char *filename, const char *ext)
construct a filename. Absolute pathnames are preserved, relative names are prefixed by the sounds/ di...
Definition: file.c:314
#define SENTINEL
Definition: compiler.h:87
static int fn_wrapper(struct ast_filestream *s, const char *comment, enum wrap_fn mode)
Definition: file.c:468
static int is_absolute_path(const char *filename)
Definition: file.c:640
enum ast_format_cmp_res ast_format_cmp(const struct ast_format *format1, const struct ast_format *format2)
Compare two formats.
Definition: format.c:201
struct ast_trans_pvt * ast_translator_build_path(struct ast_format *dest, struct ast_format *source)
Builds a translator path Build a path (possibly NULL) from source to dest.
Definition: translate.c:479
General Asterisk PBX channel definitions.
struct ast_filestream * ast_readfile(const char *filename, const char *type, const char *comment, int flags, int check, mode_t mode)
Starts reading from a file.
Definition: file.c:1309
Asterisk JSON abstraction layer.
int ast_register_cleanup(void(*func)(void))
Register a function to be executed before Asterisk gracefully exits.
Definition: clicompat.c:19
Asterisk file paths, configured in asterisk.conf.
const char * src
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:851
struct ast_json * ast_json_string_create(const char *value)
Construct a JSON string from value.
Definition: json.c:268
wrap_fn
Definition: file.c:466
const int fd
Definition: cli.h:159
char * ast_format_str_reduce(char *fmts)
Definition: file.c:1825
int ast_file_read_dirs(const char *dir_name, ast_file_on_file on_file, void *obj, int max_depth)
Recursively iterate through files and directories up to max_depth.
Definition: file.c:1231
ast_mutex_t lock
Definition: app_meetme.c:1091
#define AST_RWLIST_TRAVERSE
Definition: linkedlists.h:493
int ast_settimeout(struct ast_channel *c, unsigned int rate, int(*func)(const void *data), void *data)
Enable or disable timer ticks for a channel.
Definition: channel.c:3175
Scheduler Routines (derived from cheops)
struct ast_format_def * fmt
Definition: mod_format.h:103
#define ao2_ref(o, delta)
Definition: astobj2.h:464
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:85
const char * orig_chan_name
Definition: mod_format.h:125
int ast_ratestream(struct ast_filestream *fs)
Return the sample rate of the stream&#39;s format.
Definition: file.c:1053
struct stasis_message_type * ast_format_unregister_type(void)
Get the message type used for signaling a format unregistration.
struct ast_frame fr
frame produced by read, typically
Definition: mod_format.h:122
#define AST_RWLIST_REMOVE_CURRENT
Definition: linkedlists.h:569
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:300
#define ast_format_cap_append(cap, format, framing)
Definition: format_cap.h:103
A set of macros to manage forward-linked lists.
#define ast_malloc(len)
A wrapper for malloc()
Definition: astmm.h:193
int ast_set_write_format(struct ast_channel *chan, struct ast_format *format)
Sets write format on channel chan.
Definition: channel.c:5789
#define AST_SCHED_DEL_ACCESSOR(sched, obj, getter, setter)
Definition: sched.h:59
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
Definition: pbx.c:4179
#define ast_format_cap_alloc(flags)
Definition: format_cap.h:52
struct ast_format * format
Definition: mod_format.h:48
int ast_get_extension_for_mime_type(const char *mime_type, char *buffer, size_t capacity)
Get a suitable filename extension for the given MIME type.
Definition: file.c:1950
Core PBX routines and definitions.
struct ast_json * ast_json_array_create(void)
Create a empty JSON array.
Definition: json.c:352
#define AST_RWLIST_TRAVERSE_SAFE_BEGIN
Definition: linkedlists.h:544
int ast_json_array_append(struct ast_json *array, struct ast_json *value)
Append to an array.
Definition: json.c:368
int ast_applystream(struct ast_channel *chan, struct ast_filestream *s)
Applys a open stream to a channel.
Definition: file.c:1020
#define ast_test_suite_event_notify(s, f,...)
Definition: test.h:196
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:290
int ast_file_init(void)
Definition: file.c:1982
int ast_channel_timingfd(const struct ast_channel *chan)
void * _private
Definition: mod_format.h:124
const char * ast_config_AST_DATA_DIR
Definition: options.c:155
int(* ast_file_on_file)(const char *dir_name, const char *filename, void *obj)
Callback called for each file found when reading directories.
Definition: file.h:152
struct ast_filestream * ast_openvstream(struct ast_channel *chan, const char *filename, const char *preflang)
Opens stream for use in seeking, playing.
Definition: file.c:812
struct ast_sched_context * ast_channel_sched(const struct ast_channel *chan)
#define LOG_ERROR
Definition: logger.h:285
struct ast_generator * ast_channel_generator(const struct ast_channel *chan)
static int filehelper(const char *filename, const void *arg2, const char *fmt, const enum file_action action)
Definition: file.c:514
The descriptor of a dynamic string XXX storage will be optimized later if needed We use the ts field ...
Definition: strings.h:584
Format capabilities structure, holds formats + preference order + etc.
Definition: format_cap.c:54
int ast_stopstream(struct ast_channel *tmp)
Stops a stream.
Definition: file.c:187
int(* rewrite)(struct ast_filestream *s, const char *comment)
Prepare a stream for output, and comment it appropriately if applicable.
Definition: mod_format.h:64
void() ast_waitstream_fr_cb(struct ast_channel *chan, long ms, enum ast_waitstream_fr_cb_values val)
callback used during dtmf controlled file playback to indicate location of playback in a file after r...
Definition: file.h:65
void ast_channel_set_flag(struct ast_channel *chan, unsigned int flag)
Set a flag on a channel.
Definition: channel.c:11082
#define CLI_SHOWUSAGE
Definition: cli.h:45
static int array(struct ast_channel *chan, const char *cmd, char *var, const char *value)
int ast_channel_streamid(const struct ast_channel *chan)
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
static int sanitize_waitstream_return(int return_value)
Definition: file.c:1758
int ast_truncstream(struct ast_filestream *fs)
Trunc stream at current location.
Definition: file.c:1043
struct ast_channel * owner
Definition: mod_format.h:116
void ast_channel_streamid_set(struct ast_channel *chan, int value)
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
int errno
int ast_streamfile(struct ast_channel *chan, const char *filename, const char *preflang)
Streams a file.
Definition: file.c:1250
#define comment
Definition: ael_lex.c:976
int ast_safe_fork(int stop_reaper)
Common routine to safely fork without a chance of a signal handler firing badly in the child...
Definition: main/app.c:2970
Definition: file.c:69
An in-memory media cache.
char mime_types[80]
Definition: mod_format.h:47
struct stasis_message_type * ast_format_register_type(void)
Get the message type used for signaling a format registration.
struct sla_ringing_trunk * first
Definition: app_meetme.c:1092
#define ao2_alloc(data_size, destructor_fn)
Definition: astobj2.h:411
char name[80]
Definition: mod_format.h:44
const char * ast_format_cap_get_names(const struct ast_format_cap *cap, struct ast_str **buf)
Get the names of codecs of a set of formats.
Definition: format_cap.c:736
struct stasis_topic * ast_system_topic(void)
A Stasis Message Bus API topic which publishes messages regarding system changes. ...
struct ast_trans_pvt * trans
Definition: mod_format.h:112
#define ast_strlen_zero(a)
Definition: muted.c:73
#define FORMAT2
int ast_format_def_unregister(const char *name)
Unregisters a file format.
Definition: file.c:162
#define ast_channel_unlock(chan)
Definition: channel.h:2891
#define ast_opt_cache_record_files
Definition: options.h:120
void stasis_publish(struct stasis_topic *topic, struct stasis_message *message)
Publish a message to a topic&#39;s subscribers.
Definition: stasis.c:1507
static const char name[]
Definition: cdr_mysql.c:74
#define ast_free(a)
Definition: astmm.h:182
char * command
Definition: cli.h:186
#define ast_calloc(num, len)
A wrapper for calloc()
Definition: astmm.h:204
fsread_res
Definition: file.c:906
struct ast_format * lastwriteformat
Definition: mod_format.h:114
static struct ast_frame * read_frame(struct ast_filestream *s, int *whennext)
Definition: file.c:874
struct ast_filestream * ast_channel_stream(const struct ast_channel *chan)
static int fileexists_test(const char *filename, const char *fmt, const char *lang, char *buf, int buflen, struct ast_format_cap *result_cap)
test if a file exists for a given format.
Definition: file.c:656
int ast_write(struct ast_channel *chan, struct ast_frame *frame)
Write a frame to a channel This function writes the given frame to the indicated channel.
Definition: channel.c:5088
Prototypes for public functions only of internal interest,.
struct ast_format_def::@270 list
#define ast_frisolate(fr)
Makes a frame independent of any static storage.
struct ast_frame *(* read)(struct ast_filestream *, int *whennext)
Definition: mod_format.h:74
int ast_sched_add(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data) attribute_warn_unused_result
Adds a scheduled event.
Definition: sched.c:565
const char * usage
Definition: cli.h:177
struct ast_format_cap * ast_channel_nativeformats(const struct ast_channel *chan)
char record_cache_dir[AST_CACHE_DIR_LEN]
Definition: options.c:96
int(* trunc)(struct ast_filestream *fs)
Definition: mod_format.h:69
#define ast_module_running_ref(mod)
Hold a reference to the module if it is running.
Definition: module.h:455
#define CLI_SUCCESS
Definition: cli.h:44
struct ast_format * ast_get_format_for_file_ext(const char *file_ext)
Get the ast_format associated with the given file extension.
Definition: file.c:1937
void ast_deactivate_generator(struct ast_channel *chan)
Definition: channel.c:2888
int ast_channel_softhangup_internal_flag(struct ast_channel *chan)
char * strsep(char **str, const char *delims)
char * filename
Definition: mod_format.h:107
This structure is allocated by file.c in one chunk, together with buf_size and desc_size bytes of mem...
Definition: mod_format.h:101
#define ao2_replace(dst, src)
Definition: astobj2.h:517
int ast_waitfor(struct ast_channel *chan, int ms)
Wait for input on a channel.
Definition: channel.c:3157
int ast_media_cache_retrieve(const char *uri, const char *preferred_file_name, char *file_path, size_t len)
Retrieve an item from the cache.
Definition: media_cache.c:196
#define ao2_cleanup(obj)
Definition: astobj2.h:1958
Standard Command Line Interface.
#define DEFAULT_LANGUAGE
Definition: asterisk.h:44
const char * ast_channel_name(const struct ast_channel *chan)
float roundf(float x)
#define DEFAULT_SAMPLES_PER_MS
Definition: asterisk.h:47
static int ast_fsread_audio(const void *data)
Definition: file.c:962
unsigned int ast_format_get_sample_rate(const struct ast_format *format)
Get the sample rate of a media format.
Definition: format.c:379
#define ast_frfree(fr)
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.
Definition: file.c:1813
int ast_waitstream_fr_w_cb(struct ast_channel *c, const char *breakon, const char *forward, const char *reverse, int ms, ast_waitstream_fr_cb cb)
Same as waitstream_fr but allows a callback to be alerted when a user fastforwards or rewinds the fil...
Definition: file.c:1733
static void waitstream_control(struct ast_channel *c, enum ast_waitstream_fr_cb_values type, ast_waitstream_fr_cb cb, int skip_ms)
Definition: file.c:1509
int ast_sched_wait(struct ast_sched_context *con) attribute_warn_unused_result
Determines number of seconds until the next outstanding event to take place.
Definition: sched.c:431
Data structure associated with a single frame of data.
struct ast_frame * ast_readframe(struct ast_filestream *s)
Read a frame from a filestream.
Definition: file.c:899
const char * ast_channel_language(const struct ast_channel *chan)
Abstract JSON element (object, array, string, int, ...).
int __ast_format_def_register(const struct ast_format_def *f, struct ast_module *mod)
Register a new file format capability. Adds a format to Asterisk&#39;s format abilities.
Definition: file.c:124
static enum fsread_res ast_readaudio_callback(struct ast_filestream *s)
Definition: file.c:914
static struct test_val b
static int __ast_file_read_dirs(const char *path, ast_file_on_file on_file, void *obj, int max_depth)
Definition: file.c:1113
Definition: search.h:40
const char * ast_channel_context(const struct ast_channel *chan)
static int publish_format_update(const struct ast_format_def *f, struct stasis_message_type *type)
Definition: file.c:93
ast_media_type
Types of media.
Definition: codec.h:30
enum ast_frame_type frametype
STASIS_MESSAGE_TYPE_DEFN(ast_format_register_type)
#define FORMAT
static int copy(const char *infile, const char *outfile)
Definition: file.c:271
struct ast_filestream * vfs
Definition: mod_format.h:110
static char context[AST_MAX_CONTEXT]
Definition: chan_alsa.c:116
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
static struct ast_json * json_array_from_list(const char *list, const char *sep)
Definition: file.c:74
struct ast_format * ast_format_cap_get_format(const struct ast_format_cap *cap, int position)
Get the format at a specific index.
Definition: format_cap.c:400
struct ast_format * format
static int is_remote_path(const char *filename)
Definition: file.c:645
static void filestream_destructor(void *arg)
Definition: file.c:383
off_t(* tell)(struct ast_filestream *fs)
Definition: mod_format.h:70
Asterisk module definitions.
int ast_language_is_prefix
The following variable controls the layout of localized sound files. If 0, use the historical layout ...
Definition: file.c:67
struct ast_format * ast_channel_writeformat(struct ast_channel *chan)
ast_timing_func_t ast_channel_timingfunc(const struct ast_channel *chan)
static snd_pcm_format_t format
Definition: chan_alsa.c:102
Application convenience functions, designed to give consistent look and feel to Asterisk apps...
int ast_stream_fastforward(struct ast_filestream *fs, off_t ms)
Fast forward stream ms.
Definition: file.c:1058
void ast_channel_vstreamid_set(struct ast_channel *chan, int value)
#define AST_RWLIST_TRAVERSE_SAFE_END
Definition: linkedlists.h:616
int(* write)(struct ast_filestream *, struct ast_frame *)
Definition: mod_format.h:66
file_action
Definition: file.c:495
#define AST_MUTEX_DEFINE_STATIC(mutex)
Definition: lock.h:518
int ast_format_cap_has_type(const struct ast_format_cap *cap, enum ast_media_type type)
Find out if the capabilities structure has any formats of a specific type.
Definition: format_cap.c:615
void ast_translator_free_path(struct ast_trans_pvt *tr)
Frees a translator path Frees the given translator path structure.
Definition: translate.c:469
jack_status_t status
Definition: app_jack.c:146
#define ast_mutex_unlock(a)
Definition: lock.h:188
static int type_in_list(const char *list, const char *type, int(*cmp)(const char *s1, const char *s2))
Definition: file.c:338
#define AST_MAX_FORMATS
Definition: file.h:44
static struct test_val a
int ast_format_cap_iscompatible(const struct ast_format_cap *cap1, const struct ast_format_cap *cap2)
Determine if any joint capabilities exist between two capabilities structures.
Definition: format_cap.c:655