app.h File Reference

Application convenience functions, designed to give consistent look and feel to Asterisk apps. More...

Go to the source code of this file.

Data Structures
struct	ast_app_option
	A structure to hold the description of an application 'option'. More...
struct	ast_group_info
struct	ast_ivr_menu
struct	ast_ivr_option
Defines
#define	AST_APP_ARG(name)   char *name
	Define an application argument.
#define	AST_APP_OPTION(option, flagno)   [option] = { .flag = flagno }
	Declares an application option that does not accept an argument.
#define	AST_APP_OPTION_ARG(option, flagno, argno)   [option] = { .flag = flagno, .arg_index = argno + 1 }
	Declares an application option that accepts an argument.
#define	AST_APP_OPTIONS(holder, options...)   static const struct ast_app_option holder[128] = options
	Declares an array of options for an application.
#define	AST_DECLARE_APP_ARGS(name, arglist)
	Declare a structure to hold the application's arguments.
#define	AST_IVR_DECLARE_MENU(holder, title, flags, foo...)
#define	AST_IVR_FLAG_AUTORESTART   (1 << 0)
#define	AST_STANDARD_APP_ARGS(args, parse)   args.argc = ast_app_separate_args(parse, '|', args.argv, (sizeof(args) - sizeof(args.argc)) / sizeof(args.argv[0]))
	Performs the 'standard' argument separation process for an application.
Typedefs
typedef int(*	ast_ivr_callback )(struct ast_channel *chan, char *option, void *cbdata)
	Callback function for IVR.
Enumerations
enum	ast_ivr_action {   AST_ACTION_UPONE, AST_ACTION_EXIT, AST_ACTION_CALLBACK, AST_ACTION_PLAYBACK,   AST_ACTION_BACKGROUND, AST_ACTION_PLAYLIST, AST_ACTION_MENU, AST_ACTION_REPEAT,   AST_ACTION_RESTART, AST_ACTION_TRANSFER, AST_ACTION_WAITOPTION, AST_ACTION_NOOP,   AST_ACTION_BACKLIST }
enum	AST_LOCK_RESULT { AST_LOCK_SUCCESS = 0, AST_LOCK_TIMEOUT = -1, AST_LOCK_PATH_NOT_FOUND = -2, AST_LOCK_FAILURE = -3 }
Functions
int	ast_app_dtget (struct ast_channel *chan, const char *context, char *collect, size_t size, int maxlen, int timeout)
	Present a dialtone and collect a certain length extension.
int	ast_app_getdata (struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout)
	Plays a stream and gets DTMF data from a channel.
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_getvoice (struct ast_channel *c, char *dest, char *dstfmt, char *prompt, int silence, int maxsec)
int	ast_app_group_discard (struct ast_channel *chan)
int	ast_app_group_get_count (char *group, char *category)
struct ast_group_info *	ast_app_group_list_head (void)
int	ast_app_group_list_lock (void)
int	ast_app_group_list_unlock (void)
int	ast_app_group_match_get_count (char *groupmatch, char *category)
int	ast_app_group_set_channel (struct ast_channel *chan, char *data)
int	ast_app_group_split_group (char *data, char *group, int group_max, char *category, int category_max)
int	ast_app_group_update (struct ast_channel *oldchan, struct ast_channel *newchan)
int	ast_app_has_voicemail (const char *mailbox, const char *folder)
int	ast_app_messagecount (const char *mailbox, int *newmsgs, int *oldmsgs)
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.
unsigned int	ast_app_separate_args (char *buf, char delim, char **array, int arraylen)
	Separate a string into arguments in an array.
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)
int	ast_dtmf_stream (struct ast_channel *chan, struct ast_channel *peer, char *digits, int between)
void	ast_install_vm_functions (int(*has_voicemail_func)(const char *mailbox, const char *folder), int(*messagecount_func)(const char *mailbox, int *newmsgs, int *oldmsgs))
int	ast_ivr_menu_run (struct ast_channel *c, struct ast_ivr_menu *menu, void *cbdata)
	Runs an IVR menu.
int	ast_linear_stream (struct ast_channel *chan, const char *filename, int fd, int allowoverride)
enum AST_LOCK_RESULT	ast_lock_path (const char *path)
	Lock a filesystem path.
int	ast_play_and_prepend (struct ast_channel *chan, char *playfile, char *recordfile, int maxtime_sec, char *fmt, int *duration, int beep, int silencethreshold, int maxsilence_ms)
int	ast_play_and_record (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime_sec, const char *fmt, int *duration, int silencethreshold, int maxsilence_ms, const char *path)
int	ast_play_and_record_full (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime_sec, const char *fmt, int *duration, int silencethreshold, int maxsilence_ms, const char *path, const char *acceptdtmf, const char *canceldtmf)
int	ast_play_and_wait (struct ast_channel *chan, const char *fn)
char *	ast_read_textfile (const char *file)
int	ast_record_review (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, const char *path)
int	ast_safe_system (const char *s)
void	ast_uninstall_vm_functions (void)
int	ast_unlock_path (const char *path)

---

Detailed Description

Application convenience functions, designed to give consistent look and feel to Asterisk apps.

Definition in file app.h.

---

Define Documentation

#define AST_APP_ARG

(

name

)

char *name

Define an application argument.

Parameters:

name

The name of the argument

Definition at line 207 of file app.h.

Referenced by __login_exec(), aqm_exec(), dial_exec_full(), disa_exec(), enumlookup_exec(), group_check_exec(), hasvoicemail_exec(), md5check_exec(), misdn_check_l2l1(), mixmonitor_exec(), ospfinished_exec(), osplookup_exec(), ospnext_exec(), playback_exec(), pqm_exec(), privacy_exec(), record_exec(), rqm_exec(), sendimage_exec(), sendtext_exec(), transfer_exec(), txtcidname_exec(), upqm_exec(), and vm_box_exists().

