app.c File Reference

Convenient Application Routines. More...

#include "asterisk.h"
#include <regex.h>
#include <sys/file.h>
#include "asterisk/paths.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/file.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/indications.h"
#include "asterisk/linkedlists.h"
#include "asterisk/strings.h"

Include dependency graph for app.c:

Go to the source code of this file.

Data Structures
struct	groups
struct	linear_state
struct	path_lock
struct	path_lock_list
Defines
#define	MAX_OTHER_FORMATS   10
#define	RES_EXIT   (1 << 17)
#define	RES_REPEAT   (1 << 18)
#define	RES_RESTART   ((1 << 19) | RES_REPEAT)
#define	RES_UPONE   (1 << 16)
Functions
unsigned int	__ast_app_separate_args (char *buf, char delim, int remove_chars, char **array, int arraylen)
	Separate a string into arguments in an array.
static int	__ast_play_and_record (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int beep, int silencethreshold, int maxsilence, const char *path, int prepend, const char *acceptdtmf, const char *canceldtmf)
static void	__fini_groups (void)
static void	__init_groups (void)
int	ast_app_dtget (struct ast_channel *chan, const char *context, char *collect, size_t size, int maxlen, int timeout)
	This function presents a dialtone and reads an extension into 'collect' which must be a pointer to a **pre-initialized** array of char having a size of 'size' suitable for writing to. It will collect no more than the smaller of 'maxlen' or 'size' minus the original strlen() of collect digits.
enum ast_getdata_result	ast_app_getdata (struct ast_channel *c, const char *prompt, char *s, int maxlen, int timeout)
	ast_app_getdata
int	ast_app_getdata_full (struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout, int audiofd, int ctrlfd)
	Full version with audiofd and controlfd. NOTE: returns '2' on ctrlfd available, not '1' like other full functions.
int	ast_app_group_discard (struct ast_channel *chan)
	Discard all group counting for a channel.
int	ast_app_group_get_count (const char *group, const char *category)
	Get the current channel count of the specified group and category.
struct ast_group_info *	ast_app_group_list_head (void)
	Get the head of the group count list.
int	ast_app_group_list_rdlock (void)
	Read Lock the group count list.
int	ast_app_group_list_unlock (void)
	Unlock the group count list.
int	ast_app_group_list_wrlock (void)
	Write Lock the group count list.
int	ast_app_group_match_get_count (const char *groupmatch, const char *category)
	Get the current channel count of all groups that match the specified pattern and category.
int	ast_app_group_set_channel (struct ast_channel *chan, const char *data)
	Set the group for a channel, splitting the provided data into group and category, if specified.
int	ast_app_group_split_group (const char *data, char *group, int group_max, char *category, int category_max)
	Split a group string into group and category, returning a default category if none is provided.
int	ast_app_group_update (struct ast_channel *old, struct ast_channel *new)
	Update all group counting for a channel to a new one.
int	ast_app_has_voicemail (const char *mailbox, const char *folder)
	Determine if a given mailbox has any voicemail.
int	ast_app_inboxcount (const char *mailbox, int *newmsgs, int *oldmsgs)
	Determine number of new/old messages in a mailbox.
int	ast_app_messagecount (const char *context, const char *mailbox, const char *folder)
	Determine number of messages in a given mailbox and folder.
void	ast_app_options2str64 (const struct ast_app_option *options, struct ast_flags64 *flags, char *buf, size_t len)
	Given a list of options array, return an option string based on passed flags.
int	ast_app_parse_options (const struct ast_app_option *options, struct ast_flags *flags, char **args, char *optstr)
	Parses a string containing application options and sets flags/arguments.
int	ast_app_parse_options64 (const struct ast_app_option *options, struct ast_flags64 *flags, char **args, char *optstr)
	Parses a string containing application options and sets flags/arguments.
unsigned int	ast_app_separate_args (char *buf, char delim, char **array, int arraylen)
int	ast_control_streamfile (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *pause, const char *restart, int skipms, long *offsetms)
	Stream a file with fast forward, pause, reverse, restart.
int	ast_dtmf_stream (struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between, unsigned int duration)
	Send DTMF to a channel.
int	ast_get_encoded_char (const char *stream, char *result, size_t *consumed)
	Decode an encoded control or extended ASCII character.
int	ast_get_encoded_str (const char *stream, char *result, size_t result_size)
	Decode a string which may contain multiple encoded control or extended ASCII characters.
void	ast_install_vm_functions (int(*has_voicemail_func)(const char *mailbox, const char *folder), int(*inboxcount_func)(const char *mailbox, int *newmsgs, int *oldmsgs), int(*messagecount_func)(const char *context, const char *mailbox, const char *folder))
int	ast_ivr_menu_run (struct ast_channel *chan, struct ast_ivr_menu *menu, void *cbdata)
	Runs an IVR menu.
static int	ast_ivr_menu_run_internal (struct ast_channel *chan, struct ast_ivr_menu *menu, void *cbdata)
int	ast_linear_stream (struct ast_channel *chan, const char *filename, int fd, int allowoverride)
	Stream a filename (or file descriptor) as a generator.
enum AST_LOCK_RESULT	ast_lock_path (const char *path)
	Lock a filesystem path.
static enum AST_LOCK_RESULT	ast_lock_path_flock (const char *path)
static enum AST_LOCK_RESULT	ast_lock_path_lockfile (const char *path)
int	ast_play_and_prepend (struct ast_channel *chan, char *playfile, char *recordfile, int maxtime, char *fmt, int *duration, int beep, int silencethreshold, int maxsilence)
	Record a message and prepend the message to the given record file after playing the optional playfile (or a beep), storing the duration in 'duration' and with a maximum permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults.
int	ast_play_and_record (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int silencethreshold, int maxsilence, const char *path)
	Record a file for a max amount of time (in seconds), in a given list of formats separated by '|', outputting the duration of the recording, and with a maximum permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults. calls ast_unlock_path() on 'path' if passed.
int	ast_play_and_record_full (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int silencethreshold, int maxsilence, const char *path, const char *acceptdtmf, const char *canceldtmf)
int	ast_play_and_wait (struct ast_channel *chan, const char *fn)
	Play a stream and wait for a digit, returning the digit that was pressed.
char *	ast_read_textfile (const char *filename)
	Read a file into asterisk.
int	ast_record_review (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, const char *path)
	Allow to record message and have a review option.
void	ast_set_lock_type (enum AST_LOCK_TYPE type)
	Set the type of locks used by ast_lock_path().
int	ast_str_get_encoded_str (struct ast_str **str, int maxlen, const char *stream)
	Decode a stream of encoded control or extended ASCII characters.
void	ast_uninstall_vm_functions (void)
int	ast_unlock_path (const char *path)
	Unlock a path.
static int	ast_unlock_path_flock (const char *path)
static int	ast_unlock_path_lockfile (const char *path)
static int	ivr_dispatch (struct ast_channel *chan, struct ast_ivr_option *option, char *exten, void *cbdata)
static void *	linear_alloc (struct ast_channel *chan, void *params)
static int	linear_generator (struct ast_channel *chan, void *data, int len, int samples)
static void	linear_release (struct ast_channel *chan, void *params)
static int	option_exists (struct ast_ivr_menu *menu, char *option)
static int	option_matchmore (struct ast_ivr_menu *menu, char *option)
static void	path_lock_destroy (struct path_lock *obj)
static int	read_newoption (struct ast_channel *chan, struct ast_ivr_menu *menu, char *exten, int maxexten)
Variables
static int(*	ast_has_voicemail_func )(const char *mailbox, const char *folder) = NULL
static int(*	ast_inboxcount_func )(const char *mailbox, int *newmsgs, int *oldmsgs) = NULL
static enum AST_LOCK_TYPE	ast_lock_type = AST_LOCK_TYPE_LOCKFILE
static int(*	ast_messagecount_func )(const char *context, const char *mailbox, const char *folder) = NULL
static char	default_acceptdtmf [] = "#"
static char	default_canceldtmf [] = ""
static int	global_maxsilence = 0
static int	global_silence_threshold = 128
static struct ast_generator	linearstream

---

Detailed Description

Convenient Application Routines.

Author:

Mark Spencer <markster@digium.com>

Definition in file app.c.

---

Define Documentation

#define MAX_OTHER_FORMATS   10

Definition at line 48 of file app.c.

Referenced by __ast_play_and_record().

#define RES_EXIT   (1 << 17)

Definition at line 1416 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_REPEAT   (1 << 18)

Definition at line 1417 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_RESTART   ((1 << 19) | RES_REPEAT)

Definition at line 1418 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_UPONE   (1 << 16)

Definition at line 1415 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

---

Function Documentation

unsigned int __ast_app_separate_args	(	char *	buf,
		char	delim,
		int	remove_chars,
		char **	array,
		int	arraylen
	)

Separate a string into arguments in an array.

Parameters:

	buf	The string to be parsed (this must be a writable copy, as it will be modified)
	delim	The character to be used to delimit arguments
	remove_chars	Remove backslashes and quote characters, while parsing
	array	An array of 'char *' to be filled in with pointers to the found arguments
	arraylen	The number of elements in the array (i.e. the number of arguments you will accept)

Note: if there are more arguments in the string than the array will hold, the last element of the array will contain the remaining arguments, not separated.

The array will be completely zeroed by this function before it populates any entries.

Returns:

The number of arguments found, or zero if the function arguments are not valid.

Definition at line 1037 of file app.c.

References quote().

Referenced by ast_app_separate_args().

{
   int argc;
   char *scan, *wasdelim = NULL;
   int paren = 0, quote = 0;

   if (!buf || !array || !arraylen)
      return 0;

   memset(array, 0, arraylen * sizeof(*array));

   scan = buf;

   for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
      array[argc] = scan;
      for (; *scan; scan++) {
         if (*scan == '(')
            paren++;
         else if (*scan == ')') {
            if (paren)
               paren--;
         } else if (*scan == '"' && delim != '"') {
            quote = quote ? 0 : 1;
            if (remove_chars) {
               /* Remove quote character from argument */
               memmove(scan, scan + 1, strlen(scan));
               scan--;
            }
         } else if (*scan == '\\') {
            if (remove_chars) {
               /* Literal character, don't parse */
               memmove(scan, scan + 1, strlen(scan));
            } else {
               scan++;
            }
         } else if ((*scan == delim) && !paren && !quote) {
            wasdelim = scan;
            *scan++ = '\0';
            break;
         }
      }
   }

   /* If the last character in the original string was the delimiter, then
    * there is one additional argument. */
   if (*scan || (scan > buf && (scan - 1) == wasdelim)) {
      array[argc++] = scan;
   }

   return argc;
}

static int __ast_play_and_record	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime,
		const char *	fmt,
		int *	duration,
		int	beep,
		int	silencethreshold,
		int	maxsilence,
		const char *	path,
		int	prepend,
		const char *	acceptdtmf,
		const char *	canceldtmf
	)			[static]

Optionally play a sound file or a beep, then record audio and video from the channel.

Parameters:

	chan	Channel to playback to/record from.
	playfile	Filename of sound to play before recording begins.
	recordfile	Filename to record to.
	maxtime	Maximum length of recording (in milliseconds).
	fmt	Format(s) to record message in. Multiple formats may be specified by separating them with a '|'.
	duration	Where to store actual length of the recorded message (in milliseconds).
	beep	Whether to play a beep before starting to record.
	silencethreshold
	maxsilence	Length of silence that will end a recording (in milliseconds).
	path	Optional filesystem path to unlock.
	prepend	If true, prepend the recorded audio to an existing file.
	acceptdtmf	DTMF digits that will end the recording.
	canceldtmf	DTMF digits that will cancel the recording.

Note:

Instead of asking how much time passed (end - start), calculate the number of seconds of audio which actually went into the file. This fixes a problem where audio is stopped up on the network and never gets to us.

Note that we still want to use the number of seconds passed for the max message, otherwise we could get a situation where this stream is never closed (which would create a resource leak).

Note:

If we ended with silence, trim all but the first 200ms of silence off the recording. However, if we ended with '#', we don't want to trim ANY part of the recording.

Same logic as above.

Definition at line 572 of file app.c.

References ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_closestream(), AST_CONTROL_VIDUPDATE, ast_copy_string(), ast_debug, ast_dsp_free(), ast_dsp_new(), ast_dsp_set_threshold(), ast_dsp_silence(), AST_FILE_MODE, ast_filedelete(), ast_filerename(), AST_FORMAT_SLINEAR, AST_FRAME_DTMF, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_getformatname(), ast_indicate(), ast_log(), ast_opt_transmit_silence, ast_play_and_wait(), ast_read(), ast_readfile(), ast_readframe(), ast_set_read_format(), ast_strdupa, ast_stream_and_wait(), ast_stream_rewind(), ast_tellstream(), ast_truncstream(), ast_unlock_path(), ast_verb, ast_waitfor(), ast_writefile(), ast_writestream(), f, ast_frame::frametype, LOG_WARNING, MAX_OTHER_FORMATS, ast_channel::name, ast_channel::readformat, strsep(), ast_frame::subclass, and ast_dsp::totalsilence.

Referenced by ast_play_and_prepend(), ast_play_and_record(), and ast_play_and_record_full().

{
   int d = 0;
   char *fmts;
   char comment[256];
   int x, fmtcnt = 1, res = -1, outmsg = 0;
   struct ast_filestream *others[MAX_OTHER_FORMATS];
   char *sfmt[MAX_OTHER_FORMATS];
   char *stringp = NULL;
   time_t start, end;
   struct ast_dsp *sildet = NULL;   /* silence detector dsp */
   int totalsilence = 0;
   int rfmt = 0;
   struct ast_silence_generator *silgen = NULL;
   char prependfile[80];

   if (silencethreshold < 0)
      silencethreshold = global_silence_threshold;

   if (maxsilence < 0)
      maxsilence = global_maxsilence;

   /* barf if no pointer passed to store duration in */
   if (!duration) {
      ast_log(LOG_WARNING, "Error play_and_record called without duration pointer\n");
      return -1;
   }

   ast_debug(1, "play_and_record: %s, %s, '%s'\n", playfile ? playfile : "<None>", recordfile, fmt);
   snprintf(comment, sizeof(comment), "Playing %s, Recording to: %s on %s\n", playfile ? playfile : "<None>", recordfile, chan->name);

   if (playfile || beep) {
      if (!beep)
         d = ast_play_and_wait(chan, playfile);
      if (d > -1)
         d = ast_stream_and_wait(chan, "beep", "");
      if (d < 0)
         return -1;
   }

   if (prepend) {
      ast_copy_string(prependfile, recordfile, sizeof(prependfile)); 
      strncat(prependfile, "-prepend", sizeof(prependfile) - strlen(prependfile) - 1);
   }

   fmts = ast_strdupa(fmt);

   stringp = fmts;
   strsep(&stringp, "|");
   ast_debug(1, "Recording Formats: sfmts=%s\n", fmts);
   sfmt[0] = ast_strdupa(fmts);

   while ((fmt = strsep(&stringp, "|"))) {
      if (fmtcnt > MAX_OTHER_FORMATS - 1) {
         ast_log(LOG_WARNING, "Please increase MAX_OTHER_FORMATS in app.c\n");
         break;
      }
      sfmt[fmtcnt++] = ast_strdupa(fmt);
   }

   end = start = time(NULL);  /* pre-initialize end to be same as start in case we never get into loop */
   for (x = 0; x < fmtcnt; x++) {
      others[x] = ast_writefile(prepend ? prependfile : recordfile, sfmt[x], comment, O_TRUNC, 0, AST_FILE_MODE);
      ast_verb(3, "x=%d, open writing:  %s format: %s, %p\n", x, prepend ? prependfile : recordfile, sfmt[x], others[x]);

      if (!others[x])
         break;
   }

   if (path)
      ast_unlock_path(path);

   if (maxsilence > 0) {
      sildet = ast_dsp_new(); /* Create the silence detector */
      if (!sildet) {
         ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
         return -1;
      }
      ast_dsp_set_threshold(sildet, silencethreshold);
      rfmt = chan->readformat;
      res = ast_set_read_format(chan, AST_FORMAT_SLINEAR);
      if (res < 0) {
         ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
         ast_dsp_free(sildet);
         return -1;
      }
   }

   if (!prepend) {
      /* Request a video update */
      ast_indicate(chan, AST_CONTROL_VIDUPDATE);

      if (ast_opt_transmit_silence)
         silgen = ast_channel_start_silence_generator(chan);
   }

   if (x == fmtcnt) {
      /* Loop forever, writing the packets we read to the writer(s), until
         we read a digit or get a hangup */
      struct ast_frame *f;
      for (;;) {
         res = ast_waitfor(chan, 2000);
         if (!res) {
            ast_debug(1, "One waitfor failed, trying another\n");
            /* Try one more time in case of masq */
            res = ast_waitfor(chan, 2000);
            if (!res) {
               ast_log(LOG_WARNING, "No audio available on %s??\n", chan->name);
               res = -1;
            }
         }

         if (res < 0) {
            f = NULL;
            break;
         }
         f = ast_read(chan);
         if (!f)
            break;
         if (f->frametype == AST_FRAME_VOICE) {
            /* write each format */
            for (x = 0; x < fmtcnt; x++) {
               if (prepend && !others[x])
                  break;
               res = ast_writestream(others[x], f);
            }

            /* Silence Detection */
            if (maxsilence > 0) {
               int dspsilence = 0;
               ast_dsp_silence(sildet, f, &dspsilence);
               if (dspsilence)
                  totalsilence = dspsilence;
               else
                  totalsilence = 0;

               if (totalsilence > maxsilence) {
                  /* Ended happily with silence */
                  ast_verb(3, "Recording automatically stopped after a silence of %d seconds\n", totalsilence/1000);
                  res = 'S';
                  outmsg = 2;
                  break;
               }
            }
            /* Exit on any error */
            if (res) {
               ast_log(LOG_WARNING, "Error writing frame\n");
               break;
            }
         } else if (f->frametype == AST_FRAME_VIDEO) {
            /* Write only once */
            ast_writestream(others[0], f);
         } else if (f->frametype == AST_FRAME_DTMF) {
            if (prepend) {
            /* stop recording with any digit */
               ast_verb(3, "User ended message by pressing %c\n", f->subclass);
               res = 't';
               outmsg = 2;
               break;
            }
            if (strchr(acceptdtmf, f->subclass)) {
               ast_verb(3, "User ended message by pressing %c\n", f->subclass);
               res = f->subclass;
               outmsg = 2;
               break;
            }
            if (strchr(canceldtmf, f->subclass)) {
               ast_verb(3, "User cancelled message by pressing %c\n", f->subclass);
               res = f->subclass;
               outmsg = 0;
               break;
            }
         }
         if (maxtime) {
            end = time(NULL);
            if (maxtime < (end - start)) {
               ast_verb(3, "Took too long, cutting it short...\n");
               res = 't';
               outmsg = 2;
               break;
            }
         }
         ast_frfree(f);
      }
      if (!f) {
         ast_verb(3, "User hung up\n");
         res = -1;
         outmsg = 1;
      } else {
         ast_frfree(f);
      }
   } else {
      ast_log(LOG_WARNING, "Error creating writestream '%s', format '%s'\n", recordfile, sfmt[x]);
   }

   if (!prepend) {
      if (silgen)
         ast_channel_stop_silence_generator(chan, silgen);
   }

   /*!\note
    * Instead of asking how much time passed (end - start), calculate the number
    * of seconds of audio which actually went into the file.  This fixes a
    * problem where audio is stopped up on the network and never gets to us.
    *
    * Note that we still want to use the number of seconds passed for the max
    * message, otherwise we could get a situation where this stream is never
    * closed (which would create a resource leak).
    */
   *duration = others[0] ? ast_tellstream(others[0]) / 8000 : 0;

   if (!prepend) {
      for (x = 0; x < fmtcnt; x++) {
         if (!others[x])
            break;
         /*!\note
          * If we ended with silence, trim all but the first 200ms of silence
          * off the recording.  However, if we ended with '#', we don't want
          * to trim ANY part of the recording.
          */
         if (res > 0 && totalsilence) {
            ast_stream_rewind(others[x], totalsilence - 200);
            /* Reduce duration by a corresponding amount */
            if (x == 0 && *duration) {
               *duration -= (totalsilence - 200) / 1000;
               if (*duration < 0) {
                  *duration = 0;
               }
            }
         }
         ast_truncstream(others[x]);
         ast_closestream(others[x]);
      }
   }

   if (prepend && outmsg) {
      struct ast_filestream *realfiles[MAX_OTHER_FORMATS];
      struct ast_frame *fr;

      for (x = 0; x < fmtcnt; x++) {
         snprintf(comment, sizeof(comment), "Opening the real file %s.%s\n", recordfile, sfmt[x]);
         realfiles[x] = ast_readfile(recordfile, sfmt[x], comment, O_RDONLY, 0, 0);
         if (!others[x] || !realfiles[x])
            break;
         /*!\note Same logic as above. */
         if (totalsilence)
            ast_stream_rewind(others[x], totalsilence - 200);
         ast_truncstream(others[x]);
         /* add the original file too */
         while ((fr = ast_readframe(realfiles[x]))) {
            ast_writestream(others[x], fr);
            ast_frfree(fr);
         }
         ast_closestream(others[x]);
         ast_closestream(realfiles[x]);
         ast_filerename(prependfile, recordfile, sfmt[x]);
         ast_verb(4, "Recording Format: sfmts=%s, prependfile %s, recordfile %s\n", sfmt[x], prependfile, recordfile);
         ast_filedelete(prependfile, sfmt[x]);
      }
   }
   if (rfmt && ast_set_read_format(chan, rfmt)) {
      ast_log(LOG_WARNING, "Unable to restore format %s to channel '%s'\n", ast_getformatname(rfmt), chan->name);
   }
   if (outmsg == 2) {
      ast_stream_and_wait(chan, "auth-thankyou", "");
   }
   if (sildet)
      ast_dsp_free(sildet);
   return res;
}