#define AST_APP_OPTION	(	option,
		flagno		)	[option] = { .flag = flagno }

Declares an application option that does not accept an argument.

Parameters:

	option	The single character representing the option
	flagno	The flag index to be set if this option is present

See also:

AST_APP_OPTIONS, ast_app_parse_options

Definition at line 336 of file app.h.

#define AST_APP_OPTION_ARG	(	option,
		flagno,
		argno		)	[option] = { .flag = flagno, .arg_index = argno + 1 }

Declares an application option that accepts an argument.

Parameters:

	option	The single character representing the option
	flagno	The flag index to be set if this option is present
	argno	The index into the argument array where the argument should be placed

See also:

AST_APP_OPTIONS, ast_app_parse_options

Definition at line 347 of file app.h.

#define AST_APP_OPTIONS	(	holder,
		options...		)	static const struct ast_app_option holder[128] = options

Declares an array of options for an application.

Parameters:

	holder	The name of the array to be created
	options	The actual options to be placed into the array

See also:

ast_app_parse_options

This macro declares a 'static const' array of struct ast_option elements to hold the list of available options for an application. Each option must be declared using either the AST_APP_OPTION() or AST_APP_OPTION_ARG() macros.

Example usage:

  enum {
        OPT_JUMP = (1 << 0),
        OPT_BLAH = (1 << 1),
        OPT_BLORT = (1 << 2),
  } my_app_option_flags;

  enum {
        OPT_ARG_BLAH = 0,
        OPT_ARG_BLORT,
        !! this entry tells how many possible arguments there are,
           and must be the last entry in the list
        OPT_ARG_ARRAY_SIZE,
  } my_app_option_args;

  AST_APP_OPTIONS(my_app_options, {
        AST_APP_OPTION('j', OPT_JUMP),
        AST_APP_OPTION_ARG('b', OPT_BLAH, OPT_ARG_BLAH),
        AST_APP_OPTION_BLORT('B', OPT_BLORT, OPT_ARG_BLORT),
  });

  static int my_app_exec(struct ast_channel *chan, void *data)
  {
   char *options;
   struct ast_flags opts = { 0, };
   char *opt_args[OPT_ARG_ARRAY_SIZE];

   ... do any argument parsing here ...

   if (ast_parseoptions(my_app_options, &opts, opt_args, options)) {
      LOCAL_USER_REMOVE(u);
      return -1;
   }
  }

Definition at line 327 of file app.h.

#define AST_DECLARE_APP_ARGS	(	name,
		arglist		)

Value:

struct { \
      unsigned int argc; \
      char *argv[0]; \
      arglist \
   } name

Declare a structure to hold the application's arguments.

Parameters:

	name	The name of the structure
	arglist	The list of arguments, defined using AST_APP_ARG

This macro defines a structure intended to be used in a call to ast_app_separate_args(). The structure includes all the arguments specified, plus an argv array that overlays them and an argc argument counter. The arguments must be declared using AST_APP_ARG, and they will all be character pointers (strings).

Note:

The structure is not initialized, as the call to ast_app_separate_args() will perform that function before parsing the arguments.

Definition at line 224 of file app.h.

Referenced by __login_exec(), aqm_exec(), dial_exec_full(), disa_exec(), enumlookup_exec(), group_check_exec(), hasvoicemail_exec(), md5check_exec(), misdn_check_l2l1(), mixmonitor_exec(), ospfinished_exec(), osplookup_exec(), ospnext_exec(), playback_exec(), pqm_exec(), privacy_exec(), record_exec(), rqm_exec(), sendimage_exec(), sendtext_exec(), transfer_exec(), txtcidname_exec(), upqm_exec(), and vm_box_exists().

#define AST_IVR_DECLARE_MENU	(	holder,
		title,
		flags,
		foo...		)

Value:

static struct ast_ivr_option __options_##holder[] = foo;\
   static struct ast_ivr_menu holder = { title, flags, __options_##holder }

Definition at line 76 of file app.h.

#define AST_IVR_FLAG_AUTORESTART   (1 << 0)

Definition at line 74 of file app.h.

#define AST_STANDARD_APP_ARGS	(	args,
		parse		)	args.argc = ast_app_separate_args(parse, '|', args.argv, (sizeof(args) - sizeof(args.argc)) / sizeof(args.argv[0]))

Performs the 'standard' argument separation process for an application.

Parameters:

	args	An argument structure defined using AST_DECLARE_APP_ARGS
	parse	A modifiable buffer containing the input to be parsed

This function will separate the input string using the standard argument separator character '|' and fill in the provided structure, including the argc argument counter field.

Definition at line 240 of file app.h.

Referenced by __login_exec(), aqm_exec(), dial_exec_full(), disa_exec(), enumlookup_exec(), group_check_exec(), hasvoicemail_exec(), md5check_exec(), misdn_check_l2l1(), mixmonitor_exec(), ospfinished_exec(), osplookup_exec(), ospnext_exec(), playback_exec(), pqm_exec(), privacy_exec(), rqm_exec(), sendimage_exec(), sendtext_exec(), transfer_exec(), txtcidname_exec(), upqm_exec(), and vm_box_exists().

---

Typedef Documentation

typedef int(* ast_ivr_callback)(struct ast_channel *chan, char *option, void *cbdata)

Callback function for IVR.

Returns:

returns 0 on completion, -1 on hangup or digit if interrupted

Definition at line 35 of file app.h.