static void __fini_groups

(

void

)

[static]

Definition at line 50 of file app.c.

{

static void __init_groups

(

void

)

[static]

Definition at line 50 of file app.c.

{

int ast_app_dtget	(	struct ast_channel *	chan,
		const char *	context,
		char *	collect,
		size_t	size,
		int	maxlen,
		int	timeout
	)

This function presents a dialtone and reads an extension into 'collect' which must be a pointer to a **pre-initialized** array of char having a size of 'size' suitable for writing to. It will collect no more than the smaller of 'maxlen' or 'size' minus the original strlen() of collect digits.

Present a dialtone and collect a certain length extension.

Parameters:

	chan	struct.
	context
	collect
	size
	maxlen
	timeout	timeout in seconds

Returns:

0 if extension does not exist, 1 if extension exists

Definition at line 66 of file app.c.

References ast_exists_extension(), ast_get_indication_tone(), ast_ignore_pattern(), ast_log(), ast_matchmore_extension(), ast_playtones_start(), ast_playtones_stop(), ast_waitfordigit(), ast_channel::cid, ast_callerid::cid_num, tone_zone_sound::data, ast_pbx::dtimeout, LOG_NOTICE, ast_channel::pbx, and ast_channel::zone.

Referenced by builtin_atxfer(), and builtin_blindtransfer().

{
   struct tone_zone_sound *ts;
   int res = 0, x = 0;

   if (maxlen > size)
      maxlen = size;
   
   if (!timeout && chan->pbx)
      timeout = chan->pbx->dtimeout;
   else if (!timeout)
      timeout = 5;

   if ((ts = ast_get_indication_tone(chan->zone, "dial")) && ts->data[0])
      res = ast_playtones_start(chan, 0, ts->data, 0);
   else 
      ast_log(LOG_NOTICE, "Huh....? no dial for indications?\n");
   
   for (x = strlen(collect); x < maxlen; ) {
      res = ast_waitfordigit(chan, timeout);
      if (!ast_ignore_pattern(context, collect))
         ast_playtones_stop(chan);
      if (res < 1)
         break;
      if (res == '#')
         break;
      collect[x++] = res;
      if (!ast_matchmore_extension(chan, context, collect, 1, chan->cid.cid_num))
         break;
   }

   if (res >= 0)
      res = ast_exists_extension(chan, context, collect, 1, chan->cid.cid_num) ? 1 : 0;

   return res;
}

enum ast_getdata_result ast_app_getdata	(	struct ast_channel *	c,
		const char *	prompt,
		char *	s,
		int	maxlen,
		int	timeout
	)

ast_app_getdata

Plays a stream and gets DTMF data from a channel.

Parameters:

	c	The channel to read from
	prompt	The file to stream to the channel
	s	The string to read in to. Must be at least the size of your length
	maxlen	How many digits to read (maximum)
	timeout	set timeout to 0 for "standard" timeouts. Set timeout to -1 for "ludicrous time" (essentially never times out)

Definition at line 111 of file app.c.

References AST_GETDATA_EMPTY_END_TERMINATED, ast_readstring(), ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_pbx::dtimeout, ast_channel::language, ast_channel::pbx, ast_pbx::rtimeout, and strsep().

Referenced by auth_exec(), conf_exec(), dictate_exec(), find_conf(), login_exec(), read_exec(), testclient_exec(), testserver_exec(), and vm_exec().

{
   int res = 0, to, fto;
   char *front, *filename;

   /* XXX Merge with full version? XXX */
   
   if (maxlen)
      s[0] = '\0';

   if (!prompt)
      prompt = "";

   filename = ast_strdupa(prompt);
   while ((front = strsep(&filename, "&"))) {
      if (!ast_strlen_zero(front)) {
         res = ast_streamfile(c, front, c->language);
         if (res)
            continue;
      }
      if (ast_strlen_zero(filename)) {
         /* set timeouts for the last prompt */
         fto = c->pbx ? c->pbx->rtimeout * 1000 : 6000;
         to = c->pbx ? c->pbx->dtimeout * 1000 : 2000;

         if (timeout > 0) 
            fto = to = timeout;
         if (timeout < 0) 
            fto = to = 1000000000;
      } else {
         /* there is more than one prompt, so
            get rid of the long timeout between 
            prompts, and make it 50ms */
         fto = 50;
         to = c->pbx ? c->pbx->dtimeout * 1000 : 2000;
      }
      res = ast_readstring(c, s, maxlen, to, fto, "#");
      if (res == AST_GETDATA_EMPTY_END_TERMINATED) {
         return res;
      }
      if (!ast_strlen_zero(s)) {
         return res;
      }
   }

   return res;
}

int ast_app_getdata_full	(	struct ast_channel *	c,
		char *	prompt,
		char *	s,
		int	maxlen,
		int	timeout,
		int	audiofd,
		int	ctrlfd
	)

Full version with audiofd and controlfd. NOTE: returns '2' on ctrlfd available, not '1' like other full functions.

Definition at line 162 of file app.c.

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

Referenced by handle_getdata().

{
   int res, to = 2000, fto = 6000;

   if (!ast_strlen_zero(prompt)) {
      res = ast_streamfile(c, prompt, c->language);
      if (res < 0)
         return res;
   }
   
   if (timeout > 0) 
      fto = to = timeout;
   if (timeout < 0) 
      fto = to = 1000000000;

   res = ast_readstring_full(c, s, maxlen, to, fto, "#", audiofd, ctrlfd);

   return res;
}

int ast_app_group_discard

(

struct ast_channel *

chan

)

Discard all group counting for a channel.

Definition at line 997 of file app.c.

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_group_info::chan, and ast_group_info::group_list.

Referenced by ast_channel_free().

{
   struct ast_group_info *gi = NULL;
   
   AST_RWLIST_WRLOCK(&groups);
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
      if (gi->chan == chan) {
         AST_RWLIST_REMOVE_CURRENT(group_list);
         ast_free(gi);
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END;
   AST_RWLIST_UNLOCK(&groups);
   
   return 0;
}

int ast_app_group_get_count	(	const char *	group,
		const char *	category
	)

Get the current channel count of the specified group and category.

Definition at line 935 of file app.c.

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_group_info::category, ast_group_info::group, and ast_group_info::group_list.

Referenced by group_count_function_read().

{
   struct ast_group_info *gi = NULL;
   int count = 0;

   if (ast_strlen_zero(group))
      return 0;
   
   AST_RWLIST_RDLOCK(&groups);
   AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
      if (!strcasecmp(gi->group, group) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
         count++;
   }
   AST_RWLIST_UNLOCK(&groups);

   return count;
}

struct ast_group_info* ast_app_group_list_head

(

void

)

[read]

Get the head of the group count list.

Definition at line 1024 of file app.c.

References AST_RWLIST_FIRST.

Referenced by group_count_function_read(), group_function_read(), group_list_function_read(), and group_show_channels().

{
   return AST_RWLIST_FIRST(&groups);
}

int ast_app_group_list_rdlock

(

void

)

Read Lock the group count list.

Definition at line 1019 of file app.c.

References AST_RWLIST_RDLOCK.

Referenced by group_count_function_read(), group_function_read(), group_list_function_read(), and group_show_channels().

{
   return AST_RWLIST_RDLOCK(&groups);
}

int ast_app_group_list_unlock

(

void

)

Unlock the group count list.

Definition at line 1029 of file app.c.

References AST_RWLIST_UNLOCK.

Referenced by group_count_function_read(), group_function_read(), group_list_function_read(), and group_show_channels().

{
   return AST_RWLIST_UNLOCK(&groups);
}

int ast_app_group_list_wrlock

(

void

)

Write Lock the group count list.

Definition at line 1014 of file app.c.

References AST_RWLIST_WRLOCK.

{
   return AST_RWLIST_WRLOCK(&groups);
}

int ast_app_group_match_get_count	(	const char *	groupmatch,
		const char *	category
	)

Get the current channel count of all groups that match the specified pattern and category.

Definition at line 953 of file app.c.

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_group_info::category, ast_group_info::group, and ast_group_info::group_list.

Referenced by group_match_count_function_read().

{
   struct ast_group_info *gi = NULL;
   regex_t regexbuf;
   int count = 0;

   if (ast_strlen_zero(groupmatch))
      return 0;

   /* if regex compilation fails, return zero matches */
   if (regcomp(&regexbuf, groupmatch, REG_EXTENDED | REG_NOSUB))
      return 0;

   AST_RWLIST_RDLOCK(&groups);
   AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
      if (!regexec(&regexbuf, gi->group, 0, NULL, 0) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
         count++;
   }
   AST_RWLIST_UNLOCK(&groups);

   regfree(&regexbuf);

   return count;
}

int ast_app_group_set_channel	(	struct ast_channel *	chan,
		const char *	data
	)

Set the group for a channel, splitting the provided data into group and category, if specified.

Definition at line 890 of file app.c.

References ast_app_group_split_group(), AST_RWLIST_INSERT_TAIL, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_strlen_zero(), calloc, ast_group_info::category, ast_group_info::chan, free, ast_group_info::group, ast_group_info::group_list, and len().

Referenced by dial_exec_full(), and group_function_write().

{
   int res = 0;
   char group[80] = "", category[80] = "";
   struct ast_group_info *gi = NULL;
   size_t len = 0;
   
   if (ast_app_group_split_group(data, group, sizeof(group), category, sizeof(category)))
      return -1;
   
   /* Calculate memory we will need if this is new */
   len = sizeof(*gi) + strlen(group) + 1;
   if (!ast_strlen_zero(category))
      len += strlen(category) + 1;
   
   AST_RWLIST_WRLOCK(&groups);
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
      if ((gi->chan == chan) && ((ast_strlen_zero(category) && ast_strlen_zero(gi->category)) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
         AST_RWLIST_REMOVE_CURRENT(group_list);
         free(gi);
         break;
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END;

   if (ast_strlen_zero(group)) {
      /* Enable unsetting the group */
   } else if ((gi = calloc(1, len))) {
      gi->chan = chan;
      gi->group = (char *) gi + sizeof(*gi);
      strcpy(gi->group, group);
      if (!ast_strlen_zero(category)) {
         gi->category = (char *) gi + sizeof(*gi) + strlen(group) + 1;
         strcpy(gi->category, category);
      }
      AST_RWLIST_INSERT_TAIL(&groups, gi, group_list);
   } else {
      res = -1;
   }
   
   AST_RWLIST_UNLOCK(&groups);
   
   return res;
}

int ast_app_group_split_group	(	const char *	data,
		char *	group,
		int	group_max,
		char *	category,
		int	category_max
	)

Split a group string into group and category, returning a default category if none is provided.

Definition at line 863 of file app.c.

References ast_copy_string(), and ast_strlen_zero().

Referenced by ast_app_group_set_channel(), group_count_function_read(), and group_match_count_function_read().

{
   int res = 0;
   char tmp[256];
   char *grp = NULL, *cat = NULL;

   if (!ast_strlen_zero(data)) {
      ast_copy_string(tmp, data, sizeof(tmp));
      grp = tmp;
      cat = strchr(tmp, '@');
      if (cat) {
         *cat = '\0';
         cat++;
      }
   }

   if (!ast_strlen_zero(grp))
      ast_copy_string(group, grp, group_max);
   else
      *group = '\0';

   if (!ast_strlen_zero(cat))
      ast_copy_string(category, cat, category_max);

   return res;
}

int ast_app_group_update	(	struct ast_channel *	old,
		struct ast_channel *	new
	)

Update all group counting for a channel to a new one.

Definition at line 978 of file app.c.

References ast_free, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_group_info::chan, and ast_group_info::group_list.

Referenced by ast_do_masquerade(), and check_bridge().

{
   struct ast_group_info *gi = NULL;

   AST_RWLIST_WRLOCK(&groups);
   AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
      if (gi->chan == old) {
         gi->chan = new;
      } else if (gi->chan == new) {
         AST_RWLIST_REMOVE_CURRENT(group_list);
         ast_free(gi);
      }
   }
   AST_RWLIST_TRAVERSE_SAFE_END
   AST_RWLIST_UNLOCK(&groups);

   return 0;
}

int ast_app_has_voicemail	(	const char *	mailbox,
		const char *	folder
	)

Determine if a given mailbox has any voicemail.

Definition at line 202 of file app.c.

References ast_has_voicemail_func, and ast_verb.

Referenced by action_mailboxstatus(), has_voicemail(), notify_new_message(), play_dialtone(), poll_mailbox(), and run_externnotify().

{
   static int warned = 0;
   if (ast_has_voicemail_func)
      return ast_has_voicemail_func(mailbox, folder);

   if (!warned) {
      ast_verb(3, "Message check requested for mailbox %s/folder %s but voicemail not loaded.\n", mailbox, folder ? folder : "INBOX");
      warned++;
   }
   return 0;
}

int ast_app_inboxcount	(	const char *	mailbox,
		int *	newmsgs,
		int *	oldmsgs
	)

Determine number of new/old messages in a mailbox.

Definition at line 216 of file app.c.

References ast_inboxcount_func, and ast_verb.

Referenced by action_mailboxcount(), notify_new_message(), sip_send_mwi_to_peer(), unistim_send_mwi_to_peer(), update_registry(), and vm_execmain().

{
   static int warned = 0;
   if (newmsgs)
      *newmsgs = 0;
   if (oldmsgs)
      *oldmsgs = 0;
   if (ast_inboxcount_func)
      return ast_inboxcount_func(mailbox, newmsgs, oldmsgs);

   if (!warned) {
      warned++;
      ast_verb(3, "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
   }

   return 0;
}

int ast_app_messagecount	(	const char *	context,
		const char *	mailbox,
		const char *	folder
	)

Determine number of messages in a given mailbox and folder.

Definition at line 234 of file app.c.

References ast_messagecount_func, and ast_verb.

Referenced by acf_vmcount_exec().

{
   static int warned = 0;
   if (ast_messagecount_func)
      return ast_messagecount_func(context, mailbox, folder);

   if (!warned) {
      warned++;
      ast_verb(3, "Message count requested for mailbox %s@%s/%s but voicemail not loaded.\n", mailbox, context, folder);
   }

   return 0;
}

void ast_app_options2str64	(	const struct ast_app_option *	options,
		struct ast_flags64 *	flags,
		char *	buf,
		size_t	len
	)

Given a list of options array, return an option string based on passed flags.

Parameters:

	options	The array of possible options declared with AST_APP_OPTIONS
	flags	The flags of the options that you wish to populate the buffer with
	buf	The buffer to fill with the string of options
	len	The maximum length of buf

Definition at line 1723 of file app.c.

References ast_test_flag64.

{
   unsigned int i, found = 0;
   for (i = 32; i < 128 && found < len; i++) {
      if (ast_test_flag64(flags, options[i].flag)) {
         buf[found++] = i;
      }
   }
   buf[found] = '\0';
}

int ast_app_parse_options	(	const struct ast_app_option *	options,
		struct ast_flags *	flags,
		char **	args,
		char *	optstr
	)

Parses a string containing application options and sets flags/arguments.

Parameters:

	options	The array of possible options declared with AST_APP_OPTIONS
	flags	The flag structure to have option flags set
	args	The array of argument pointers to hold arguments found
	optstr	The string containing the options to be parsed

Returns:

zero for success, non-zero if an error occurs

See also:

AST_APP_OPTIONS

Definition at line 1647 of file app.c.

References ast_app_option::arg_index, ast_clear_flag, AST_FLAGS_ALL, ast_log(), ast_set_flag, LOG_WARNING, and s.

Referenced by app_exec(), auth_exec(), bridge_exec(), cdr_read(), cdr_write(), chanspy_exec(), conf_exec(), controlplayback_exec(), directory_exec(), disa_exec(), dundi_query_read(), dundifunc_read(), extenspy_exec(), forkcdr_exec(), handle_options(), hint_read(), minivm_accmess_exec(), minivm_greet_exec(), minivm_record_exec(), mixmonitor_exec(), page_exec(), pbx_builtin_background(), pbx_builtin_resetcdr(), pbx_builtin_waitexten(), read_exec(), readexten_exec(), record_exec(), sendurl_exec(), sla_trunk_exec(), sms_exec(), softhangup_exec(), speech_background(), vm_exec(), and vm_execmain().

{
   char *s, *arg;
   int curarg, res = 0;
   unsigned int argloc;

   ast_clear_flag(flags, AST_FLAGS_ALL);

   if (!optstr)
      return 0;

   s = optstr;
   while (*s) {
      curarg = *s++ & 0x7f;   /* the array (in app.h) has 128 entries */
      argloc = options[curarg].arg_index;
      if (*s == '(') {
         /* Has argument */
         arg = ++s;
         if ((s = strchr(s, ')'))) {
            if (argloc)
               args[argloc - 1] = arg;
            *s++ = '\0';
         } else {
            ast_log(LOG_WARNING, "Missing closing parenthesis for argument '%c' in string '%s'\n", curarg, arg);
            res = -1;
            break;
         }
      } else if (argloc) {
         args[argloc - 1] = "";
      }
      ast_set_flag(flags, options[curarg].flag);
   }

   return res;
}

int ast_app_parse_options64	(	const struct ast_app_option *	options,
		struct ast_flags64 *	flags,
		char **	args,
		char *	optstr
	)

Parses a string containing application options and sets flags/arguments.

Parameters:

	options	The array of possible options declared with AST_APP_OPTIONS
	flags	The 64-bit flag structure to have option flags set
	args	The array of argument pointers to hold arguments found
	optstr	The string containing the options to be parsed

Returns:

zero for success, non-zero if an error occurs

See also:

AST_APP_OPTIONS

Definition at line 1687 of file app.c.

References ast_app_option::arg_index, ast_log(), ast_set_flag64, ast_flags64::flags, LOG_WARNING, and s.

Referenced by dial_exec_full().

{
   char *s, *arg;
   int curarg, res = 0;
   unsigned int argloc;

   flags->flags = 0;
   
   if (!optstr)
      return 0;

   s = optstr;
   while (*s) {
      curarg = *s++ & 0x7f;   /* the array (in app.h) has 128 entries */
      ast_set_flag64(flags, options[curarg].flag);
      argloc = options[curarg].arg_index;
      if (*s == '(') {
         /* Has argument */
         arg = ++s;
         if ((s = strchr(s, ')'))) {
            if (argloc)
               args[argloc - 1] = arg;
            *s++ = '\0';
         } else {
            ast_log(LOG_WARNING, "Missing closing parenthesis for argument '%c' in string '%s'\n", curarg, arg);
            res = -1;
            break;
         }
      } else if (argloc) {
         args[argloc - 1] = NULL;
      }
   }

   return res;
}

unsigned int ast_app_separate_args	(	char *	buf,
		char	delim,
		char **	array,
		int	arraylen
	)

Definition at line 1090 of file app.c.

References __ast_app_separate_args().

{
   return __ast_app_separate_args(buf, delim, 1, array, arraylen);
}

int ast_control_streamfile	(	struct ast_channel *	chan,
		const char *	file,
		const char *	fwd,
		const char *	rev,
		const char *	stop,
		const char *	pause,
		const char *	restart,
		int	skipms,
		long *	offsetms
	)

Stream a file with fast forward, pause, reverse, restart.

Parameters:

	chan
	file	filename
	fwd,rev,stop,pause,restart,skipms,offsetms

Before calling this function, set this to be the number of ms to start from the beginning of the file. When the function returns, it will be the number of ms from the beginning where the playback stopped. Pass NULL if you don't care.

Definition at line 415 of file app.c.

References ast_channel::_state, ast_answer(), ast_debug, ast_seekstream(), AST_STATE_UP, ast_stopstream(), ast_streamfile(), ast_tellstream(), ast_verb, ast_waitfordigit(), ast_waitstream_fr(), ast_channel::language, and ast_channel::stream.

Referenced by controlplayback_exec(), handle_controlstreamfile(), and wait_file().

{
   char *breaks = NULL;
   char *end = NULL;
   int blen = 2;
   int res;
   long pause_restart_point = 0;
   long offset = 0;

   if (offsetms) 
      offset = *offsetms * 8; /* XXX Assumes 8kHz */

   if (stop)
      blen += strlen(stop);
   if (pause)
      blen += strlen(pause);
   if (restart)
      blen += strlen(restart);

   if (blen > 2) {
      breaks = alloca(blen + 1);
      breaks[0] = '\0';
      if (stop)
         strcat(breaks, stop);
      if (pause)
         strcat(breaks, pause);
      if (restart)
         strcat(breaks, restart);
   }
   if (chan->_state != AST_STATE_UP)
      res = ast_answer(chan);

   if (file) {
      if ((end = strchr(file, ':'))) {
         if (!strcasecmp(end, ":end")) {
            *end = '\0';
            end++;
         }
      }
   }

   for (;;) {
      ast_stopstream(chan);
      res = ast_streamfile(chan, file, chan->language);
      if (!res) {
         if (pause_restart_point) {
            ast_seekstream(chan->stream, pause_restart_point, SEEK_SET);
            pause_restart_point = 0;
         }
         else if (end || offset < 0) {
            if (offset == -8) 
               offset = 0;
            ast_verb(3, "ControlPlayback seek to offset %ld from end\n", offset);

            ast_seekstream(chan->stream, offset, SEEK_END);
            end = NULL;
            offset = 0;
         } else if (offset) {
            ast_verb(3, "ControlPlayback seek to offset %ld\n", offset);
            ast_seekstream(chan->stream, offset, SEEK_SET);
            offset = 0;
         };
         res = ast_waitstream_fr(chan, breaks, fwd, rev, skipms);
      }

      if (res < 1)
         break;

      /* We go at next loop if we got the restart char */
      if (restart && strchr(restart, res)) {
         ast_debug(1, "we'll restart the stream here at next loop\n");
         pause_restart_point = 0;
         continue;
      }

      if (pause && strchr(pause, res)) {
         pause_restart_point = ast_tellstream(chan->stream);
         for (;;) {
            ast_stopstream(chan);
            res = ast_waitfordigit(chan, 1000);
            if (!res)
               continue;
            else if (res == -1 || strchr(pause, res) || (stop && strchr(stop, res)))
               break;
         }
         if (res == *pause) {
            res = 0;
            continue;
         }
      }

      if (res == -1)
         break;

      /* if we get one of our stop chars, return it to the calling function */
      if (stop && strchr(stop, res))
         break;
   }

   if (pause_restart_point) {
      offset = pause_restart_point;
   } else {
      if (chan->stream) {
         offset = ast_tellstream(chan->stream);
      } else {
         offset = -8;  /* indicate end of file */
      }
   }

   if (offsetms) 
      *offsetms = offset / 8; /* samples --> ms ... XXX Assumes 8 kHz */

   /* If we are returning a digit cast it as char */
   if (res > 0 || chan->stream)
      res = (char)res;

   ast_stopstream(chan);

   return res;
}

int ast_dtmf_stream	(	struct ast_channel *	chan,
		struct ast_channel *	peer,
		const char *	digits,
		int	between,
		unsigned int	duration
	)

Send DTMF to a channel.

Parameters:

	chan	The channel that will receive the DTMF frames
	peer	(optional) Peer channel that will be autoserviced while the primary channel is receiving DTMF
	digits	This is a string of characters representing the DTMF digits to be sent to the channel. Valid characters are "0123456789*#abcdABCD". Note: You can pass arguments 'f' or 'F', if you want to Flash the channel (if supported by the channel), or 'w' to add a 500 millisecond pause to the DTMF sequence.
	between	This is the number of milliseconds to wait in between each DTMF digit. If zero milliseconds is specified, then the default value of 100 will be used.
	duration	This is the duration that each DTMF digit should have.

Definition at line 248 of file app.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), AST_CONTROL_FLASH, ast_indicate(), ast_log(), ast_opt_transmit_silence, ast_safe_sleep(), ast_senddigit(), ast_waitfor(), and LOG_WARNING.

Referenced by ast_bridge_call(), dial_exec_full(), handle_cli_misdn_send_digit(), senddtmf_exec(), testclient_exec(), and testserver_exec().

{
   const char *ptr;
   int res = 0;
   struct ast_silence_generator *silgen = NULL;

   if (!between)
      between = 100;

   if (peer)
      res = ast_autoservice_start(peer);

   if (!res)
      res = ast_waitfor(chan, 100);

   /* ast_waitfor will return the number of remaining ms on success */
   if (res < 0) {
      if (peer) {
         ast_autoservice_stop(peer);
      }
      return res;
   }

   if (ast_opt_transmit_silence) {
      silgen = ast_channel_start_silence_generator(chan);
   }

   for (ptr = digits; *ptr; ptr++) {
      if (*ptr == 'w') {
         /* 'w' -- wait half a second */
         if ((res = ast_safe_sleep(chan, 500)))
            break;
      } else if (strchr("0123456789*#abcdfABCDF", *ptr)) {
         /* Character represents valid DTMF */
         if (*ptr == 'f' || *ptr == 'F') {
            /* ignore return values if not supported by channel */
            ast_indicate(chan, AST_CONTROL_FLASH);
         } else
            ast_senddigit(chan, *ptr, duration);
         /* pause between digits */
         if ((res = ast_safe_sleep(chan, between)))
            break;
      } else
         ast_log(LOG_WARNING, "Illegal DTMF character '%c' in string. (0-9*#aAbBcCdD allowed)\n", *ptr);
   }

   if (peer) {
      /* Stop autoservice on the peer channel, but don't overwrite any error condition 
         that has occurred previously while acting on the primary channel */
      if (ast_autoservice_stop(peer) && !res)
         res = -1;
   }

   if (silgen) {
      ast_channel_stop_silence_generator(chan, silgen);
   }

   return res;
}

int ast_get_encoded_char	(	const char *	stream,
		char *	result,
		size_t *	consumed
	)

Decode an encoded control or extended ASCII character.

Definition at line 1734 of file app.c.

References ast_debug, ast_log(), ast_strlen_zero(), and LOG_ERROR.

Referenced by ast_get_encoded_str(), ast_str_get_encoded_str(), cut_internal(), filter(), and function_fieldqty().

{
   int i;
   *consumed = 1;
   *result = 0;
   if (ast_strlen_zero(stream)) {
      *consumed = 0;
      return -1;
   }

   if (*stream == '\\') {
      *consumed = 2;
      switch (*(stream + 1)) {
      case 'n':
         *result = '\n';
         break;
      case 'r':
         *result = '\r';
         break;
      case 't':
         *result = '\t';
         break;
      case 'x':
         /* Hexadecimal */
         if (strchr("0123456789ABCDEFabcdef", *(stream + 2)) && *(stream + 2) != '\0') {
            *consumed = 3;
            if (*(stream + 2) <= '9')
               *result = *(stream + 2) - '0';
            else if (*(stream + 2) <= 'F')
               *result = *(stream + 2) - 'A' + 10;
            else
               *result = *(stream + 2) - 'a' + 10;
         } else {
            ast_log(LOG_ERROR, "Illegal character '%c' in hexadecimal string\n", *(stream + 2));
            return -1;
         }

         if (strchr("0123456789ABCDEFabcdef", *(stream + 3)) && *(stream + 3) != '\0') {
            *consumed = 4;
            *result <<= 4;
            if (*(stream + 3) <= '9')
               *result += *(stream + 3) - '0';
            else if (*(stream + 3) <= 'F')
               *result += *(stream + 3) - 'A' + 10;
            else
               *result += *(stream + 3) - 'a' + 10;
         }
         break;
      case '0':
         /* Octal */
         *consumed = 2;
         for (i = 2; ; i++) {
            if (strchr("01234567", *(stream + i)) && *(stream + i) != '\0') {
               (*consumed)++;
               ast_debug(5, "result was %d, ", *result);
               *result <<= 3;
               *result += *(stream + i) - '0';
               ast_debug(5, "is now %d\n", *result);
            } else
               break;
         }
         break;
      default:
         *result = *(stream + 1);
      }
   } else {
      *result = *stream;
      *consumed = 1;
   }
   return 0;
}

int ast_get_encoded_str	(	const char *	stream,
		char *	result,
		size_t	result_size
	)

Decode a string which may contain multiple encoded control or extended ASCII characters.

Definition at line 1806 of file app.c.

References ast_get_encoded_char().

Referenced by sip_addheader().

{
   char *cur = result;
   size_t consumed;

   while (cur < result + result_size - 1 && !ast_get_encoded_char(stream, cur, &consumed)) {
      cur++;
      stream += consumed;
   }
   *cur = '\0';
   return 0;
}

void ast_install_vm_functions	(	int(*)(const char *mailbox, const char *folder)	has_voicemail_func,
		int(*)(const char *mailbox, int *newmsgs, int *oldmsgs)	inboxcount_func,
		int(*)(const char *context, const char *mailbox, const char *folder)	messagecount_func
	)

Definition at line 186 of file app.c.

References ast_has_voicemail_func, ast_inboxcount_func, and ast_messagecount_func.

Referenced by load_module().

{
   ast_has_voicemail_func = has_voicemail_func;
   ast_inboxcount_func = inboxcount_func;
   ast_messagecount_func = messagecount_func;
}

int ast_ivr_menu_run	(	struct ast_channel *	c,
		struct ast_ivr_menu *	menu,
		void *	cbdata
	)

Runs an IVR menu.

Returns:

returns 0 on successful completion, -1 on hangup, or -2 on user error in menu

Definition at line 1606 of file app.c.

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

{
   int res = ast_ivr_menu_run_internal(chan, menu, cbdata);
   /* Hide internal coding */
   return res > 0 ? 0 : res;
}

static int ast_ivr_menu_run_internal	(	struct ast_channel *	chan,
		struct ast_ivr_menu *	menu,
		void *	cbdata
	)			[static]

Definition at line 1526 of file app.c.

References ast_debug, AST_DIGIT_ANY, ast_log(), AST_MAX_EXTENSION, exten, ivr_dispatch(), LOG_WARNING, maxretries, ast_ivr_option::option, option_exists(), ast_ivr_menu::options, read_newoption(), RES_EXIT, RES_REPEAT, RES_RESTART, RES_UPONE, and ast_ivr_menu::title.

Referenced by ast_ivr_menu_run(), and ivr_dispatch().

{
   /* Execute an IVR menu structure */
   int res = 0;
   int pos = 0;
   int retries = 0;
   char exten[AST_MAX_EXTENSION] = "s";
   if (option_exists(menu, "s") < 0) {
      strcpy(exten, "g");
      if (option_exists(menu, "g") < 0) {
         ast_log(LOG_WARNING, "No 's' nor 'g' extension in menu '%s'!\n", menu->title);
         return -1;
      }
   }
   while (!res) {
      while (menu->options[pos].option) {
         if (!strcasecmp(menu->options[pos].option, exten)) {
            res = ivr_dispatch(chan, menu->options + pos, exten, cbdata);
            ast_debug(1, "IVR Dispatch of '%s' (pos %d) yields %d\n", exten, pos, res);
            if (res < 0)
               break;
            else if (res & RES_UPONE)
               return 0;
            else if (res & RES_EXIT)
               return res;
            else if (res & RES_REPEAT) {
               int maxretries = res & 0xffff;
               if ((res & RES_RESTART) == RES_RESTART) {
                  retries = 0;
               } else
                  retries++;
               if (!maxretries)
                  maxretries = 3;
               if ((maxretries > 0) && (retries >= maxretries)) {
                  ast_debug(1, "Max retries %d exceeded\n", maxretries);
                  return -2;
               } else {
                  if (option_exists(menu, "g") > -1) 
                     strcpy(exten, "g");
                  else if (option_exists(menu, "s") > -1)
                     strcpy(exten, "s");
               }
               pos = 0;
               continue;
            } else if (res && strchr(AST_DIGIT_ANY, res)) {
               ast_debug(1, "Got start of extension, %c\n", res);
               exten[1] = '\0';
               exten[0] = res;
               if ((res = read_newoption(chan, menu, exten, sizeof(exten))))
                  break;
               if (option_exists(menu, exten) < 0) {
                  if (option_exists(menu, "i")) {
                     ast_debug(1, "Invalid extension entered, going to 'i'!\n");
                     strcpy(exten, "i");
                     pos = 0;
                     continue;
                  } else {
                     ast_debug(1, "Aborting on invalid entry, with no 'i' option!\n");
                     res = -2;
                     break;
                  }
               } else {
                  ast_debug(1, "New existing extension: %s\n", exten);
                  pos = 0;
                  continue;
               }
            }
         }
         pos++;
      }
      ast_debug(1, "Stopping option '%s', res is %d\n", exten, res);
      pos = 0;
      if (!strcasecmp(exten, "s"))
         strcpy(exten, "g");
      else
         break;
   }
   return res;
}

int ast_linear_stream	(	struct ast_channel *	chan,
		const char *	filename,
		int	fd,
		int	allowoverride
	)

Stream a filename (or file descriptor) as a generator.

Definition at line 387 of file app.c.

References linear_state::allowoverride, ast_activate_generator(), ast_calloc, ast_config_AST_DATA_DIR, ast_copy_string(), ast_log(), ast_strlen_zero(), linear_state::autoclose, errno, linear_state::fd, and LOG_WARNING.

{
   struct linear_state *lin;
   char tmpf[256];
   int res = -1;
   int autoclose = 0;
   if (fd < 0) {
      if (ast_strlen_zero(filename))
         return -1;
      autoclose = 1;
      if (filename[0] == '/') 
         ast_copy_string(tmpf, filename, sizeof(tmpf));
      else
         snprintf(tmpf, sizeof(tmpf), "%s/%s/%s", ast_config_AST_DATA_DIR, "sounds", filename);
      if ((fd = open(tmpf, O_RDONLY)) < 0) {
         ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", tmpf, strerror(errno));
         return -1;
      }
   }
   if ((lin = ast_calloc(1, sizeof(*lin)))) {
      lin->fd = fd;
      lin->allowoverride = allowoverride;
      lin->autoclose = autoclose;
      res = ast_activate_generator(chan, &linearstream, lin);
   }
   return res;
}

enum AST_LOCK_RESULT ast_lock_path

(

const char *

path

)

Lock a filesystem path.

Parameters:

path

the path to be locked

Returns:

one of AST_LOCK_RESULT values

Definition at line 1287 of file app.c.

References AST_LOCK_FAILURE, ast_lock_path_flock(), ast_lock_path_lockfile(), AST_LOCK_TYPE_FLOCK, and AST_LOCK_TYPE_LOCKFILE.

Referenced by vm_lock_path().

{
   enum AST_LOCK_RESULT r = AST_LOCK_FAILURE;

   switch (ast_lock_type) {
   case AST_LOCK_TYPE_LOCKFILE:
      r = ast_lock_path_lockfile(path);
      break;
   case AST_LOCK_TYPE_FLOCK:
      r = ast_lock_path_flock(path);
      break;
   }

   return r;
}

static enum AST_LOCK_RESULT ast_lock_path_flock

(

const char *

path

)

[static]

Definition at line 1166 of file app.c.

References ast_calloc, ast_debug, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, AST_LOCK_FAILURE, AST_LOCK_PATH_NOT_FOUND, AST_LOCK_SUCCESS, AST_LOCK_TIMEOUT, ast_log(), errno, path_lock::fd, path_lock::le, LOG_WARNING, path_lock::path, path_lock_destroy(), and strdup.

Referenced by ast_lock_path().

{
   char *fs;
   int res;
   int fd;
   time_t start;
   struct path_lock *pl;
   struct stat st, ost;

   fs = alloca(strlen(path) + 20);

   snprintf(fs, strlen(path) + 19, "%s/lock", path);
   if (lstat(fs, &st) == 0) {
      if ((st.st_mode & S_IFMT) == S_IFLNK) {
         ast_log(LOG_WARNING, "Unable to create lock file "
               "'%s': it's already a symbolic link\n",
               fs);
         return AST_LOCK_FAILURE;
      }
      if (st.st_nlink > 1) {
         ast_log(LOG_WARNING, "Unable to create lock file "
               "'%s': %u hard links exist\n",
               fs, (unsigned int) st.st_nlink);
         return AST_LOCK_FAILURE;
      }
   }
   fd = open(fs, O_WRONLY | O_CREAT, 0600);
   if (fd < 0) {
      ast_log(LOG_WARNING, "Unable to create lock file '%s': %s\n",
            fs, strerror(errno));
      return AST_LOCK_PATH_NOT_FOUND;
   }
   pl = ast_calloc(1, sizeof(*pl));
   if (!pl) {
      /* We don't unlink the lock file here, on the possibility that
       * someone else created it - better to leave a little mess
       * than create a big one by destroying someone else's lock
       * and causing something to be corrupted.
       */
      close(fd);
      return AST_LOCK_FAILURE;
   }
   pl->fd = fd;
   pl->path = strdup(path);

   time(&start);
   while ((
      #ifdef SOLARIS
      (res = fcntl(pl->fd, F_SETLK, fcntl(pl->fd, F_GETFL) | O_NONBLOCK)) < 0) &&
      #else
      (res = flock(pl->fd, LOCK_EX | LOCK_NB)) < 0) &&
      #endif
         (errno == EWOULDBLOCK) && 
         (time(NULL) - start < 5))
      usleep(1000);
   if (res) {
      ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n",
            path, strerror(errno));
      /* No unlinking of lock done, since we tried and failed to
       * flock() it.
       */
      path_lock_destroy(pl);
      return AST_LOCK_TIMEOUT;
   }

   /* Check for the race where the file is recreated or deleted out from
    * underneath us.
    */
   if (lstat(fs, &st) != 0 && fstat(pl->fd, &ost) != 0 &&
         st.st_dev != ost.st_dev &&
         st.st_ino != ost.st_ino) {
      ast_log(LOG_WARNING, "Unable to create lock file '%s': "
            "file changed underneath us\n", fs);
      path_lock_destroy(pl);
      return AST_LOCK_FAILURE;
   }

   /* Success: file created, flocked, and is the one we started with */
   AST_LIST_LOCK(&path_lock_list);
   AST_LIST_INSERT_TAIL(&path_lock_list, pl, le);
   AST_LIST_UNLOCK(&path_lock_list);

   ast_debug(1, "Locked path '%s'\n", path);

   return AST_LOCK_SUCCESS;
}

static enum AST_LOCK_RESULT ast_lock_path_lockfile

(

const char *

path

)

[static]

Definition at line 1095 of file app.c.

References ast_debug, AST_FILE_MODE, AST_LOCK_PATH_NOT_FOUND, AST_LOCK_SUCCESS, AST_LOCK_TIMEOUT, ast_log(), ast_random(), errno, LOG_ERROR, LOG_WARNING, and s.

Referenced by ast_lock_path().

{
   char *s;
   char *fs;
   int res;
   int fd;
   int lp = strlen(path);
   time_t start;

   s = alloca(lp + 10); 
   fs = alloca(lp + 20);

   snprintf(fs, strlen(path) + 19, "%s/.lock-%08lx", path, ast_random());
   fd = open(fs, O_WRONLY | O_CREAT | O_EXCL, AST_FILE_MODE);
   if (fd < 0) {
      ast_log(LOG_ERROR, "Unable to create lock file '%s': %s\n", path, strerror(errno));
      return AST_LOCK_PATH_NOT_FOUND;
   }
   close(fd);

   snprintf(s, strlen(path) + 9, "%s/.lock", path);
   start = time(NULL);
   while (((res = link(fs, s)) < 0) && (errno == EEXIST) && (time(NULL) - start < 5))
      usleep(1);

   unlink(fs);

   if (res) {
      ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n", path, strerror(errno));
      return AST_LOCK_TIMEOUT;
   } else {
      ast_debug(1, "Locked path '%s'\n", path);
      return AST_LOCK_SUCCESS;
   }
}

int ast_play_and_prepend	(	struct ast_channel *	chan,
		char *	playfile,
		char *	recordfile,
		int	maxtime,
		char *	fmt,
		int *	duration,
		int	beep,
		int	silencethreshold,
		int	maxsilence
	)

Record a message and prepend the message to the given record file after playing the optional playfile (or a beep), storing the duration in 'duration' and with a maximum permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults.

Definition at line 856 of file app.c.

References __ast_play_and_record().

Referenced by vm_forwardoptions().

{
   return __ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, beep, silencethreshold, maxsilence, NULL, 1, default_acceptdtmf, default_canceldtmf);
}

int ast_play_and_record	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime,
		const char *	fmt,
		int *	duration,
		int	silencethreshold,
		int	maxsilence,
		const char *	path
	)

Record a file for a max amount of time (in seconds), in a given list of formats separated by '|', outputting the duration of the recording, and with a maximum
permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults. calls ast_unlock_path() on 'path' if passed.

Definition at line 851 of file app.c.

References __ast_play_and_record().

Referenced by app_exec(), ast_record_review(), conf_run(), and setup_privacy_args().

{
   return __ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, 0, silencethreshold, maxsilence, path, 0, default_acceptdtmf, default_canceldtmf);
}

int ast_play_and_record_full	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime,
		const char *	fmt,
		int *	duration,
		int	silencethreshold,
		int	maxsilence,
		const char *	path,
		const char *	acceptdtmf,
		const char *	canceldtmf
	)

Definition at line 846 of file app.c.

References __ast_play_and_record(), and S_OR.

Referenced by play_record_review().

{
   return __ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, 0, silencethreshold, maxsilence, path, 0, S_OR(acceptdtmf, default_acceptdtmf), S_OR(canceldtmf, default_canceldtmf));
}

int ast_play_and_wait	(	struct ast_channel *	chan,
		const char *	fn
	)

Play a stream and wait for a digit, returning the digit that was pressed.

Definition at line 539 of file app.c.

References AST_DIGIT_ANY, ast_stopstream(), ast_streamfile(), ast_waitstream(), and ast_channel::language.