---

Enumeration Type Documentation

enum ast_ivr_action

Enumerator:

AST_ACTION_UPONE	adata is unused
AST_ACTION_EXIT	adata is the return value for ast_ivr_menu_run if channel was not hungup
AST_ACTION_CALLBACK	adata is an ast_ivr_callback
AST_ACTION_PLAYBACK	adata is file to play
AST_ACTION_BACKGROUND	adata is file to play
AST_ACTION_PLAYLIST	adata is list of files, separated by ; to play
AST_ACTION_MENU	adata is a pointer to an ast_ivr_menu
AST_ACTION_REPEAT	adata is max # of repeats, cast to a pointer
AST_ACTION_RESTART	adata is like repeat, but resets repeats to 0
AST_ACTION_TRANSFER	adata is a string with exten[]
AST_ACTION_WAITOPTION	adata is a timeout, or 0 for defaults
AST_ACTION_NOOP	adata is unused
AST_ACTION_BACKLIST	adata is list of files separated by ; allows interruption

Definition at line 37 of file app.h.

             {
   AST_ACTION_UPONE, /*!< adata is unused */
   AST_ACTION_EXIT,  /*!< adata is the return value for ast_ivr_menu_run if channel was not hungup */
   AST_ACTION_CALLBACK, /*!< adata is an ast_ivr_callback */
   AST_ACTION_PLAYBACK, /*!< adata is file to play */
   AST_ACTION_BACKGROUND,  /*!< adata is file to play */
   AST_ACTION_PLAYLIST, /*!< adata is list of files, separated by ; to play */
   AST_ACTION_MENU,  /*!< adata is a pointer to an ast_ivr_menu */
   AST_ACTION_REPEAT,   /*!< adata is max # of repeats, cast to a pointer */
   AST_ACTION_RESTART,  /*!< adata is like repeat, but resets repeats to 0 */
   AST_ACTION_TRANSFER, /*!< adata is a string with exten[@context] */
   AST_ACTION_WAITOPTION,  /*!< adata is a timeout, or 0 for defaults */
   AST_ACTION_NOOP,  /*!< adata is unused */
   AST_ACTION_BACKLIST, /*!< adata is list of files separated by ; allows interruption */
} ast_ivr_action;

enum AST_LOCK_RESULT

Enumerator:

AST_LOCK_SUCCESS
AST_LOCK_TIMEOUT
AST_LOCK_PATH_NOT_FOUND
AST_LOCK_FAILURE

Definition at line 149 of file app.h.

                     {
   AST_LOCK_SUCCESS = 0,
   AST_LOCK_TIMEOUT = -1,
   AST_LOCK_PATH_NOT_FOUND = -2,
   AST_LOCK_FAILURE = -3,
};

---

Function Documentation

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

Present a dialtone and collect a certain length extension.

Returns:

Returns 1 on valid extension entered, -1 on hangup, or 0 on invalid extension.

Note:

Note that if 'collect' holds digits already, new digits will be appended, so be sure it's initialized properly

Definition at line 64 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;
   
   ts = ast_get_indication_tone(chan->zone,"dial");
   if (ts && 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); strlen(collect) < 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) {
      if (ast_exists_extension(chan, context, collect, 1, chan->cid.cid_num))
         res = 1;
      else
         res = 0;
   }
   return res;
}

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

Plays a stream and gets DTMF data from a channel.

Parameters:

	c	Which channel one is interacting with
	prompt	File to pass to ast_streamfile (the one that you wish to play)
	s	The location where the DTMF data will be stored
	maxlen	Max Length of the data
	timeout	Timeout length waiting for data(in milliseconds). Set to 0 for standard timeout(six seconds), or -1 for no time out.

This function was designed for application programmers for situations where they need to play a message and then get some DTMF data in response to the message. If a digit is pressed during playback, it will immediately break out of the message and continue execution of your code.

Parameters:

timeout

set timeout to 0 for "standard" timeouts. Set timeout to -1 for "ludicrous time" (essentially never times out)

Definition at line 108 of file app.c.

References ast_readstring(), ast_streamfile(), ast_pbx::dtimeout, ast_channel::language, ast_channel::pbx, and ast_pbx::rtimeout.

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