Referenced by __ast_play_and_record(), advanced_options(), ast_record_review(), ast_say_counted_adjective(), ast_say_counted_noun(), dialout(), forward_message(), get_folder(), get_folder2(), leave_voicemail(), minivm_greet_exec(), play_message_category(), play_message_duration(), play_record_review(), vm_authenticate(), vm_browse_messages_en(), vm_browse_messages_es(), vm_browse_messages_gr(), vm_browse_messages_it(), vm_browse_messages_pt(), vm_browse_messages_zh(), vm_execmain(), vm_forwardoptions(), vm_instructions_en(), vm_instructions_zh(), vm_intro(), vm_intro_cz(), vm_intro_de(), vm_intro_en(), vm_intro_es(), vm_intro_fr(), vm_intro_gr(), vm_intro_it(), vm_intro_multilang(), vm_intro_nl(), vm_intro_no(), vm_intro_pl(), vm_intro_pt(), vm_intro_pt_BR(), vm_intro_se(), vm_intro_zh(), vm_newuser(), vm_options(), vm_play_folder_name(), vm_play_folder_name_gr(), vm_play_folder_name_pl(), vm_play_folder_name_ua(), vm_tempgreeting(), and vmauthenticate().

{
   int d = 0;

   if ((d = ast_streamfile(chan, fn, chan->language)))
      return d;

   d = ast_waitstream(chan, AST_DIGIT_ANY);

   ast_stopstream(chan);

   return d;
}

char* ast_read_textfile

(

const char *

filename

)

Read a file into asterisk.

Definition at line 1613 of file app.c.

References ast_free, ast_log(), ast_malloc, errno, path_lock::fd, and LOG_WARNING.

Referenced by file_read(), and readfile_exec().

{
   int fd, count = 0, res;
   char *output = NULL;
   struct stat filesize;

   if (stat(filename, &filesize) == -1) {
      ast_log(LOG_WARNING, "Error can't stat %s\n", filename);
      return NULL;
   }

   count = filesize.st_size + 1;

   if ((fd = open(filename, O_RDONLY)) < 0) {
      ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", filename, strerror(errno));
      return NULL;
   }

   if ((output = ast_malloc(count))) {
      res = read(fd, output, count - 1);
      if (res == count - 1) {
         output[res] = '\0';
      } else {
         ast_log(LOG_WARNING, "Short read of %s (%d of %d): %s\n", filename, res, count - 1, strerror(errno));
         ast_free(output);
         output = NULL;
      }
   }

   close(fd);

   return output;
}

int ast_record_review	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime,
		const char *	fmt,
		int *	duration,
		const char *	path
	)

Allow to record message and have a review option.

Definition at line 1319 of file app.c.

References AST_DIGIT_ANY, ast_log(), ast_play_and_record(), ast_play_and_wait(), ast_stream_and_wait(), ast_verb, ast_waitfordigit(), LOG_WARNING, maxsilence, and silencethreshold.