{
   int res,to,fto;
   /* XXX Merge with full version? XXX */
   if (maxlen)
      s[0] = '\0';
   if (prompt) {
      res = ast_streamfile(c, prompt, c->language);
      if (res < 0)
         return res;
   }
   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;
   res = ast_readstring(c, s, maxlen, to, fto, "#");
   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 131 of file app.c.

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

Referenced by handle_getdata().

{
   int res,to,fto;
   if (prompt) {
      res = ast_streamfile(c, prompt, c->language);
      if (res < 0)
         return res;
   }
   fto = 6000;
   to = 2000;
   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_getvoice	(	struct ast_channel *	c,
		char *	dest,
		char *	dstfmt,
		char *	prompt,
		int	silence,
		int	maxsec
	)

Record voice (after playing prompt if specified), waiting for silence (in ms) up to a given timeout (in s) or '#'

Definition at line 149 of file app.c.

References ast_closestream(), ast_dsp_free(), ast_dsp_new(), ast_dsp_silence(), AST_FORMAT_SLINEAR, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree(), ast_log(), ast_read(), ast_set_read_format(), ast_streamfile(), ast_waitfor(), ast_waitstream(), ast_writefile(), ast_writestream(), ast_frame::frametype, ast_channel::language, LOG_NOTICE, LOG_WARNING, ast_channel::name, ast_channel::readformat, ast_frame::samples, ast_frame::subclass, and total.

{
   int res;
   struct ast_filestream *writer;
   int rfmt;
   int totalms=0, total;
   
   struct ast_frame *f;
   struct ast_dsp *sildet;
   /* Play prompt if requested */
   if (prompt) {
      res = ast_streamfile(c, prompt, c->language);
      if (res < 0)
         return res;
      res = ast_waitstream(c,"");
      if (res < 0)
         return res;
   }
   rfmt = c->readformat;
   res = ast_set_read_format(c, AST_FORMAT_SLINEAR);
   if (res < 0) {
      ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
      return -1;
   }
   sildet = ast_dsp_new();
   if (!sildet) {
      ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
      return -1;
   }
   writer = ast_writefile(dest, dstfmt, "Voice file", 0, 0, 0666);
   if (!writer) {
      ast_log(LOG_WARNING, "Unable to open file '%s' in format '%s' for writing\n", dest, dstfmt);
      ast_dsp_free(sildet);
      return -1;
   }
   for(;;) {
      if ((res = ast_waitfor(c, 2000)) < 0) {
         ast_log(LOG_NOTICE, "Waitfor failed while recording file '%s' format '%s'\n", dest, dstfmt);
         break;
      }
      if (res) {
         f = ast_read(c);
         if (!f) {
            ast_log(LOG_NOTICE, "Hungup while recording file '%s' format '%s'\n", dest, dstfmt);
            break;
         }
         if ((f->frametype == AST_FRAME_DTMF) && (f->subclass == '#')) {
            /* Ended happily with DTMF */
            ast_frfree(f);
            break;
         } else if (f->frametype == AST_FRAME_VOICE) {
            ast_dsp_silence(sildet, f, &total); 
            if (total > silence) {
               /* Ended happily with silence */
               ast_frfree(f);
               break;
            }
            totalms += f->samples / 8;
            if (totalms > maxsec * 1000) {
               /* Ended happily with too much stuff */
               ast_log(LOG_NOTICE, "Constraining voice on '%s' to %d seconds\n", c->name, maxsec);
               ast_frfree(f);
               break;
            }
            res = ast_writestream(writer, f);
            if (res < 0) {
               ast_log(LOG_WARNING, "Failed to write to stream at %s!\n", dest);
               ast_frfree(f);
               break;
            }
               
         }
         ast_frfree(f);
      }
   }
   res = ast_set_read_format(c, rfmt);
   if (res)
      ast_log(LOG_WARNING, "Unable to restore read format on '%s'\n", c->name);
   ast_dsp_free(sildet);
   ast_closestream(writer);
   return 0;
}

int ast_app_group_discard

(

struct ast_channel *

chan

)

Discard all group counting for a channel

Definition at line 1134 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_group_info::chan, free, and list.

Referenced by ast_channel_free().

{
   struct ast_group_info *gi = NULL;

   AST_LIST_LOCK(&groups);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&groups, gi, list) {
      if (gi->chan == chan) {
         AST_LIST_REMOVE_CURRENT(&groups, list);
         free(gi);
      }
   }
        AST_LIST_TRAVERSE_SAFE_END
   AST_LIST_UNLOCK(&groups);

   return 0;
}

int ast_app_group_get_count	(	char *	group,
		char *	category
	)

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

Definition at line 1077 of file app.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_group_info::category, ast_group_info::group, and list.

Referenced by group_check_exec(), group_count_exec(), and group_count_function_read().

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

   if (ast_strlen_zero(group))
      return 0;

   AST_LIST_LOCK(&groups);
   AST_LIST_TRAVERSE(&groups, gi, list) {
      if (!strcasecmp(gi->group, group) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
         count++;
   }
   AST_LIST_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 1156 of file app.c.

References AST_LIST_FIRST.

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

{
   return AST_LIST_FIRST(&groups);
}

int ast_app_group_list_lock

(

void

)

Lock the group count list

Definition at line 1151 of file app.c.

References AST_LIST_LOCK.

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

{
   return AST_LIST_LOCK(&groups);
}

int ast_app_group_list_unlock

(

void

)

Unlock the group count list

Definition at line 1161 of file app.c.

References AST_LIST_UNLOCK.

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

{
   return AST_LIST_UNLOCK(&groups);
}

int ast_app_group_match_get_count	(	char *	groupmatch,
		char *	category
	)

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

Definition at line 1095 of file app.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_strlen_zero(), ast_group_info::category, ast_group_info::group, and list.

Referenced by group_match_count_exec(), and 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_LIST_LOCK(&groups);
   AST_LIST_TRAVERSE(&groups, gi, list) {
      if (!regexec(&regexbuf, gi->group, 0, NULL, 0) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
         count++;
   }
   AST_LIST_UNLOCK(&groups);

   regfree(&regexbuf);

   return count;
}

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

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

Definition at line 1034 of file app.c.

References ast_app_group_split_group(), AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_strlen_zero(), calloc, ast_group_info::category, ast_group_info::chan, free, ast_group_info::group, group, and list.

Referenced by dial_exec_full(), group_function_write(), and group_set_exec().

{
   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_LIST_LOCK(&groups);
   AST_LIST_TRAVERSE_SAFE_BEGIN(&groups, gi, list) {
      if ((gi->chan == chan) && ((ast_strlen_zero(category) && ast_strlen_zero(gi->category)) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
         AST_LIST_REMOVE_CURRENT(&groups, list);
         free(gi);
         break;
      }
   }
   AST_LIST_TRAVERSE_SAFE_END

   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_LIST_INSERT_TAIL(&groups, gi, list);
   } else {
      res = -1;
   }

   AST_LIST_UNLOCK(&groups);

   return res;
}

int ast_app_group_split_group	(	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 1007 of file app.c.

References ast_strlen_zero().

Referenced by ast_app_group_set_channel(), group_check_exec(), group_count_exec(), group_count_function_read(), group_match_count_exec(), 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
      res = -1;

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

   return res;
}

int ast_app_group_update	(	struct ast_channel *	oldchan,
		struct ast_channel *	newchan
	)

Update all group counting for a channel to a new one

Definition at line 1120 of file app.c.

References AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_group_info::chan, and list.

Referenced by ast_do_masquerade().

{
   struct ast_group_info *gi = NULL;

   AST_LIST_LOCK(&groups);
   AST_LIST_TRAVERSE(&groups, gi, list) {
      if (gi->chan == old)
         gi->chan = new;
   }
   AST_LIST_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 248 of file app.c.

References ast_has_voicemail_func, ast_verbose(), option_verbose, and VERBOSE_PREFIX_3.

Referenced by action_mailboxstatus(), do_monitor(), has_voicemail(), notify_new_message(), play_dialtone(), and update_registry().

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

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

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

Determine number of new/old messages in a mailbox

Definition at line 262 of file app.c.

References ast_messagecount_func, ast_verbose(), option_verbose, and VERBOSE_PREFIX_3.

Referenced by action_mailboxcount(), do_housekeeping(), notify_new_message(), sip_send_mwi_to_peer(), and update_registry().

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

   if (!warned && (option_verbose > 2)) {
      warned++;
      ast_verbose(VERBOSE_PREFIX_3 "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
   }

   return 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 1596 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(), chanspy_exec(), conf_exec(), dial_exec_full(), mixmonitor_exec(), page_exec(), pbx_builtin_background(), pbx_builtin_resetcdr(), pbx_builtin_waitexten(), vm_exec(), and vm_execmain().

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

   ast_clear_flag(flags, AST_FLAGS_ALL);

   if (!optstr)
      return 0;

   s = optstr;
   while (*s) {
      curarg = *s++ & 0x7f;
      ast_set_flag(flags, options[curarg].flag);
      argloc = options[curarg].arg_index;
      if (*s == '(') {
         /* Has argument */
         arg = ++s;
         while (*s && (*s != ')'))
            s++;
         if (*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;
         }
      } else if (argloc) {
         args[argloc - 1] = NULL;
      }
   }

   return res;
}

unsigned int ast_app_separate_args	(	char *	buf,
		char	delim,
		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
	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 1166 of file app.c.

Referenced by add_agent(), app_exec(), astman_get_variables(), builtin_function_cdr_read(), builtin_function_cdr_write(), builtin_function_checkmd5(), builtin_function_math(), chanspy_exec(), controlplayback_exec(), cut_internal(), dictate_exec(), function_db_exists(), function_db_read(), function_db_write(), pbx_builtin_background(), pbx_builtin_setvar(), pbx_builtin_waitexten(), read_exec(), record_exec(), vm_exec(), and vm_execmain().

{
   int argc;
   char *scan;
   int paren = 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) && !paren) {
            *scan++ = '\0';
            break;
         }
      }
   }

   if (*scan)
      array[argc++] = scan;

   return argc;
}

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
	)

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