Referenced by conf_run().

{
   int silencethreshold = 128; 
   int maxsilence = 0;
   int res = 0;
   int cmd = 0;
   int max_attempts = 3;
   int attempts = 0;
   int recorded = 0;
   int message_exists = 0;
   /* Note that urgent and private are for flagging messages as such in the future */

   /* barf if no pointer passed to store duration in */
   if (!duration) {
      ast_log(LOG_WARNING, "Error ast_record_review called without duration pointer\n");
      return -1;
   }

   cmd = '3';   /* Want to start by recording */

   while ((cmd >= 0) && (cmd != 't')) {
      switch (cmd) {
      case '1':
         if (!message_exists) {
            /* In this case, 1 is to record a message */
            cmd = '3';
            break;
         } else {
            ast_stream_and_wait(chan, "vm-msgsaved", "");
            cmd = 't';
            return res;
         }
      case '2':
         /* Review */
         ast_verb(3, "Reviewing the recording\n");
         cmd = ast_stream_and_wait(chan, recordfile, AST_DIGIT_ANY);
         break;
      case '3':
         message_exists = 0;
         /* Record */
         if (recorded == 1)
            ast_verb(3, "Re-recording\n");
         else  
            ast_verb(3, "Recording\n");
         recorded = 1;
         cmd = ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, silencethreshold, maxsilence, path);
         if (cmd == -1) {
         /* User has hung up, no options to give */
            return cmd;
         }
         if (cmd == '0') {
            break;
         } else if (cmd == '*') {
            break;
         } 
         else {
            /* If all is well, a message exists */
            message_exists = 1;
            cmd = 0;
         }
         break;
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
      case '*':
      case '#':
         cmd = ast_play_and_wait(chan, "vm-sorry");
         break;
      default:
         if (message_exists) {
            cmd = ast_play_and_wait(chan, "vm-review");
         }
         else {
            cmd = ast_play_and_wait(chan, "vm-torerecord");
            if (!cmd)
               cmd = ast_waitfordigit(chan, 600);
         }
         
         if (!cmd)
            cmd = ast_waitfordigit(chan, 6000);
         if (!cmd) {
            attempts++;
         }
         if (attempts > max_attempts) {
            cmd = 't';
         }
      }
   }
   if (cmd == 't')
      cmd = 0;
   return cmd;
}

void ast_set_lock_type

(

enum AST_LOCK_TYPE

type

)

Set the type of locks used by ast_lock_path().

Parameters:

type

the locking type to use

Definition at line 1282 of file app.c.

Referenced by ast_readconfig().

{
   ast_lock_type = type;
}

int ast_str_get_encoded_str	(	struct ast_str **	str,
		int	maxlen,
		const char *	stream
	)

Decode a stream of encoded control or extended ASCII characters.

Definition at line 1819 of file app.c.

References ast_get_encoded_char(), ast_str_buffer, ast_str_make_space(), ast_str_set(), ast_str_size, ast_str_update, buf, and path_lock::next.

Referenced by system_exec_helper().

{
   char next, *buf;
   size_t offset = 0;
   size_t consumed;

   if (strchr(stream, '\\')) {
      while (!ast_get_encoded_char(stream, &next, &consumed)) {
         if (offset + 2 > ast_str_size(*str) && maxlen > -1) {
            ast_str_make_space(str, maxlen > 0 ? maxlen : (ast_str_size(*str) + 48) * 2 - 48);
         }
         if (offset + 2 > ast_str_size(*str)) {
            break;
         }
         buf = ast_str_buffer(*str);
         buf[offset++] = next;
         stream += consumed;
      }
      buf = ast_str_buffer(*str);
      buf[offset++] = '\0';
      ast_str_update(*str);
   } else {
      ast_str_set(str, maxlen, "%s", stream);
   }
   return 0;
}

void ast_uninstall_vm_functions

(

void

)

Definition at line 195 of file app.c.

References ast_has_voicemail_func, ast_inboxcount_func, and ast_messagecount_func.

Referenced by unload_module().

{
   ast_has_voicemail_func = NULL;
   ast_inboxcount_func = NULL;
   ast_messagecount_func = NULL;
}

int ast_unlock_path

(

const char *

path

)

Unlock a path.

Definition at line 1303 of file app.c.

References AST_LOCK_TYPE_FLOCK, AST_LOCK_TYPE_LOCKFILE, ast_unlock_path_flock(), and ast_unlock_path_lockfile().

Referenced by __ast_play_and_record(), access_counter_file(), close_mailbox(), copy_message(), count_messages(), leave_voicemail(), open_mailbox(), resequence_mailbox(), and save_to_folder().

{
   int r = 0;

   switch (ast_lock_type) {
   case AST_LOCK_TYPE_LOCKFILE:
      r = ast_unlock_path_lockfile(path);
      break;
   case AST_LOCK_TYPE_FLOCK:
      r = ast_unlock_path_flock(path);
      break;
   }

   return r;
}

static int ast_unlock_path_flock

(

const char *

path

)

[static]

Definition at line 1253 of file app.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_log(), path_lock::le, LOG_DEBUG, path_lock::path, path_lock_destroy(), and s.

Referenced by ast_unlock_path().

{
   char *s;
   struct path_lock *p;

   s = alloca(strlen(path) + 20);

   AST_LIST_LOCK(&path_lock_list);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&path_lock_list, p, le) {
      if (!strcmp(p->path, path)) {
         AST_LIST_REMOVE_CURRENT(le);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END;
   AST_LIST_UNLOCK(&path_lock_list);

   if (p) {
      snprintf(s, strlen(path) + 19, "%s/lock", path);
      unlink(s);
      path_lock_destroy(p);
      ast_log(LOG_DEBUG, "Unlocked path '%s'\n", path);
   } else
      ast_log(LOG_DEBUG, "Failed to unlock path '%s': "
            "lock not found\n", path);

   return 0;
}

static int ast_unlock_path_lockfile

(

const char *

path

)

[static]

Definition at line 1131 of file app.c.

References ast_debug, ast_log(), errno, LOG_ERROR, and s.

Referenced by ast_unlock_path().

{
   char *s;
   int res;

   s = alloca(strlen(path) + 10);

   snprintf(s, strlen(path) + 9, "%s/%s", path, ".lock");

   if ((res = unlink(s)))
      ast_log(LOG_ERROR, "Could not unlock path '%s': %s\n", path, strerror(errno));
   else {
      ast_debug(1, "Unlocked path '%s'\n", path);
   }

   return res;
}

static int ivr_dispatch	(	struct ast_channel *	chan,
		struct ast_ivr_option *	option,
		char *	exten,
		void *	cbdata
	)			[static]

Definition at line 1422 of file app.c.

References ast_ivr_option::action, ast_ivr_option::adata, AST_ACTION_BACKGROUND, AST_ACTION_BACKLIST, AST_ACTION_CALLBACK, AST_ACTION_EXIT, AST_ACTION_MENU, AST_ACTION_NOOP, AST_ACTION_PLAYBACK, AST_ACTION_PLAYLIST, AST_ACTION_REPEAT, AST_ACTION_RESTART, AST_ACTION_TRANSFER, AST_ACTION_UPONE, AST_ACTION_WAITOPTION, AST_DIGIT_ANY, ast_ivr_menu_run_internal(), ast_log(), ast_parseable_goto(), ast_stopstream(), ast_strdupa, ast_stream_and_wait(), ast_waitfordigit(), LOG_NOTICE, ast_channel::pbx, RES_EXIT, RES_REPEAT, RES_RESTART, RES_UPONE, ast_pbx::rtimeout, and strsep().

Referenced by ast_ivr_menu_run_internal().

{
   int res;
   int (*ivr_func)(struct ast_channel *, void *);
   char *c;
   char *n;
   
   switch (option->action) {
   case AST_ACTION_UPONE:
      return RES_UPONE;
   case AST_ACTION_EXIT:
      return RES_EXIT | (((unsigned long)(option->adata)) & 0xffff);
   case AST_ACTION_REPEAT:
      return RES_REPEAT | (((unsigned long)(option->adata)) & 0xffff);
   case AST_ACTION_RESTART:
      return RES_RESTART ;
   case AST_ACTION_NOOP:
      return 0;
   case AST_ACTION_BACKGROUND:
      res = ast_stream_and_wait(chan, (char *)option->adata, AST_DIGIT_ANY);
      if (res < 0) {
         ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
         res = 0;
      }
      return res;
   case AST_ACTION_PLAYBACK:
      res = ast_stream_and_wait(chan, (char *)option->adata, "");
      if (res < 0) {
         ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
         res = 0;
      }
      return res;
   case AST_ACTION_MENU:
      res = ast_ivr_menu_run_internal(chan, (struct ast_ivr_menu *)option->adata, cbdata);
      /* Do not pass entry errors back up, treat as though it was an "UPONE" */
      if (res == -2)
         res = 0;
      return res;
   case AST_ACTION_WAITOPTION:
      res = ast_waitfordigit(chan, 1000 * (chan->pbx ? chan->pbx->rtimeout : 10));
      if (!res)
         return 't';
      return res;
   case AST_ACTION_CALLBACK:
      ivr_func = option->adata;
      res = ivr_func(chan, cbdata);
      return res;
   case AST_ACTION_TRANSFER:
      res = ast_parseable_goto(chan, option->adata);
      return 0;
   case AST_ACTION_PLAYLIST:
   case AST_ACTION_BACKLIST:
      res = 0;
      c = ast_strdupa(option->adata);
      while ((n = strsep(&c, ";"))) {
         if ((res = ast_stream_and_wait(chan, n,
               (option->action == AST_ACTION_BACKLIST) ? AST_DIGIT_ANY : "")))
            break;
      }
      ast_stopstream(chan);
      return res;
   default:
      ast_log(LOG_NOTICE, "Unknown dispatch function %d, ignoring!\n", option->action);
      return 0;
   };
   return -1;
}

static void* linear_alloc	(	struct ast_channel *	chan,
		void *	params
	)			[static]

Definition at line 356 of file app.c.

References linear_state::allowoverride, ast_clear_flag, AST_FLAG_WRITE_INT, AST_FORMAT_SLINEAR, ast_free, ast_log(), ast_set_flag, ast_set_write_format(), LOG_WARNING, ast_channel::name, linear_state::origwfmt, and ast_channel::writeformat.

{
   struct linear_state *ls = params;

   if (!params)
      return NULL;

   /* In this case, params is already malloc'd */
   if (ls->allowoverride)
      ast_set_flag(chan, AST_FLAG_WRITE_INT);
   else
      ast_clear_flag(chan, AST_FLAG_WRITE_INT);

   ls->origwfmt = chan->writeformat;

   if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
      ast_log(LOG_WARNING, "Unable to set '%s' to linear format (write)\n", chan->name);
      ast_free(ls);
      ls = params = NULL;
   }

   return params;
}

static int linear_generator	(	struct ast_channel *	chan,
		void *	data,
		int	len,
		int	samples
	)			[static]

Definition at line 328 of file app.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_write(), buf, ast_frame::datalen, linear_state::fd, ast_frame::frametype, LOG_WARNING, and ast_frame::samples.

{
   short buf[2048 + AST_FRIENDLY_OFFSET / 2];
   struct linear_state *ls = data;
   struct ast_frame f = {
      .frametype = AST_FRAME_VOICE,
      .subclass = AST_FORMAT_SLINEAR,
      .data = buf + AST_FRIENDLY_OFFSET / 2,
      .offset = AST_FRIENDLY_OFFSET,
   };
   int res;

   len = samples * 2;
   if (len > sizeof(buf) - AST_FRIENDLY_OFFSET) {
      ast_log(LOG_WARNING, "Can't generate %d bytes of data!\n" , len);
      len = sizeof(buf) - AST_FRIENDLY_OFFSET;
   }
   res = read(ls->fd, buf + AST_FRIENDLY_OFFSET/2, len);
   if (res > 0) {
      f.datalen = res;
      f.samples = res / 2;
      ast_write(chan, &f);
      if (res == len)
         return 0;
   }
   return -1;
}

static void linear_release	(	struct ast_channel *	chan,
		void *	params
	)			[static]

Definition at line 315 of file app.c.

References ast_free, ast_log(), ast_set_write_format(), linear_state::autoclose, linear_state::fd, LOG_WARNING, ast_channel::name, and linear_state::origwfmt.

{
   struct linear_state *ls = params;
   
   if (ls->origwfmt && ast_set_write_format(chan, ls->origwfmt))
      ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, ls->origwfmt);

   if (ls->autoclose)
      close(ls->fd);

   ast_free(params);
}

static int option_exists	(	struct ast_ivr_menu *	menu,
		char *	option
	)			[static]

Definition at line 1490 of file app.c.

References ast_ivr_option::option, and ast_ivr_menu::options.

Referenced by ast_ivr_menu_run_internal().

{
   int x;
   for (x = 0; menu->options[x].option; x++)
      if (!strcasecmp(menu->options[x].option, option))
         return x;
   return -1;
}

static int option_matchmore	(	struct ast_ivr_menu *	menu,
		char *	option
	)			[static]

Definition at line 1499 of file app.c.

References ast_ivr_option::option, and ast_ivr_menu::options.

Referenced by read_newoption().

{
   int x;
   for (x = 0; menu->options[x].option; x++)
      if ((!strncasecmp(menu->options[x].option, option, strlen(option))) && 
            (menu->options[x].option[strlen(option)]))
         return x;
   return -1;
}

static void path_lock_destroy

(

struct path_lock *

obj

)

[static]

Definition at line 1157 of file app.c.

References free.

Referenced by ast_lock_path_flock(), and ast_unlock_path_flock().

{
   if (obj->fd >= 0)
      close(obj->fd);
   if (obj->path)
      free(obj->path);
   free(obj);
}

static int read_newoption	(	struct ast_channel *	chan,
		struct ast_ivr_menu *	menu,
		char *	exten,
		int	maxexten
	)			[static]

Definition at line 1509 of file app.c.

References ast_waitfordigit(), ast_pbx::dtimeout, option_matchmore(), and ast_channel::pbx.

Referenced by ast_ivr_menu_run_internal().

{
   int res = 0;
   int ms;
   while (option_matchmore(menu, exten)) {
      ms = chan->pbx ? chan->pbx->dtimeout : 5000;
      if (strlen(exten) >= maxexten - 1) 
         break;
      res = ast_waitfordigit(chan, ms);
      if (res < 1)
         break;
      exten[strlen(exten) + 1] = '\0';
      exten[strlen(exten)] = res;
   }
   return res > 0 ? 0 : res;
}

---

Variable Documentation

int(* ast_has_voicemail_func)(const char *mailbox, const char *folder) = NULL [static]

Referenced by ast_app_has_voicemail(), ast_install_vm_functions(), and ast_uninstall_vm_functions().

int(* ast_inboxcount_func)(const char *mailbox, int *newmsgs, int *oldmsgs) = NULL [static]

Referenced by ast_app_inboxcount(), ast_install_vm_functions(), and ast_uninstall_vm_functions().

enum AST_LOCK_TYPE ast_lock_type = AST_LOCK_TYPE_LOCKFILE [static]

Definition at line 160 of file app.c.

int(* ast_messagecount_func)(const char *context, const char *mailbox, const char *folder) = NULL [static]

Referenced by ast_app_messagecount(), ast_install_vm_functions(), and ast_uninstall_vm_functions().

char default_acceptdtmf[] = "#" [static]

Definition at line 843 of file app.c.

char default_canceldtmf[] = "" [static]

Definition at line 844 of file app.c.

int global_maxsilence = 0 [static]

Definition at line 554 of file app.c.

Referenced by apply_general_options(), handle_minivm_show_settings(), load_config(), and play_record_review().

int global_silence_threshold = 128 [static]

Definition at line 553 of file app.c.

struct ast_generator linearstream [static]

Definition at line 380 of file app.c.