Definition at line 431 of file app.c.

References ast_channel::_state, ast_answer(), ast_log(), ast_seekstream(), AST_STATE_UP, ast_stopstream(), ast_streamfile(), ast_tellstream(), ast_waitfordigit(), ast_waitstream_fr(), ast_channel::language, LOG_DEBUG, 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;

   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) {
            ast_seekstream(chan->stream, 0, SEEK_END);
            end = NULL;
         };
         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_log(LOG_DEBUG, "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;
   }

   ast_stopstream(chan);

   return res;
}

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

Send DTMF to chan (optionally entertain peer)

Definition at line 280 of file app.c.

References ast_autoservice_start(), ast_autoservice_stop(), AST_FRAME_DTMF, ast_log(), ast_safe_sleep(), ast_waitfor(), ast_write(), ast_frame::frametype, LOG_WARNING, ast_frame::src, and ast_frame::subclass.

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

{
   char *ptr;
   int res = 0;
   struct ast_frame f;
   if (!between)
      between = 100;

   if (peer)
      res = ast_autoservice_start(peer);

   if (!res) {
      res = ast_waitfor(chan,100);
      if (res > -1) {
         for (ptr=digits; *ptr; ptr++) {
            if (*ptr == 'w') {
               res = ast_safe_sleep(chan, 500);
               if (res) 
                  break;
               continue;
            }
            memset(&f, 0, sizeof(f));
            f.frametype = AST_FRAME_DTMF;
            f.subclass = *ptr;
            f.src = "ast_dtmf_stream";
            if (strchr("0123456789*#abcdABCD",*ptr)==NULL) {
               ast_log(LOG_WARNING, "Illegal DTMF character '%c' in string. (0-9*#aAbBcCdD allowed)\n",*ptr);
            } else {
               res = ast_write(chan, &f);
               if (res) 
                  break;
               /* pause between digits */
               res = ast_safe_sleep(chan,between);
               if (res) 
                  break;
            }
         }
      }
      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;
      }
   }
   return res;
}

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

Definition at line 235 of file app.c.

References ast_has_voicemail_func, and ast_messagecount_func.

Referenced by load_module().

{
   ast_has_voicemail_func = has_voicemail_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 1553 of file app.c.

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

{
   int res;
   res = ast_ivr_menu_run_internal(chan, menu, cbdata);
   /* Hide internal coding */
   if (res > 0)
      res = 0;
   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 400 of file app.c.

References linear_state::allowoverride, ast_activate_generator(), ast_config_AST_VAR_DIR, ast_log(), ast_strlen_zero(), linear_state::autoclose, linear_state::fd, LOG_WARNING, and malloc.

{
   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", (char *)ast_config_AST_VAR_DIR, "sounds", filename);
      fd = open(tmpf, O_RDONLY);
      if (fd < 0){
         ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", tmpf, strerror(errno));
         return -1;
      }
   }
   lin = malloc(sizeof(struct linear_state));
   if (lin) {
      memset(lin, 0, 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 1200 of file app.c.

References AST_LOCK_FAILURE, AST_LOCK_PATH_NOT_FOUND, AST_LOCK_SUCCESS, AST_LOCK_TIMEOUT, ast_log(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, and s.

Referenced by vm_lock_path().

{
   char *s;
   char *fs;
   int res;
   int fd;
   time_t start;

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

   if (!fs || !s) {
      ast_log(LOG_WARNING, "Out of memory!\n");
      return AST_LOCK_FAILURE;
   }

   snprintf(fs, strlen(path) + 19, "%s/.lock-%08x", path, rand());
   fd = open(fs, O_WRONLY | O_CREAT | O_EXCL, 0600);
   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);
   time(&start);
   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_log(LOG_DEBUG, "Locked path '%s'\n", path);
      return AST_LOCK_SUCCESS;
   }
}

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

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 771 of file app.c.

References ast_closestream(), ast_dsp_free(), ast_dsp_new(), ast_dsp_set_threshold(), ast_dsp_silence(), ast_filedelete(), ast_filerename(), AST_FORMAT_SLINEAR, AST_FRAME_DTMF, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_getformatname(), ast_log(), ast_play_and_wait(), ast_read(), ast_readfile(), ast_readframe(), ast_set_read_format(), ast_strdupa, ast_stream_rewind(), ast_streamfile(), ast_truncstream(), ast_verbose(), ast_waitfor(), ast_waitstream(), ast_writefile(), ast_writestream(), ast_frame::frametype, ast_channel::language, LOG_DEBUG, LOG_WARNING, MAX_OTHER_FORMATS, ast_channel::name, option_verbose, ast_channel::readformat, strsep(), ast_frame::subclass, ast_dsp::totalsilence, and VERBOSE_PREFIX_3.

Referenced by vm_forwardoptions().

{
   int d = 0;
   char *fmts;
   char comment[256];
   int x, fmtcnt=1, res=-1,outmsg=0;
   struct ast_frame *f;
   struct ast_filestream *others[MAX_OTHER_FORMATS];
   struct ast_filestream *realfiles[MAX_OTHER_FORMATS];
   char *sfmt[MAX_OTHER_FORMATS];
   char *stringp=NULL;
   time_t start, end;
   struct ast_dsp *sildet;    /* silence detector dsp */
   int totalsilence = 0;
   int dspsilence = 0;
   int rfmt=0; 
   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 == NULL) {
      ast_log(LOG_WARNING, "Error play_and_prepend called without duration pointer\n");
      return -1;
   }

   ast_log(LOG_DEBUG,"play_and_prepend: %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_streamfile(chan, "beep",chan->language);
      if (!d)
         d = ast_waitstream(chan,"");
      if (d < 0)
         return -1;
   }
   ast_copy_string(prependfile, recordfile, sizeof(prependfile)); 
   strncat(prependfile, "-prepend", sizeof(prependfile) - strlen(prependfile) - 1);
         
   fmts = ast_strdupa(fmt);
   
   stringp=fmts;
   strsep(&stringp, "|");
   ast_log(LOG_DEBUG,"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);
   }

   time(&start);
   end=start;  /* 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(prependfile, sfmt[x], comment, O_TRUNC, 0, 0700);
      ast_verbose( VERBOSE_PREFIX_3 "x=%d, open writing:  %s format: %s, %p\n", x, prependfile, sfmt[x], others[x]);
      if (!others[x]) {
         break;
      }
   }
   
   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);

   if (maxsilence > 0) {
      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 (x == fmtcnt) {
   /* Loop forever, writing the packets we read to the writer(s), until
      we read a # or get a hangup */
      f = NULL;
      for(;;) {
         res = ast_waitfor(chan, 2000);
         if (!res) {
            ast_log(LOG_DEBUG, "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 (!others[x])
                  break;
               res = ast_writestream(others[x], f);
            }
            
            /* Silence Detection */
            if (maxsilence > 0) {
               dspsilence = 0;
               ast_dsp_silence(sildet, f, &dspsilence);
               if (dspsilence)
                  totalsilence = dspsilence;
               else
                  totalsilence = 0;
               
               if (totalsilence > maxsilence) {
               /* Ended happily with silence */
               if (option_verbose > 2) 
                  ast_verbose( VERBOSE_PREFIX_3 "Recording automatically stopped after a silence of %d seconds\n", totalsilence/1000);
               ast_frfree(f);
               res = 'S';
               outmsg=2;
               break;
               }
            }
            /* Exit on any error */
            if (res) {
               ast_log(LOG_WARNING, "Error writing frame\n");
               ast_frfree(f);
               break;
            }
         } else if (f->frametype == AST_FRAME_VIDEO) {
            /* Write only once */
            ast_writestream(others[0], f);
         } else if (f->frametype == AST_FRAME_DTMF) {
            /* stop recording with any digit */
            if (option_verbose > 2) 
               ast_verbose( VERBOSE_PREFIX_3 "User ended message by pressing %c\n", f->subclass);
            res = 't';
            outmsg = 2;
            ast_frfree(f);
            break;
         }
         if (maxtime) {
            time(&end);
            if (maxtime < (end - start)) {
               if (option_verbose > 2)
                  ast_verbose( VERBOSE_PREFIX_3 "Took too long, cutting it short...\n");
               res = 't';
               outmsg=2;
               ast_frfree(f);
               break;
            }
         }
         ast_frfree(f);
      }
      if (end == start) time(&end);
      if (!f) {
         if (option_verbose > 2) 
            ast_verbose( VERBOSE_PREFIX_3 "User hung up\n");
         res = -1;
         outmsg=1;
#if 0
         /* delete all the prepend files */
         for (x=0;x<fmtcnt;x++) {
            if (!others[x])
               break;
            ast_closestream(others[x]);
            ast_filedelete(prependfile, sfmt[x]);
         }
#endif
      }
   } else {
      ast_log(LOG_WARNING, "Error creating writestream '%s', format '%s'\n", prependfile, sfmt[x]); 
   }
   ast_dsp_free(sildet);
   *duration = end - start;
#if 0
   if (outmsg > 1) {
#else
   if (outmsg) {
#endif
      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;
         if (totalsilence)
            ast_stream_rewind(others[x], totalsilence-200);
         else
            ast_stream_rewind(others[x], 200);
         ast_truncstream(others[x]);
         /* add the original file too */
         while ((fr = ast_readframe(realfiles[x]))) {
            ast_writestream(others[x],fr);
         }
         ast_closestream(others[x]);
         ast_closestream(realfiles[x]);
         ast_filerename(prependfile, recordfile, sfmt[x]);
#if 0
         ast_verbose("Recording Format: sfmts=%s, prependfile %s, recordfile %s\n", sfmt[x],prependfile,recordfile);
#endif
         ast_filedelete(prependfile, sfmt[x]);
      }
   }
   if (rfmt) {
      if (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) {
      if (outmsg > 1) {
         /* Let them know it worked */
         ast_streamfile(chan, "auth-thankyou", chan->language);
         ast_waitstream(chan, "");
      }
   }  
   return res;
}

int ast_play_and_record	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime_sec,
		const char *	fmt,
		int *	duration,
		int	silencethreshold,
		int	maxsilence_ms,
		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 766 of file app.c.

References ast_play_and_record_full().

Referenced by ast_record_review(), and dial_exec_full().

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

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

Definition at line 539 of file app.c.

References ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_closestream(), AST_CONTROL_VIDUPDATE, ast_dsp_free(), ast_dsp_new(), ast_dsp_set_threshold(), ast_dsp_silence(), AST_FORMAT_SLINEAR, AST_FRAME_DTMF, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree(), ast_getformatname(), ast_indicate(), ast_log(), ast_play_and_wait(), ast_read(), ast_set_read_format(), ast_strdupa, ast_stream_rewind(), ast_streamfile(), ast_truncstream(), ast_unlock_path(), ast_verbose(), ast_waitfor(), ast_waitstream(), ast_writefile(), ast_writestream(), ast_frame::frametype, ast_channel::language, LOG_DEBUG, LOG_WARNING, MAX_OTHER_FORMATS, ast_channel::name, option_transmit_silence_during_record, option_verbose, ast_channel::readformat, strsep(), ast_frame::subclass, ast_dsp::totalsilence, and VERBOSE_PREFIX_3.

Referenced by ast_play_and_record(), and play_record_review().

{
   int d;
   char *fmts;
   char comment[256];
   int x, fmtcnt=1, res=-1,outmsg=0;
   struct ast_frame *f;
   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 dspsilence = 0;
   int rfmt=0;
   struct ast_silence_generator *silgen = NULL;

   if (silencethreshold < 0)
      silencethreshold = global_silence_threshold;

   if (maxsilence < 0)
      maxsilence = global_maxsilence;

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

   ast_log(LOG_DEBUG,"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) {
      d = ast_play_and_wait(chan, playfile);
      if (d > -1)
         d = ast_streamfile(chan, "beep",chan->language);
      if (!d)
         d = ast_waitstream(chan,"");
      if (d < 0)
         return -1;
   }

   fmts = ast_strdupa(fmt);

   stringp=fmts;
   strsep(&stringp, "|");
   ast_log(LOG_DEBUG,"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);
   }

   time(&start);
   end=start;  /* 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(recordfile, sfmt[x], comment, O_TRUNC, 0, 0700);
      ast_verbose( VERBOSE_PREFIX_3 "x=%d, open writing:  %s format: %s, %p\n", x, 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;
      }
   }

   /* Request a video update */
   ast_indicate(chan, AST_CONTROL_VIDUPDATE);

   if (option_transmit_silence_during_record)
      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 # or get a hangup */
      f = NULL;
      for(;;) {
         res = ast_waitfor(chan, 2000);
         if (!res) {
            ast_log(LOG_DEBUG, "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++) {
               res = ast_writestream(others[x], f);
            }

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

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

   if (silgen)
      ast_channel_stop_silence_generator(chan, silgen);

   *duration = end - start;

   for (x=0;x<fmtcnt;x++) {
      if (!others[x])
         break;
      if (res > 0) {
         if (totalsilence)
            ast_stream_rewind(others[x], totalsilence-200);
         else
            ast_stream_rewind(others[x], 200);
      }
      ast_truncstream(others[x]);
      ast_closestream(others[x]);
   }
   if (rfmt) {
      if (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 > 1) {
      /* Let them know recording is stopped */
      if(!ast_streamfile(chan, "auth-thankyou", chan->language))
         ast_waitstream(chan, "");
   }
   if (sildet)
      ast_dsp_free(sildet);
   return res;
}

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 525 of file app.c.

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

Referenced by advanced_options(), ast_play_and_prepend(), ast_play_and_record_full(), ast_record_review(), dial_exec_full(), dialout(), forward_message(), get_folder(), get_folder2(), leave_voicemail(), play_message_category(), 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_execmain(), vm_forwardoptions(), vm_instructions(), vm_intro_cz(), vm_intro_de(), vm_intro_en(), vm_intro_es(), vm_intro_fr(), vm_intro_gr(), vm_intro_it(), vm_intro_nl(), vm_intro_no(), vm_intro_pt(), vm_intro_se(), vm_newuser(), vm_options(), vm_play_folder_name(), vm_play_folder_name_gr(), vm_tempgreeting(), and vmauthenticate().

{
   int d;
   d = ast_streamfile(chan, fn, chan->language);
   if (d)
      return d;
   d = ast_waitstream(chan, AST_DIGIT_ANY);
   ast_stopstream(chan);
   return d;
}

char* ast_read_textfile

(

const char *

file

)

Read a file into asterisk

Definition at line 1563 of file app.c.

References ast_log(), free, LOG_WARNING, and malloc.

Referenced by readfile_exec().

{
   int fd;
   char *output=NULL;
   struct stat filesize;
   int count=0;
   int res;
   if(stat(filename,&filesize)== -1){
      ast_log(LOG_WARNING,"Error can't stat %s\n", filename);
      return NULL;
   }
   count=filesize.st_size + 1;
   fd = open(filename, O_RDONLY);
   if (fd < 0) {
      ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", filename, strerror(errno));
      return NULL;
   }
   output=(char *)malloc(count);
   if (output) {
      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));
         free(output);
         output = NULL;
      }
   } else 
      ast_log(LOG_WARNING, "Out of memory!\n");
   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 1261 of file app.c.

References AST_DIGIT_ANY, ast_log(), ast_play_and_record(), ast_play_and_wait(), ast_streamfile(), ast_verbose(), ast_waitfordigit(), ast_waitstream(), ast_channel::language, LOG_WARNING, and VERBOSE_PREFIX_3.

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 == NULL) {
      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_streamfile(chan, "vm-msgsaved", chan->language);
            ast_waitstream(chan, "");
            cmd = 't';
            return res;
         }
      case '2':
         /* Review */
         ast_verbose(VERBOSE_PREFIX_3 "Reviewing the recording\n");
         ast_streamfile(chan, recordfile, chan->language);
         cmd = ast_waitstream(chan, AST_DIGIT_ANY);
         break;
      case '3':
         message_exists = 0;
         /* Record */
         if (recorded == 1)
            ast_verbose(VERBOSE_PREFIX_3 "Re-recording\n");
         else  
            ast_verbose(VERBOSE_PREFIX_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;
}

int ast_safe_system

(

const char *

s

)

Safely spawn an external program while closing file descriptors

Note:

This replaces the system call in all Asterisk modules

Definition at line 428 of file asterisk.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_priority(), LOG_WARNING, and null_sig_handler().

Referenced by alarmreceiver_exec(), ast_closestream(), ast_monitor_change_fname(), ast_monitor_start(), ast_monitor_stop(), consolehandler(), mixmonitor_thread(), process_text_line(), remoteconsolehandler(), run_externnotify(), sendmail(), sendpage(), system_exec_helper(), and vm_change_password_shell().

{
   pid_t pid;
   int x;
   int res;
   struct rusage rusage;
   int status;
   unsigned int level;

   /* keep track of how many ast_safe_system() functions
      are running at this moment
   */
   ast_mutex_lock(&safe_system_lock);
   level = safe_system_level++;

   /* only replace the handler if it has not already been done */
   if (level == 0)
      safe_system_prev_handler = signal(SIGCHLD, null_sig_handler);

   ast_mutex_unlock(&safe_system_lock);

   pid = fork();

   if (pid == 0) {
      if (option_highpriority)
         ast_set_priority(0);
      /* Close file descriptors and launch system command */
      for (x = STDERR_FILENO + 1; x < 4096; x++)
         close(x);
      execl("/bin/sh", "/bin/sh", "-c", s, NULL);
      _exit(1);
   } else if (pid > 0) {
      for(;;) {
         res = wait4(pid, &status, 0, &rusage);
         if (res > -1) {
            res = WIFEXITED(status) ? WEXITSTATUS(status) : -1;
            break;
         } else if (errno != EINTR) 
            break;
      }
   } else {
      ast_log(LOG_WARNING, "Fork failed: %s\n", strerror(errno));
      res = -1;
   }

   ast_mutex_lock(&safe_system_lock);
   level = --safe_system_level;

   /* only restore the handler if we are the last one */
   if (level == 0)
      signal(SIGCHLD, safe_system_prev_handler);

   ast_mutex_unlock(&safe_system_lock);

   return res;
}

void ast_uninstall_vm_functions

(

void

)

Definition at line 242 of file app.c.

References ast_has_voicemail_func, and ast_messagecount_func.

Referenced by unload_module().

{
   ast_has_voicemail_func = NULL;
   ast_messagecount_func = NULL;
}

int ast_unlock_path

(

const char *

path

)

Unlock a path

Definition at line 1240 of file app.c.

References ast_log(), LOG_DEBUG, LOG_ERROR, LOG_WARNING, and s.

Referenced by ast_play_and_record_full(), close_mailbox(), copy_message(), count_messages(), last_message_index(), leave_voicemail(), resequence_mailbox(), and save_to_folder().

{
   char *s;
   int res;

   s = alloca(strlen(path) + 10);
   if (!s) {
      ast_log(LOG_WARNING, "Out of memory!\n");
      return -1;
   }

   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_log(LOG_DEBUG, "Unlocked path '%s'\n", path);

   return res;
}