app.c File Reference

Convenient Application Routines. More...

#include "asterisk.h"
#include <sys/stat.h>
#include <regex.h>
#include <sys/file.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.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/threadstorage.h"
#include "asterisk/test.h"
#include "asterisk/module.h"
#include "asterisk/astobj2.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/json.h"
#include "asterisk/format_cache.h"

Include dependency graph for main/app.c:

Go to the source code of this file.

Data Structures
struct	groups
struct	linear_state
struct	path_lock
struct	path_lock_list
struct	zombie
struct	zombies

Macros
#define	AST_MAX_FORMATS   10
#define	FMT   "%30Lf%9s"
#define	RES_EXIT   (1 << 17)
#define	RES_REPEAT   (1 << 18)
#define	RES_RESTART   ((1 << 19) | RES_REPEAT)
#define	RES_UPONE   (1 << 16)
#define	SF_BETWEEN   600
#define	SF_BUF_LEN   20
#define	SF_OFF   33
#define	SF_ON   67
#define	VM_API_CALL(res, api_call, api_parms)
#define	VM_GREETER_API_CALL(res, api_call, api_parms)

Enumerations
enum	control_tone_frame_response_result { CONTROL_TONE_RESPONSE_FAILED = -1 , CONTROL_TONE_RESPONSE_NORMAL = 0 , CONTROL_TONE_RESPONSE_FINISHED = 1 }

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 *sound_duration, int beep, int silencethreshold, int maxsilence, const char *path, int prepend, const char *acceptdtmf, const char *canceldtmf, int skip_confirmation_sound, enum ast_record_if_exists if_exists)
int	__ast_vm_greeter_register (const struct ast_vm_greeter_functions *vm_table, struct ast_module *module)
	Set voicemail greeter function callbacks.
int	__ast_vm_register (const struct ast_vm_functions *vm_table, struct ast_module *module)
	Set voicemail function callbacks.
static	AO2_GLOBAL_OBJ_STATIC (vm_greeter_provider)
	The container for the voicemail greeter provider.
static	AO2_GLOBAL_OBJ_STATIC (vm_provider)
	The container for the voicemail provider.
static void	app_cleanup (void)
int	app_init (void)
	Initialize the application core.
int	ast_app_copy_recording_to_vm (struct ast_vm_recording_data *vm_rec_data)
	param[in] vm_rec_data Contains data needed to make the recording. retval 0 voicemail successfully created from recording. retval -1 Failure
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.
int	ast_app_exec_sub (struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const char *sub_args, int ignore_hangup)
	Run a subroutine on a channel, placing an optional second channel into autoservice.
const char *	ast_app_expand_sub_args (struct ast_channel *chan, const char *args)
	Add missing context/exten to subroutine argument string.
enum ast_getdata_result	ast_app_getdata (struct ast_channel *c, const 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, const 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.
enum ast_getdata_result	ast_app_getdata_terminator (struct ast_channel *c, const char *prompt, char *s, int maxlen, int timeout, char *terminator)
	Plays a stream and gets DTMF data from a channel.
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 *mailboxes, const char *folder)
	Determine if a given mailbox has any voicemail If folder is NULL, defaults to "INBOX". If folder is "INBOX", includes the number of messages in the "Urgent" folder.
int	ast_app_inboxcount (const char *mailboxes, int *newmsgs, int *oldmsgs)
	Determine number of new/old messages in a mailbox.
int	ast_app_inboxcount2 (const char *mailboxes, int *urgentmsgs, int *newmsgs, int *oldmsgs)
	Determine number of urgent/new/old messages in a mailbox.
int	ast_app_messagecount (const char *mailbox_id, const char *folder)
	Get the number of messages in a given mailbox 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.
int	ast_app_parse_timelen (const char *timestr, int *result, enum ast_timelen unit)
	Common routine to parse time lengths, with optional time unit specifier.
int	ast_app_run_sub (struct ast_channel *autoservice_chan, struct ast_channel *sub_chan, const char *sub_location, const char *sub_args, int ignore_hangup)
	Run a subroutine on a channel, placing an optional second channel into autoservice.
int	ast_app_sayname (struct ast_channel *chan, const char *mailbox_id)
	Play a recorded user name for the mailbox to the specified channel.
void	ast_close_fds_above_n (int n)
	Common routine for child processes, to close all fds prior to exec(2)
int	ast_control_streamfile (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *suspend, const char *restart, int skipms, long *offsetms)
	Stream a file with fast forward, pause, reverse, restart.
int	ast_control_streamfile_lang (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *suspend, const char *restart, int skipms, const char *lang, long *offsetms)
	Version of ast_control_streamfile() which allows the language of the media file to be specified.
int	ast_control_streamfile_w_cb (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *suspend, const char *restart, int skipms, long *offsetms, ast_waitstream_fr_cb cb)
	Stream a file with fast forward, pause, reverse, restart.
int	ast_control_tone (struct ast_channel *chan, const char *tone)
	Controls playback of a tone.
int	ast_dtmf_stream (struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between, unsigned int duration)
	Send a string of DTMF digits to a channel.
void	ast_dtmf_stream_external (struct ast_channel *chan, const char *digits, int between, unsigned int duration)
	Send a string of DTMF digits to a channel from an external thread.
int	ast_get_encoded_char (const char *stream, char *result, size_t *consumed)
	Decode an encoded control or extended ASCII character.
char *	ast_get_encoded_str (const char *stream, char *result, size_t result_size)
	Decode a stream of encoded control or extended ASCII characters.
void	ast_install_stack_functions (const struct ast_app_stack_funcs *funcs)
	Set stack application function callbacks.
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_mf_stream (struct ast_channel *chan, struct ast_channel *peer, struct ast_channel *chan2, const char *digits, int between, unsigned int duration, unsigned int durationkp, unsigned int durationst, int is_external)
	Send a string of MF digits to a channel.
int	ast_play_and_prepend (struct ast_channel *chan, char *playfile, char *recordfile, int maxtime, char *fmt, int *duration, int *sound_duration, int beep, int silencethreshold, int maxsilence)
	Record a file based on input frm a channel. Recording is performed in 'prepend' mode which works a little differently from normal recordings This function will not play a success message due to post-recording control in the application this was added for.
int	ast_play_and_record (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int *sound_duration, int silencethreshold, int maxsilence, const char *path)
	Record a file based on input from a channel. Use default accept and cancel DTMF. This function will play "auth-thankyou" upon successful recording.
int	ast_play_and_record_full (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int *sound_duration, int beep, int silencethreshold, int maxsilence, const char *path, const char *acceptdtmf, const char *canceldtmf, int skip_confirmation_sound, enum ast_record_if_exists if_exists)
	Record a file based on input from a channel This function will play "auth-thankyou" upon successful recording if skip_confirmation_sound is false.
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.
struct stasis_topic *	ast_queue_topic (const char *queuename)
	Get the Stasis Message Bus API topic for queue messages for a particular queue name.
struct stasis_topic *	ast_queue_topic_all (void)
	Get the Stasis Message Bus API topic for queue messages.
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.
int	ast_safe_fork (int stop_reaper)
	Common routine to safely fork without a chance of a signal handler firing badly in the child.
void	ast_safe_fork_cleanup (void)
	Common routine to cleanup after fork'ed process is complete (if reaping was stopped)
void	ast_set_lock_type (enum AST_LOCK_TYPE type)
	Set the type of locks used by ast_lock_path()
int	ast_sf_stream (struct ast_channel *chan, struct ast_channel *peer, struct ast_channel *chan2, const char *digits, int frequency, int is_external)
	Send a string of SF digits to a channel.
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.
	AST_THREADSTORAGE_PUBLIC (ast_str_thread_global_buf)
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)
int	ast_vm_greeter_is_registered (void)
	Determine if a voicemail greeter provider is registered.
void	ast_vm_greeter_unregister (const char *module_name)
	Unregister the specified voicemail greeter provider.
const char *	ast_vm_index_to_foldername (int id)
	Return name of folder, given an id.
int	ast_vm_is_registered (void)
	Determine if a voicemail provider is registered.
struct ast_vm_mailbox_snapshot *	ast_vm_mailbox_snapshot_create (const char *mailbox, const char *context, const char *folder, int descending, enum ast_vm_snapshot_sort_val sort_val, int combine_INBOX_and_OLD)
	Create a snapshot of a mailbox which contains information about every msg.
struct ast_vm_mailbox_snapshot *	ast_vm_mailbox_snapshot_destroy (struct ast_vm_mailbox_snapshot *mailbox_snapshot)
	destroy a snapshot
int	ast_vm_msg_forward (const char *from_mailbox, const char *from_context, const char *from_folder, const char *to_mailbox, const char *to_context, const char *to_folder, size_t num_msgs, const char *msg_ids[], int delete_old)
	forward a message from one mailbox to another.
int	ast_vm_msg_move (const char *mailbox, const char *context, size_t num_msgs, const char *oldfolder, const char *old_msg_ids[], const char *newfolder)
	Move messages from one folder to another.
int	ast_vm_msg_play (struct ast_channel *chan, const char *mailbox, const char *context, const char *folder, const char *msg_num, ast_vm_msg_play_cb *cb)
	Play a voicemail msg back on a channel.
int	ast_vm_msg_remove (const char *mailbox, const char *context, size_t num_msgs, const char *folder, const char *msgs[])
	Remove/delete messages from a mailbox folder.
void	ast_vm_unregister (const char *module_name)
	Unregister the specified voicemail provider.
static int	control_streamfile (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *suspend, const char *restart, int skipms, long *offsetms, const char *lang, ast_waitstream_fr_cb cb)
static enum control_tone_frame_response_result	control_tone_frame_response (struct ast_channel *chan, struct ast_frame *fr, struct ast_tone_zone_sound *ts, const char *tone, int *paused)
static int	dtmf_stream (struct ast_channel *chan, const char *digits, int between, unsigned int duration, int is_external)
static int	external_sleep (struct ast_channel *chan, int ms)
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 struct ast_frame *	make_silence (const struct ast_frame *orig)
	Construct a silence frame of the same duration as orig.
static int	mf_stream (struct ast_channel *chan, struct ast_channel *chan2, const char *digits, int between, unsigned int duration, unsigned int durationkp, unsigned int durationst, int is_external)
static int	option_exists (struct ast_ivr_menu *menu, char *option)
static int	option_matchmore (struct ast_ivr_menu *menu, char *option)
static int	parse_options (const struct ast_app_option *options, void *_flags, char **args, char *optstr, int flaglen)
static int	parse_tone_uri (char *tone_parser, const char **tone_indication, const char **tone_zone)
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)
static int	set_read_to_slin (struct ast_channel *chan, struct ast_format **orig_format)
	Sets a channel's read format to ast_format_slin, recording its original format.
static int	sf_stream (struct ast_channel *chan, struct ast_channel *chan2, const char *digits, int frequency, int is_external)
static void *	shaun_of_the_dead (void *data)
static void	vm_greeter_warn_no_provider (void)
static void	vm_warn_no_provider (void)

Variables
static const struct ast_app_stack_funcs *	app_stack_callbacks
static enum AST_LOCK_TYPE	ast_lock_type = AST_LOCK_TYPE_LOCKFILE
static const char	default_acceptdtmf [] = "#"
static const char	default_canceldtmf [] = ""
static int	global_maxsilence = 0
static int	global_silence_threshold = 128
static struct groups	groups = AST_RWLIST_HEAD_INIT_VALUE
static struct ast_generator	linearstream
static struct path_lock_list	path_lock_list = AST_LIST_HEAD_INIT_VALUE
static pthread_t	shaun_of_the_dead_thread = AST_PTHREADT_NULL
static int	vm_greeter_warnings
static int	vm_warnings
static struct zombies	zombies = AST_LIST_HEAD_INIT_VALUE
static struct stasis_topic *	queue_topic_all
	Define Stasis Message Bus API topic objects.
static struct stasis_topic_pool *	queue_topic_pool

Detailed Description

Convenient Application Routines.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Definition in file main/app.c.

Macro Definition Documentation

AST_MAX_FORMATS

#define AST_MAX_FORMATS   10

Definition at line 122 of file main/app.c.

FMT

#define FMT   "%30Lf%9s"

RES_EXIT

#define RES_EXIT   (1 << 17)

Definition at line 2742 of file main/app.c.

RES_REPEAT

#define RES_REPEAT   (1 << 18)

Definition at line 2743 of file main/app.c.

RES_RESTART

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

Definition at line 2744 of file main/app.c.

RES_UPONE

#define RES_UPONE   (1 << 16)

Definition at line 2741 of file main/app.c.

SF_BETWEEN

#define SF_BETWEEN   600

SF_BUF_LEN

#define SF_BUF_LEN   20

SF_OFF

#define SF_OFF   33

SF_ON

#define SF_ON   67

VM_API_CALL

#define VM_API_CALL	(		res,
			api_call,
			api_parms
	)

Definition at line 547 of file main/app.c.

       {                                                                    \
        struct ast_vm_functions *table;                                     \
        table = ao2_global_obj_ref(vm_provider);                            \
        if (!table) {                                                       \
            vm_warn_no_provider();                                          \
        } else if (table->api_call) {                                       \
            ast_module_ref(table->module);                                  \
            (res) = table->api_call api_parms;                              \
            ast_module_unref(table->module);                                \
        }                                                                   \
        ao2_cleanup(table);                                                 \
    } while (0)

VM_GREETER_API_CALL

#define VM_GREETER_API_CALL	(		res,
			api_call,
			api_parms
	)

Definition at line 568 of file main/app.c.

       {                                                                    \
        struct ast_vm_greeter_functions *table;                             \
        table = ao2_global_obj_ref(vm_greeter_provider);                    \
        if (!table) {                                                       \
            vm_greeter_warn_no_provider();                                  \
        } else if (table->api_call) {                                       \
            ast_module_ref(table->module);                                  \
            (res) = table->api_call api_parms;                              \
            ast_module_unref(table->module);                                \
        }                                                                   \
        ao2_cleanup(table);                                                 \
    } while (0)

Enumeration Type Documentation

control_tone_frame_response_result

enum control_tone_frame_response_result

Enumerator
CONTROL_TONE_RESPONSE_FAILED
CONTROL_TONE_RESPONSE_NORMAL
CONTROL_TONE_RESPONSE_FINISHED

Definition at line 1481 of file main/app.c.

                                        {
    CONTROL_TONE_RESPONSE_FAILED = -1,
    CONTROL_TONE_RESPONSE_NORMAL = 0,
    CONTROL_TONE_RESPONSE_FINISHED = 1,
};

Function Documentation

__ast_app_separate_args()

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 2357 of file main/app.c.

{
    int argc;
    char *scan, *wasdelim = NULL;
    int paren = 0, quote = 0, bracket = 0;
 
    if (!array || !arraylen) {
        return 0;
    }
 
    memset(array, 0, arraylen * sizeof(*array));
 
    if (!buf) {
        return 0;
    }
 
    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 == '[') {
                bracket++;
            } else if (*scan == ']') {
                if (bracket) {
                    bracket--;
                }
            } 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 && !bracket) {
                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;
}

References array(), buf, NULL, paren, and quote().

__ast_play_and_record()

static int __ast_play_and_record ( struct ast_channel *  chan, const char *  playfile, const char *  recordfile, int  maxtime, const char *  fmt, int *  duration, int *  sound_duration, int  beep, int  silencethreshold, int  maxsilence, const char *  path, int  prepend, const char *  acceptdtmf, const char *  canceldtmf, int  skip_confirmation_sound, enum ast_record_if_exists  if_exists  )

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 seconds).
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).
sound_duration	Where to store the length of the recorded message (in milliseconds), minus any silence
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 and follow prepend mode recording rules
acceptdtmf	DTMF digits that will end the recording.
canceldtmf	DTMF digits that will cancel the recording.
skip_confirmation_sound	If true, don't play auth-thankyou at end. Nice for custom recording prompts in apps.
if_exists

Return values

-1	failure or hangup
'S'	Recording ended from silence timeout
't'	Recording ended from the message exceeding the maximum duration, or via DTMF in prepend mode
dtmfchar	Recording ended via the return value's DTMF character for either cancel or accept.

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 1728 of file main/app.c.

{
    int d = 0;
    char *fmts;
    char comment[256];
    int x, fmtcnt = 1, res = -1, outmsg = 0;
    struct ast_filestream *others[AST_MAX_FORMATS];
    const char *sfmt[AST_MAX_FORMATS];
    char *stringp = NULL;
    time_t start, end;
    struct ast_dsp *sildet = NULL;   /* silence detector dsp */
    int totalsilence = 0;
    int dspsilence = 0;
    int olddspsilence = 0;
    struct ast_format *rfmt = NULL;
    struct ast_silence_generator *silgen = NULL;
    char prependfile[PATH_MAX];
    int ioflags;    /* IO flags for writing output file */
    SCOPE_ENTER(3, "%s: play: '%s'  record: '%s'  path: '%s'  prepend: %d\n",
        ast_channel_name(chan), playfile, recordfile, path, prepend);
 
    ioflags = O_CREAT|O_WRONLY;
 
    switch (if_exists) {
    case AST_RECORD_IF_EXISTS_FAIL:
        ioflags |= O_EXCL;
        break;
    case AST_RECORD_IF_EXISTS_OVERWRITE:
        ioflags |= O_TRUNC;
        break;
    case AST_RECORD_IF_EXISTS_APPEND:
        ioflags |= O_APPEND;
        break;
    case AST_RECORD_IF_EXISTS_ERROR:
        ast_assert(0);
        break;
    }
 
    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, ast_channel_name(chan));
 
    if (playfile || beep) {
        if (!beep) {
            ast_trace(-1, "Playing '%s' to '%s'\n", playfile, ast_channel_name(chan));
            d = ast_play_and_wait(chan, playfile);
        }
        if (d > -1) {
            ast_trace(-1, "Playing 'beep' to '%s'\n", ast_channel_name(chan));
            d = ast_stream_and_wait(chan, "beep", "");
        }
        if (d < 0) {
            SCOPE_EXIT_RTN_VALUE(-1, "Failed to play. RC: %d\n", d);
        }
    }
 
    if (prepend) {
        ast_copy_string(prependfile, recordfile, sizeof(prependfile));
        strncat(prependfile, "-prepend", sizeof(prependfile) - strlen(prependfile) - 1);
        ast_trace(-1, "Prepending to '%s'\n", prependfile);
    }
 
    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 > AST_MAX_FORMATS - 1) {
            ast_log(LOG_WARNING, "Please increase AST_MAX_FORMATS in file.h\n");
            break;
        }
        /*
         * Storage for 'fmt' is on the stack and held by 'fmts', which is maintained for
         * the rest of this function. So okay to not duplicate 'fmt' here, but only keep
         * a pointer to it.
         */
        sfmt[fmtcnt++] = 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, ioflags, 0, AST_FILE_MODE);
        ast_trace(-1, "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);
        res = set_read_to_slin(chan, &rfmt);
        if (res < 0) {
            ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
            ast_dsp_free(sildet);
            ao2_cleanup(rfmt);
            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, writing the packets we read to the writer(s), until
         * we have reason to stop. */
        struct ast_frame *f;
        int paused = 0;
        int muted = 0;
        time_t pause_start = 0;
        int paused_secs = 0;
        int pausedsilence = 0;
 
        for (;;) {
            if (!(res = ast_waitfor(chan, 2000))) {
                ast_debug(1, "One waitfor failed, trying another\n");
                /* Try one more time in case of masq */
                if (!(res = ast_waitfor(chan, 2000))) {
                    ast_log(LOG_WARNING, "No audio available on %s??\n", ast_channel_name(chan));
                    res = -1;
                }
            }
 
            if (res < 0) {
                f = NULL;
                break;
            }
            if (!(f = ast_read(chan))) {
                break;
            }
            if (f->frametype == AST_FRAME_VOICE) {
                /* write each format */
                if (paused) {
                    /* It's all good */
                    res = 0;
                } else {
                    struct ast_frame *silence = NULL;
                    struct ast_frame *orig = f;
 
                    if (muted) {
                        silence = make_silence(orig);
                        if (!silence) {
                            ast_log(LOG_WARNING, "Error creating silence\n");
                            break;
                        }
                        f = silence;
                    }
                    for (x = 0; x < fmtcnt; x++) {
                        if (prepend && !others[x]) {
                            break;
                        }
                        res = ast_writestream(others[x], f);
                    }
                    ast_frame_dtor(silence);
                    f = orig;
                }
 
                /* Silence Detection */
                if (maxsilence > 0) {
                    dspsilence = 0;
                    ast_dsp_silence(sildet, f, &dspsilence);
                    if (olddspsilence > dspsilence) {
                        totalsilence += olddspsilence;
                    }
                    olddspsilence = dspsilence;
 
                    if (paused) {
                        /* record how much silence there was while we are paused */
                        pausedsilence = dspsilence;
                    } else if (dspsilence > pausedsilence) {
                        /* ignore the paused silence */
                        dspsilence -= pausedsilence;
                    } else {
                        /* dspsilence has reset, reset pausedsilence */
                        pausedsilence = 0;
                    }
 
                    if (dspsilence > maxsilence) {
                        /* Ended happily with silence */
                        ast_verb(3, "Recording automatically stopped after a silence of %d seconds\n", dspsilence/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.integer);
                    res = 't';
                    outmsg = 2;
                    break;
                }
                if (strchr(acceptdtmf, f->subclass.integer)) {
                    ast_verb(3, "User ended message by pressing %c\n", f->subclass.integer);
                    res = f->subclass.integer;
                    outmsg = 2;
                    break;
                }
                if (strchr(canceldtmf, f->subclass.integer)) {
                    ast_verb(3, "User canceled message by pressing %c\n", f->subclass.integer);
                    res = f->subclass.integer;
                    outmsg = 0;
                    break;
                }
            } else if (f->frametype == AST_FRAME_CONTROL) {
                if (f->subclass.integer == AST_CONTROL_RECORD_CANCEL) {
                    ast_verb(3, "Message canceled by control\n");
                    outmsg = 0; /* cancels the recording */
                    res = 0;
                    break;
                } else if (f->subclass.integer == AST_CONTROL_RECORD_STOP) {
                    ast_verb(3, "Message ended by control\n");
                    res = 0;
                    break;
                } else if (f->subclass.integer == AST_CONTROL_RECORD_SUSPEND) {
                    paused = !paused;
                    ast_verb(3, "Message %spaused by control\n",
                        paused ? "" : "un");
                    if (paused) {
                        pause_start = time(NULL);
                    } else {
                        paused_secs += time(NULL) - pause_start;
                    }
                } else if (f->subclass.integer == AST_CONTROL_RECORD_MUTE) {
                    muted = !muted;
                    ast_verb(3, "Message %smuted by control\n",
                        muted ? "" : "un");
                    /* We can only silence slin frames, so
                     * set the mode, if we haven't already
                     * for sildet
                     */
                    if (muted && !rfmt) {
                        ast_verb(3, "Setting read format to linear mode\n");
                        res = set_read_to_slin(chan, &rfmt);
                        if (res < 0) {
                            ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
                            break;
                        }
                    }
                }
            }
            if (maxtime && !paused) {
                end = time(NULL);
                if (maxtime < (end - start - paused_secs)) {
                    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 (sound_duration) {
        *sound_duration = *duration;
    }
 
    if (!prepend) {
        /* Reduce duration by a total silence amount */
        if (olddspsilence <= dspsilence) {
            totalsilence += dspsilence;
        }
 
        if (sound_duration) {
            if (totalsilence > 0) {
                *sound_duration -= (totalsilence - 200) / 1000;
            }
            if (*sound_duration < 0) {
                *sound_duration = 0;
            }
        }
 
        if (dspsilence > 0) {
            *duration -= (dspsilence - 200) / 1000;
        }
 
        if (*duration < 0) {
            *duration = 0;
        }
 
        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 && dspsilence) {
                /* rewind only the trailing silence */
                ast_stream_rewind(others[x], dspsilence - 200);
            }
            ast_truncstream(others[x]);
            ast_closestream(others[x]);
        }
    } else if (prepend && outmsg) {
        struct ast_filestream *realfiles[AST_MAX_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]) {
                break;
            }
            if (!realfiles[x]) {
                ast_closestream(others[x]);
                continue;
            }
            /*!\note Same logic as above. */
            if (dspsilence) {
                ast_stream_rewind(others[x], dspsilence - 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_trace(-1, "Recording Format: sfmts=%s, prependfile %s, recordfile %s\n", sfmt[x], prependfile, recordfile);
            ast_trace(-1, "Deleting the prepend file %s.%s\n", recordfile, sfmt[x]);
            ast_filedelete(prependfile, sfmt[x]);
        }
    } else {
        for (x = 0; x < fmtcnt; x++) {
            if (!others[x]) {
                break;
            }
            ast_closestream(others[x]);
        }
    }
 
    if (rfmt && ast_set_read_format(chan, rfmt)) {
        ast_log(LOG_WARNING, "Unable to restore format %s to channel '%s'\n", ast_format_get_name(rfmt), ast_channel_name(chan));
    }
    ao2_cleanup(rfmt);
    if ((outmsg == 2) && (!skip_confirmation_sound)) {
        ast_stream_and_wait(chan, "auth-thankyou", "");
    }
    if (sildet) {
        ast_dsp_free(sildet);
    }
    SCOPE_EXIT_RTN_VALUE(res, "Done.  RC: %d\n", res);
}

References ao2_cleanup, ast_assert, ast_channel_name(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_closestream(), AST_CONTROL_RECORD_CANCEL, AST_CONTROL_RECORD_MUTE, AST_CONTROL_RECORD_STOP, AST_CONTROL_RECORD_SUSPEND, 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_get_name(), AST_FRAME_CONTROL, AST_FRAME_DTMF, ast_frame_dtor(), AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_indicate(), ast_log, AST_MAX_FORMATS, ast_opt_transmit_silence, ast_play_and_wait(), ast_read(), ast_readfile(), ast_readframe(), AST_RECORD_IF_EXISTS_APPEND, AST_RECORD_IF_EXISTS_ERROR, AST_RECORD_IF_EXISTS_FAIL, AST_RECORD_IF_EXISTS_OVERWRITE, ast_set_read_format(), ast_strdupa, ast_stream_and_wait(), ast_stream_rewind(), ast_tellstream(), ast_trace, ast_truncstream(), ast_unlock_path(), ast_verb, ast_waitfor(), ast_writefile(), ast_writestream(), comment, d, end, ast_frame::frametype, global_maxsilence, global_silence_threshold, ast_frame_subclass::integer, LOG_WARNING, make_silence(), maxsilence, NULL, PATH_MAX, SCOPE_ENTER, SCOPE_EXIT_RTN_VALUE, set_read_to_slin(), silencethreshold, strsep(), ast_frame::subclass, and ast_dsp::totalsilence.

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

__ast_vm_greeter_register()

int __ast_vm_greeter_register	(	const struct ast_vm_greeter_functions *	vm_table,
		struct ast_module *	module
	)

Set voicemail greeter function callbacks.

Since

13.0.0

Parameters

vm_table	Voicemail greeter function table to install.
module	Pointer to the module implementing the interface

Return values

0	on success.
-1	on error.
AST_MODULE_LOAD_DECLINE	if there's already another greeter registered.

Definition at line 479 of file main/app.c.

{
    RAII_VAR(struct ast_vm_greeter_functions *, table, NULL, ao2_cleanup);
 
    if (!vm_table->module_name) {
        ast_log(LOG_ERROR, "Voicemail greeter provider missing required information.\n");
        return -1;
    }
    if (vm_table->module_version != VM_GREETER_MODULE_VERSION) {
        ast_log(LOG_ERROR, "Voicemail greeter provider '%s' has incorrect version\n",
            vm_table->module_name);
        return -1;
    }
 
    table = ao2_global_obj_ref(vm_greeter_provider);
    if (table) {
        ast_log(LOG_WARNING, "Voicemail greeter provider already registered by %s.\n",
            table->module_name);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    table = ao2_alloc_options(sizeof(*table), NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!table) {
        return -1;
    }
    *table = *vm_table;
    table->module = module;
 
    ao2_global_obj_replace_unref(vm_greeter_provider, table);
    return 0;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_replace_unref, ast_log, AST_MODULE_LOAD_DECLINE, LOG_ERROR, LOG_WARNING, ast_vm_functions::module_name, ast_vm_functions::module_version, NULL, RAII_VAR, VM_GREETER_MODULE_VERSION, and vm_table.

__ast_vm_register()

int __ast_vm_register	(	const struct ast_vm_functions *	vm_table,
		struct ast_module *	module
	)

Set voicemail function callbacks.

Parameters

vm_table	Voicemail function table to install.
module	Pointer to the module implementing the interface

Return values

0	on success.
-1	on error.
AST_MODULE_LOAD_DECLINE	if there's already another provider registered.

Definition at line 368 of file main/app.c.

{
    RAII_VAR(struct ast_vm_functions *, table, NULL, ao2_cleanup);
 
    if (!vm_table->module_name) {
        ast_log(LOG_ERROR, "Voicemail provider missing required information.\n");
        return -1;
    }
    if (vm_table->module_version != VM_MODULE_VERSION) {
        ast_log(LOG_ERROR, "Voicemail provider '%s' has incorrect version\n",
            vm_table->module_name);
        return -1;
    }
 
    table = ao2_global_obj_ref(vm_provider);
    if (table) {
        ast_log(LOG_WARNING, "Voicemail provider already registered by %s.\n",
            table->module_name);
        return AST_MODULE_LOAD_DECLINE;
    }
 
    table = ao2_alloc_options(sizeof(*table), NULL, AO2_ALLOC_OPT_LOCK_NOLOCK);
    if (!table) {
        return -1;
    }
    *table = *vm_table;
    table->module = module;
 
    ao2_global_obj_replace_unref(vm_provider, table);
    return 0;
}

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_replace_unref, ast_log, AST_MODULE_LOAD_DECLINE, LOG_ERROR, LOG_WARNING, ast_vm_functions::module_name, ast_vm_functions::module_version, NULL, RAII_VAR, VM_MODULE_VERSION, and vm_table.

AO2_GLOBAL_OBJ_STATIC() [1/2]

static AO2_GLOBAL_OBJ_STATIC ( vm_greeter_provider  )

static

The container for the voicemail greeter provider.

AO2_GLOBAL_OBJ_STATIC() [2/2]

static AO2_GLOBAL_OBJ_STATIC ( vm_provider  )

static

The container for the voicemail provider.

app_cleanup()

static void app_cleanup ( void  )

static

Definition at line 3355 of file main/app.c.

{
#ifdef HAS_CAP
    cap_free(child_cap);
#endif
    ao2_cleanup(queue_topic_pool);
    queue_topic_pool = NULL;
    ao2_cleanup(queue_topic_all);
    queue_topic_all = NULL;
}

References ao2_cleanup, NULL, queue_topic_all, and queue_topic_pool.

Referenced by app_init().

app_init()

int app_init

(

void

)

Initialize the application core.

Return values

0	Success
-1	Failure

Since

12

Definition at line 3366 of file main/app.c.

{
    ast_register_cleanup(app_cleanup);
#ifdef HAVE_CAP
    child_cap = cap_from_text("cap_net_admin-eip");
#endif
    queue_topic_all = stasis_topic_create("queue:all");
    if (!queue_topic_all) {
        return -1;
    }
    queue_topic_pool = stasis_topic_pool_create(queue_topic_all);
    if (!queue_topic_pool) {
        return -1;
    }
    return 0;
}

References app_cleanup(), ast_register_cleanup(), queue_topic_all, queue_topic_pool, stasis_topic_create(), and stasis_topic_pool_create().

Referenced by asterisk_daemon().

ast_app_copy_recording_to_vm()

int ast_app_copy_recording_to_vm

(

struct ast_vm_recording_data *

vm_rec_data

)

param[in] vm_rec_data Contains data needed to make the recording. retval 0 voicemail successfully created from recording. retval -1 Failure

Definition at line 596 of file main/app.c.

{
    int res = -1;
 
    VM_API_CALL(res, copy_recording_to_vm, (vm_rec_data));
    return res;
}

References VM_API_CALL.

Referenced by copy_to_voicemail().

ast_app_dtget()

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 milliseconds

Definition at line 138 of file main/app.c.

{
    struct ast_tone_zone_sound *ts;
    int res = 0, x = 0;
 
    if (maxlen > size) {
        maxlen = size;
    }
 
    if (!timeout) {
        if (ast_channel_pbx(chan) && ast_channel_pbx(chan)->dtimeoutms) {
            timeout = ast_channel_pbx(chan)->dtimeoutms;
        } else {
            timeout = 5000;
        }
    }
 
    if ((ts = ast_get_indication_tone(ast_channel_zone(chan), "dial"))) {
        res = ast_playtones_start(chan, 0, ts->data, 0);
        ts = ast_tone_zone_sound_unref(ts);
    } 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,
            S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL))) {
            break;
        }
    }
 
    if (res >= 0) {
        res = ast_exists_extension(chan, context, collect, 1,
            S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL)) ? 1 : 0;
    }
 
    return res;
}

References ast_channel_caller(), ast_channel_pbx(), ast_channel_zone(), ast_exists_extension(), ast_get_indication_tone(), ast_ignore_pattern(), ast_log, ast_matchmore_extension(), ast_playtones_start(), ast_playtones_stop(), ast_tone_zone_sound_unref(), ast_waitfordigit(), ast_tone_zone_sound::data, ast_pbx::dtimeoutms, LOG_NOTICE, NULL, and S_COR.

Referenced by grab_transfer().

ast_app_exec_sub()

int ast_app_exec_sub	(	struct ast_channel *	autoservice_chan,
		struct ast_channel *	sub_chan,
		const char *	sub_args,
		int	ignore_hangup
	)

Run a subroutine on a channel, placing an optional second channel into autoservice.

Since

11

This is a shorthand method that makes it very easy to run a subroutine on any given channel. It is perfectly reasonable to supply a NULL autoservice_chan here in case there is no channel to place into autoservice.

Note

Absolutely NO channel locks should be held before calling this function.

Parameters

autoservice_chan	A channel to place into autoservice while the subroutine is run
sub_chan	Channel to execute subroutine on.
sub_args	Gosub application argument string.
ignore_hangup	TRUE if a hangup does not stop execution of the routine.

Return values

0	success
-1	on error

Definition at line 297 of file main/app.c.

{
    const struct ast_app_stack_funcs *funcs;
    int res;
 
    funcs = app_stack_callbacks;
    if (!funcs || !funcs->run_sub || !ast_module_running_ref(funcs->module)) {
        ast_log(LOG_WARNING,
            "Cannot run 'Gosub(%s)'.  The app_stack module is not available.\n",
            sub_args);
        return -1;
    }
 
    if (autoservice_chan) {
        ast_autoservice_start(autoservice_chan);
    }
 
    res = funcs->run_sub(sub_chan, sub_args, ignore_hangup);
    ast_module_unref(funcs->module);
 
    if (autoservice_chan) {
        ast_autoservice_stop(autoservice_chan);
    }
 
    if (!ignore_hangup && ast_check_hangup_locked(sub_chan)) {
        ast_queue_hangup(sub_chan);
    }
 
    return res;
}

References app_stack_callbacks, ast_autoservice_start(), ast_autoservice_stop(), ast_check_hangup_locked(), ast_log, ast_module_running_ref, ast_module_unref, ast_queue_hangup(), ignore_hangup, LOG_WARNING, and ast_app_stack_funcs::run_sub.

Referenced by app_exec(), ast_app_run_sub(), ast_pbx_hangup_handler_run(), ast_pre_call(), dial_exec_full(), eval_sub_read(), generic_recall(), originate_exec(), page_exec(), queue_exec(), run_app_helper(), and try_calling().

ast_app_expand_sub_args()

const char * ast_app_expand_sub_args	(	struct ast_channel *	chan,
		const char *	args
	)

Add missing context/exten to subroutine argument string.

Parameters

chan	Channel to obtain context/exten.
args	Gosub application argument string.

Fills in the optional context and exten from the given channel.

Returns

New-args Gosub argument string on success. Must be freed.

Return values

NULL

on error.

Definition at line 278 of file main/app.c.

{
    const struct ast_app_stack_funcs *funcs;
    const char *new_args;
 
    funcs = app_stack_callbacks;
    if (!funcs || !funcs->expand_sub_args || !ast_module_running_ref(funcs->module)) {
        ast_log(LOG_WARNING,
            "Cannot expand 'Gosub(%s)' arguments.  The app_stack module is not available.\n",
            args);
        return NULL;
    }
 
    new_args = funcs->expand_sub_args(chan, args);
    ast_module_unref(funcs->module);
 
    return new_args;
}

References app_stack_callbacks, args, ast_log, ast_module_running_ref, ast_module_unref, ast_app_stack_funcs::expand_sub_args, LOG_WARNING, and NULL.

Referenced by app_exec(), ast_pbx_hangup_handler_push(), dial_exec_full(), and page_exec().

ast_app_getdata()

enum ast_getdata_result ast_app_getdata	(	struct ast_channel *	c,
		const 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). It is also valid for this to be multiple files concatenated by "&". For example, "file1&file2&file3".
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.

Definition at line 188 of file main/app.c.

{
    return ast_app_getdata_terminator(c, prompt, s, maxlen, timeout, NULL);
}

References ast_app_getdata_terminator(), c, NULL, and prompt.

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

ast_app_getdata_full()

int ast_app_getdata_full	(	struct ast_channel *	c,
		const 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 247 of file main/app.c.

{
    int res, to = 2000, fto = 6000;
 
    if (!ast_strlen_zero(prompt)) {
        res = ast_streamfile(c, prompt, ast_channel_language(c));
        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;
}

References ast_channel_language(), ast_readstring_full(), ast_streamfile(), ast_strlen_zero(), c, and prompt.

Referenced by handle_getdata().

ast_app_getdata_terminator()

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

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). It is also valid for this to be multiple files concatenated by "&". For example, "file1&file2&file3".
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.
terminator	A string of characters that may be used as terminators to end input. If NULL, "#" will be used.

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.

Definition at line 193 of file main/app.c.

{
    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 = ast_strsep(&filename, '&', AST_STRSEP_STRIP | AST_STRSEP_TRIM))) {
        if (!ast_strlen_zero(front)) {
            res = ast_streamfile(c, front, ast_channel_language(c));
            if (res)
                continue;
        }
        if (ast_strlen_zero(filename)) {
            /* set timeouts for the last prompt */
            fto = ast_channel_pbx(c) ? ast_channel_pbx(c)->rtimeoutms : 6000;
            to = ast_channel_pbx(c) ? ast_channel_pbx(c)->dtimeoutms : 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 = ast_channel_pbx(c) ? ast_channel_pbx(c)->dtimeoutms : 2000;
        }
        res = ast_readstring(c, s, maxlen, to, fto, (terminator ? terminator : "#"));
        if (res == AST_GETDATA_EMPTY_END_TERMINATED) {
            return res;
        }
        if (!ast_strlen_zero(s)) {
            return res;
        }
    }
 
    return res;
}

References ast_channel_language(), ast_channel_pbx(), AST_GETDATA_EMPTY_END_TERMINATED, ast_readstring(), ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_strsep(), AST_STRSEP_STRIP, AST_STRSEP_TRIM, c, ast_pbx::dtimeoutms, prompt, and ast_pbx::rtimeoutms.

Referenced by ast_app_getdata(), and read_exec().

ast_app_group_discard()

int ast_app_group_discard

(

struct ast_channel *

chan

)

Discard all group counting for a channel.

Definition at line 2320 of file main/app.c.

{
    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;
}

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, ast_group_info::group_list, and NULL.

Referenced by ast_channel_destructor().

ast_app_group_get_count()

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 2241 of file main/app.c.

{
    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;
}

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

Referenced by group_count_function_read().

ast_app_group_list_head()

struct ast_group_info * ast_app_group_list_head

(

void

)

Get the head of the group count list.

Definition at line 2347 of file main/app.c.

{
    return AST_RWLIST_FIRST(&groups);
}

References AST_RWLIST_FIRST.

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

ast_app_group_list_rdlock()

int ast_app_group_list_rdlock

(

void

)

Read Lock the group count list.

Definition at line 2342 of file main/app.c.

{
    return AST_RWLIST_RDLOCK(&groups);
}

References AST_RWLIST_RDLOCK.

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

ast_app_group_list_unlock()

int ast_app_group_list_unlock

(

void

)

Unlock the group count list.

Definition at line 2352 of file main/app.c.

{
    return AST_RWLIST_UNLOCK(&groups);
}

References AST_RWLIST_UNLOCK.

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

ast_app_group_list_wrlock()

int ast_app_group_list_wrlock

(

void

)

Write Lock the group count list.

Definition at line 2337 of file main/app.c.

{
    return AST_RWLIST_WRLOCK(&groups);
}

References AST_RWLIST_WRLOCK.

ast_app_group_match_get_count()

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 2261 of file main/app.c.

{
    struct ast_group_info *gi = NULL;
    regex_t regexbuf_group;
    regex_t regexbuf_category;
    int count = 0;
 
    if (ast_strlen_zero(groupmatch)) {
        ast_log(LOG_NOTICE, "groupmatch empty\n");
        return 0;
    }
 
    /* if regex compilation fails, return zero matches */
    if (regcomp(&regexbuf_group, groupmatch, REG_EXTENDED | REG_NOSUB)) {
        ast_log(LOG_ERROR, "Regex compile failed on: %s\n", groupmatch);
        return 0;
    }
 
    if (!ast_strlen_zero(category) && regcomp(&regexbuf_category, category, REG_EXTENDED | REG_NOSUB)) {
        ast_log(LOG_ERROR, "Regex compile failed on: %s\n", category);
        regfree(&regexbuf_group);
        return 0;
    }
 
    AST_RWLIST_RDLOCK(&groups);
    AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
        if (!regexec(&regexbuf_group, gi->group, 0, NULL, 0) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !regexec(&regexbuf_category, gi->category, 0, NULL, 0)))) {
            count++;
        }
    }
    AST_RWLIST_UNLOCK(&groups);
 
    regfree(&regexbuf_group);
    if (!ast_strlen_zero(category)) {
        regfree(&regexbuf_category);
    }
 
    return count;
}

References ast_log, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_group_info::category, ast_group_info::group, ast_group_info::group_list, LOG_ERROR, LOG_NOTICE, and NULL.

Referenced by AST_TEST_DEFINE(), and group_match_count_function_read().

ast_app_group_set_channel()

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 2194 of file main/app.c.

{
    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);
            ast_free(gi);
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
 
    if (ast_strlen_zero(group)) {
        /* Enable unsetting the group */
    } else if ((gi = ast_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;
}

References ast_app_group_split_group(), ast_calloc, ast_free, 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(), ast_group_info::category, ast_group_info::chan, ast_group_info::group, ast_group_info::group_list, len(), and NULL.

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

ast_app_group_split_group()

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 2167 of file main/app.c.

{
    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;
        if ((cat = strchr(tmp, '@'))) {
            *cat++ = '\0';
        }
    }
 
    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;
}

References ast_copy_string(), ast_strlen_zero(), ast_frame::data, and NULL.

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

ast_app_group_update()

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 2301 of file main/app.c.

{
    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;
}

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, ast_group_info::group_list, and NULL.

Referenced by channel_do_masquerade().

ast_app_has_voicemail()

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

Determine if a given mailbox has any voicemail If folder is NULL, defaults to "INBOX". If folder is "INBOX", includes the number of messages in the "Urgent" folder.

Return values

1	Mailbox has voicemail
0	No new voicemail in specified mailbox
-1	Failure

Since

1.0

Definition at line 582 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, has_voicemail, (mailboxes, folder));
    return res;
}

References has_voicemail(), mailboxes, and VM_API_CALL.

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

ast_app_inboxcount()

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

Determine number of new/old messages in a mailbox.

Since

1.0

Parameters

[in]	mailboxes	Mailbox specification in the format /code mbox[@context][&mbox2[@context2]][...] /code
[out]	newmsgs	Number of messages in the "INBOX" folder. Includes number of messages in the "Urgent" folder, if any.
[out]	oldmsgs	Number of messages in the "Old" folder.

Return values

0	Success
-1	Failure

Definition at line 604 of file main/app.c.

{
    int res = 0;
 
    if (newmsgs) {
        *newmsgs = 0;
    }
    if (oldmsgs) {
        *oldmsgs = 0;
    }
 
    VM_API_CALL(res, inboxcount, (mailboxes, newmsgs, oldmsgs));
    return res;
}

References inboxcount(), mailboxes, and VM_API_CALL.

Referenced by update_registry().

ast_app_inboxcount2()

int ast_app_inboxcount2	(	const char *	mailboxes,
		int *	urgentmsgs,
		int *	newmsgs,
		int *	oldmsgs
	)

Determine number of urgent/new/old messages in a mailbox.

Parameters

[in]	mailboxes	the mailbox context to use
[out]	urgentmsgs	the urgent message count
[out]	newmsgs	the new message count
[out]	oldmsgs	the old message count

Return values

0	for success
negative	upon error

Since

1.6.1

Definition at line 619 of file main/app.c.

{
    int res = 0;
 
    if (newmsgs) {
        *newmsgs = 0;
    }
    if (oldmsgs) {
        *oldmsgs = 0;
    }
    if (urgentmsgs) {
        *urgentmsgs = 0;
    }
 
    VM_API_CALL(res, inboxcount2, (mailboxes, urgentmsgs, newmsgs, oldmsgs));
    return res;
}

References inboxcount2(), mailboxes, and VM_API_CALL.

Referenced by action_mailboxcount(), mwi_retrieve_then_create_state(), notify_new_message(), notify_new_state(), and vm_execmain().

ast_app_messagecount()

int ast_app_messagecount	(	const char *	mailbox_id,
		const char *	folder
	)

Get the number of messages in a given mailbox folder.

Parameters

[in]	mailbox_id	Mailbox name
[in]	folder	The folder to look in. Default is INBOX if not provided.

Note

If requesting INBOX then the returned count is INBOX + Urgent.

Returns

The number of messages in the mailbox folder (zero or more).

Definition at line 645 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, messagecount, (mailbox_id, folder));
    return res;
}

References messagecount(), and VM_API_CALL.

Referenced by acf_vmcount_exec().

ast_app_options2str64()

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 3077 of file main/app.c.

{
    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';
}

References ast_test_flag64, buf, ast_flags64::flags, len(), and options.

ast_app_parse_options()

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

Return values

zero	for success
non-zero	if an error occurs

See also

AST_APP_OPTIONS

Definition at line 3067 of file main/app.c.

{
    return parse_options(options, flags, args, optstr, 32);
}

References args, ast_flags64::flags, options, and parse_options().

Referenced by agent_login_exec(), app_exec(), app_exec(), app_exec(), aqm_exec(), ast_multicast_rtp_create_options(), AST_TEST_DEFINE(), audiosocket_request(), auth_exec(), bridge_exec(), bridgewait_exec(), broadcast_exec(), cdr_read_callback(), cdr_write_callback(), chanspy_exec(), connectedline_write(), controlplayback_exec(), detect_write(), directory_exec(), disa_exec(), dundi_query_read(), dundifunc_read(), extenspy_exec(), forkcdr_exec(), geoloc_profile_read(), geoloc_profile_write(), handle_options(), hint_read(), json_decode_read(), manager_mixmonitor(), minivm_accmess_exec(), minivm_greet_exec(), minivm_record_exec(), mixmonitor_exec(), page_exec(), park_app_parse_data(), pbx_builtin_background(), pbx_builtin_waitexten(), pickupchan_exec(), queue_exec(), read_exec(), read_mf_exec(), read_sf_exec(), readexten_exec(), realtime_common(), receivefax_exec(), record_exec(), redirecting_write(), resetcdr_exec(), senddtmf_exec(), sendfax_exec(), sla_trunk_exec(), smdi_msg_retrieve_read(), sms_exec(), softhangup_exec(), speech_background(), unicast_rtp_request(), vm_exec(), vm_execmain(), volume_write(), wait_exec(), and webchan_request().

ast_app_parse_options64()

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

Return values

zero	for success
non-zero	if an error occurs

See also

AST_APP_OPTIONS

Definition at line 3072 of file main/app.c.

{
    return parse_options(options, flags, args, optstr, 64);
}

References args, ast_flags64::flags, options, and parse_options().

Referenced by AST_TEST_DEFINE(), conf_exec(), dial_exec_full(), find_conf_realtime(), originate_exec(), and sayunixtime_exec().

ast_app_parse_timelen()

int ast_app_parse_timelen	(	const char *	timestr,
		int *	result,
		enum ast_timelen	defunit
	)

Common routine to parse time lengths, with optional time unit specifier.

Parameters

[in]	timestr	String to parse
[in]	defunit	Default unit type
[out]	result	Resulting value, specified in milliseconds

Return values

0	Success
-1	Failure

Since

1.8

Definition at line 3274 of file main/app.c.

{
    int res;
    char u[10];
#ifdef HAVE_LONG_DOUBLE_WIDER
    long double amount;
    #define FMT "%30Lf%9s"
#else
    double amount;
    #define FMT "%30lf%9s"
#endif
    if (!timestr) {
        return -1;
    }
 
    res = sscanf(timestr, FMT, &amount, u);
 
    if (res == 0 || res == EOF) {
#undef FMT
        return -1;
    } else if (res == 2) {
        switch (u[0]) {
        case 'h':
        case 'H':
            unit = TIMELEN_HOURS;
            if (u[1] != '\0') {
                return -1;
            }
            break;
        case 's':
        case 'S':
            unit = TIMELEN_SECONDS;
            if (u[1] != '\0') {
                return -1;
            }
            break;
        case 'm':
        case 'M':
            if (toupper(u[1]) == 'S') {
                unit = TIMELEN_MILLISECONDS;
                if (u[2] != '\0') {
                    return -1;
                }
            } else if (u[1] == '\0') {
                unit = TIMELEN_MINUTES;
            } else {
                return -1;
            }
            break;
        default:
            return -1;
        }
    }
 
    switch (unit) {
    case TIMELEN_HOURS:
        amount *= 60;
        /* fall-through */
    case TIMELEN_MINUTES:
        amount *= 60;
        /* fall-through */
    case TIMELEN_SECONDS:
        amount *= 1000;
        /* fall-through */
    case TIMELEN_MILLISECONDS:
        ;
    }
    *result = amount > INT_MAX ? INT_MAX : (int) amount;
    return 0;
}

References FMT, result, TIMELEN_HOURS, TIMELEN_MILLISECONDS, TIMELEN_MINUTES, and TIMELEN_SECONDS.

Referenced by ast_eivr_senddtmf(), ast_parse_arg(), new_realtime_sqlite3_db(), pbx_builtin_wait(), pbx_builtin_waitdigit(), pbx_builtin_waitexten(), senddtmf_exec(), and sendmf_exec().

ast_app_run_sub()

int ast_app_run_sub	(	struct ast_channel *	autoservice_chan,
		struct ast_channel *	sub_chan,
		const char *	sub_location,
		const char *	sub_args,
		int	ignore_hangup
	)

Run a subroutine on a channel, placing an optional second channel into autoservice.

Since

11

This is a shorthand method that makes it very easy to run a subroutine on any given channel. It is perfectly reasonable to supply a NULL autoservice_chan here in case there is no channel to place into autoservice.

Note

Absolutely NO channel locks should be held before calling this function.

Parameters

autoservice_chan	A channel to place into autoservice while the subroutine is run
sub_chan	Channel to execute subroutine on.
sub_location	The location of the subroutine to run.
sub_args	The arguments to pass to the subroutine.
ignore_hangup	TRUE if a hangup does not stop execution of the routine.

Return values

0	success
-1	on error

Definition at line 328 of file main/app.c.

{
    int res;
    char *args_str;
    size_t args_len;
 
    if (ast_strlen_zero(sub_args)) {
        return ast_app_exec_sub(autoservice_chan, sub_chan, sub_location, ignore_hangup);
    }
 
    /* Create the Gosub application argument string. */
    args_len = strlen(sub_location) + strlen(sub_args) + 3;
    args_str = ast_malloc(args_len);
    if (!args_str) {
        return -1;
    }
    snprintf(args_str, args_len, "%s(%s)", sub_location, sub_args);
 
    res = ast_app_exec_sub(autoservice_chan, sub_chan, args_str, ignore_hangup);
    ast_free(args_str);
    return res;
}

References ast_app_exec_sub(), ast_free, ast_malloc, ast_strlen_zero(), and ignore_hangup.

Referenced by ast_channel_connected_line_sub(), and ast_channel_redirecting_sub().

ast_app_sayname()

int ast_app_sayname	(	struct ast_channel *	chan,
		const char *	mailbox_id
	)

Play a recorded user name for the mailbox to the specified channel.

Parameters

chan	Where to play the recorded name file.
mailbox_id	The mailbox name.

Return values

0	Name played without interruption
dtmf	ASCII value of the DTMF which interrupted playback.
-1	Unable to locate mailbox or hangup occurred.

Definition at line 637 of file main/app.c.

{
    int res = -1;
 
    VM_GREETER_API_CALL(res, sayname, (chan, mailbox_id));
    return res;
}

References sayname(), and VM_GREETER_API_CALL.

Referenced by play_mailbox_owner(), and spy_sayname().

ast_close_fds_above_n()

void ast_close_fds_above_n

(

int

n

)

Common routine for child processes, to close all fds prior to exec(2)

Parameters

[in]

n

starting file descriptor number for closing all higher file descriptors

Since

1.6.1

Definition at line 3203 of file main/app.c.

{
    closefrom(n + 1);
}

References closefrom().

Referenced by app_exec(), asterisk_daemon(), launch_script(), mp3play(), safe_exec_prep(), send_waveform_to_fd(), spawn_mp3(), and vm_check_password_shell().

ast_control_streamfile()

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	Channel
file	File to play.
fwd,rev,stop,pause,restart	DTMF keys for media control
skipms	Number of milliseconds to skip for fwd/rev.
offsetms	Number of milliseconds to skip when starting the media.

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.

Return values

0	on success
Non-zero	on failure

Definition at line 1466 of file main/app.c.

{
    return control_streamfile(chan, file, fwd, rev, stop, suspend, restart, skipms, offsetms, NULL, NULL);
}

References control_streamfile(), NULL, skipms, stop, and suspend().

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

ast_control_streamfile_lang()

int ast_control_streamfile_lang	(	struct ast_channel *	chan,
		const char *	file,
		const char *	fwd,
		const char *	rev,
		const char *	stop,
		const char *	suspend,
		const char *	restart,
		int	skipms,
		const char *	lang,
		long *	offsetms
	)

Version of ast_control_streamfile() which allows the language of the media file to be specified.

Return values

0	on success
Non-zero	on failure

Definition at line 1474 of file main/app.c.

{
    return control_streamfile(chan, file, fwd, rev, stop, suspend, restart, skipms, offsetms, lang, NULL);
}

References control_streamfile(), NULL, skipms, stop, and suspend().

Referenced by play_on_channel().

ast_control_streamfile_w_cb()

int ast_control_streamfile_w_cb	(	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,
		ast_waitstream_fr_cb	cb
	)

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

Parameters

chan
file	filename
fwd,rev,stop,pause,restart,skipms,offsetms
cb	waitstream callback to invoke when fastforward or rewind occurs.

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 1452 of file main/app.c.

{
    return control_streamfile(chan, file, fwd, rev, stop, suspend, restart, skipms, offsetms, NULL, cb);
}

References control_streamfile(), NULL, skipms, stop, and suspend().

ast_control_tone()

int ast_control_tone	(	struct ast_channel *	chan,
		const char *	tone
	)

Controls playback of a tone.

Return values

0	on success
Non-zero	on failure

Definition at line 1546 of file main/app.c.

{
    struct ast_tone_zone *zone = NULL;
    struct ast_tone_zone_sound *ts;
    int paused = 0;
    int res = 0;
 
    const char *tone_indication = NULL;
    const char *tone_zone = NULL;
    char *tone_uri_parser;
 
    if (ast_strlen_zero(tone)) {
        return -1;
    }
 
    tone_uri_parser = ast_strdupa(tone);
 
    if (parse_tone_uri(tone_uri_parser, &tone_indication, &tone_zone)) {
        return -1;
    }
 
    if (tone_zone) {
        zone = ast_get_indication_zone(tone_zone);
    }
 
    ts = ast_get_indication_tone(zone ? zone : ast_channel_zone(chan), tone_indication);
 
    if (ast_playtones_start(chan, 0, ts ? ts->data : tone_indication, 0)) {
        res = -1;
    }
 
    while (!res) {
        struct ast_frame *fr;
 
        if (ast_waitfor(chan, -1) < 0) {
            res = -1;
            break;
        }
 
        fr = ast_read_noaudio(chan);
 
        if (!fr) {
            res = -1;
            break;
        }
 
        if (fr->frametype != AST_FRAME_CONTROL) {
            continue;
        }
 
        res = control_tone_frame_response(chan, fr, ts, tone_indication, &paused);
        if (res == CONTROL_TONE_RESPONSE_FINISHED) {
            res = 0;
            break;
        } else if (res == CONTROL_TONE_RESPONSE_FAILED) {
            res = -1;
            break;
        }
    }
 
    if (ts) {
        ast_tone_zone_sound_unref(ts);
    }
 
    if (zone) {
        ast_tone_zone_unref(zone);
    }
 
    return res;
}

References ast_channel_zone(), AST_FRAME_CONTROL, ast_get_indication_tone(), ast_get_indication_zone(), ast_playtones_start(), ast_read_noaudio(), ast_strdupa, ast_strlen_zero(), ast_tone_zone_sound_unref(), ast_tone_zone_unref(), ast_waitfor(), control_tone_frame_response(), CONTROL_TONE_RESPONSE_FAILED, CONTROL_TONE_RESPONSE_FINISHED, ast_tone_zone_sound::data, ast_frame::frametype, NULL, parse_tone_uri(), and ast_frame::ts.

Referenced by play_on_channel().

ast_dtmf_stream()

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

Send a string of DTMF digits 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.

Precondition

This must only be called by the channel's media handler thread.

Return values

0	on success.
-1	on failure or a channel hung up.

Definition at line 1127 of file main/app.c.

{
    int res;
 
    if (peer && ast_autoservice_start(peer)) {
        return -1;
    }
    res = dtmf_stream(chan, digits, between, duration, 0);
    if (peer && ast_autoservice_stop(peer)) {
        res = -1;
    }
 
    return res;
}

References ast_autoservice_start(), ast_autoservice_stop(), and dtmf_stream().

Referenced by ast_eivr_senddtmf(), bridge_channel_dtmf_stream(), dial_exec_full(), dtmf_no_bridge(), senddtmf_exec(), testclient_exec(), testserver_exec(), and wait_for_answer().

ast_dtmf_stream_external()

void ast_dtmf_stream_external	(	struct ast_channel *	chan,
		const char *	digits,
		int	between,
		unsigned int	duration
	)

Send a string of DTMF digits to a channel from an external thread.

Parameters

chan	The channel that will receive the DTMF frames
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.

Precondition

This must only be called by threads that are not the channel's media handler thread.

Definition at line 1142 of file main/app.c.

{
    dtmf_stream(chan, digits, between, duration, 1);
}

References dtmf_stream().

Referenced by dtmf_in_bridge().

ast_get_encoded_char()

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

Decode an encoded control or extended ASCII character.

Parameters

[in]	stream	String to decode
[out]	result	Decoded character
[out]	consumed	Number of characters used in stream to encode the character

Return values

-1	Stream is of zero length
0	Success

Definition at line 3088 of file main/app.c.

{
    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;
}

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

Referenced by ast_get_encoded_str(), ast_str_get_encoded_str(), cut_internal(), filter(), function_fieldnum_helper(), function_fieldqty_helper(), replace(), shift_pop(), and unshift_push().

ast_get_encoded_str()

char * ast_get_encoded_str	(	const char *	stream,
		char *	result,
		size_t	result_len
	)

Decode a stream of encoded control or extended ASCII characters.

Parameters

[in]	stream	Encoded string
[out]	result	Decoded string
[in]	result_len	Maximum size of the result buffer

Returns

A pointer to the result string

Definition at line 3163 of file main/app.c.

{
    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 result;
}

References ast_get_encoded_char(), and result.

Referenced by chan_pjsip_new(), listfilter(), and replace().

ast_install_stack_functions()

void ast_install_stack_functions

(

const struct ast_app_stack_funcs *

funcs

)

Set stack application function callbacks.

Since

11

Parameters

funcs

Stack applications callback functions.

Definition at line 273 of file main/app.c.

{
    app_stack_callbacks = funcs;
}

References app_stack_callbacks.

Referenced by load_module(), and unload_module().

ast_ivr_menu_run()

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

Runs an IVR menu.

Return values

0	on successful completion.
-1	on hangup.
-2	on user error in menu.

Definition at line 2943 of file main/app.c.

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

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

ast_ivr_menu_run_internal()

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

static

Definition at line 2858 of file main/app.c.

{
    /* 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;
}

References ast_debug, AST_DIGIT_ANY, ast_log, AST_MAX_EXTENSION, ast_channel::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().

ast_linear_stream()

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 1235 of file main/app.c.

{
    struct linear_state *lin;
    char tmpf[256];
    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);
        }
 
        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 = ast_calloc(1, sizeof(*lin));
    if (!lin) {
        if (autoclose) {
            close(fd);
        }
 
        return -1;
    }
 
    lin->fd = fd;
    lin->allowoverride = allowoverride;
    lin->autoclose = autoclose;
 
    return ast_activate_generator(chan, &linearstream, lin);
}

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, linearstream, and LOG_WARNING.

ast_lock_path()

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 2615 of file main/app.c.

{
    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;
}

References AST_LOCK_FAILURE, ast_lock_path_flock(), ast_lock_path_lockfile(), AST_LOCK_TYPE_FLOCK, AST_LOCK_TYPE_LOCKFILE, and path_lock::path.

Referenced by ast_module_reload(), test_vm_api_create_voicemail_files(), vm_lock_path(), and vm_lock_path().

ast_lock_path_flock()

static enum AST_LOCK_RESULT ast_lock_path_flock ( const char *  path )

static

Definition at line 2495 of file main/app.c.

{
    char *fs;
    int res;
    int fd;
    time_t start;
    struct path_lock *pl;
    struct stat st, ost;
 
    fs = ast_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;
        }
    }
    if ((fd = open(fs, O_WRONLY | O_CREAT, 0600)) < 0) {
        ast_log(LOG_WARNING, "Unable to create lock file '%s': %s\n",
                fs, strerror(errno));
        return AST_LOCK_PATH_NOT_FOUND;
    }
    if (!(pl = ast_calloc(1, sizeof(*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 = ast_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;
}

References ast_alloca, 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, ast_strdup, errno, path_lock::fd, LOG_WARNING, NULL, path_lock::path, and path_lock_destroy().

Referenced by ast_lock_path().

ast_lock_path_lockfile()

static enum AST_LOCK_RESULT ast_lock_path_lockfile ( const char *  path )

static

Definition at line 2421 of file main/app.c.

{
    char *s;
    char *fs;
    int res;
    int fd;
    int lp = strlen(path);
    time_t start;
 
    s = ast_alloca(lp + 10);
    fs = ast_alloca(lp + 20);
 
    snprintf(fs, strlen(path) + 19, "%s/.lock-%08lx", path, (unsigned long)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)) {
        sched_yield();
    }
 
    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;
    }
}

References ast_alloca, 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 NULL.

Referenced by ast_lock_path().

ast_mf_stream()

int ast_mf_stream	(	struct ast_channel *	chan,
		struct ast_channel *	peer,
		struct ast_channel *	chan2,
		const char *	digits,
		int	between,
		unsigned int	duration,
		unsigned int	durationkp,
		unsigned int	durationst,
		int	is_external
	)

Send a string of MF digits to a channel.

Parameters

chan	The channel that will receive the MF digits.
peer	(optional) Peer channel that will be autoserviced while the primary channel is receiving MF
chan2	A second channel that will simultaneously receive MF digits. This option may only be used if is_external is 0.
digits	This is a string of characters representing the MF 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' or 'W' to add a wink (if supported by the channel).
between	This is the number of milliseconds to wait in between each MF digit. If zero milliseconds is specified, then the default value of 50 will be used.
duration	This is the duration that each numeric MF digit should have. Default value is 55.
durationkp	This is the duration that each KP digit should have. Default is 120.
durationst	This is the duration that each ST, STP, ST2P, or ST3P digit should have. Default is 65.
is_external	1 if called by a thread that is not the channel's media handler thread, 0 if called by the channel's media handler thread.

Return values

0	on success.
-1	on failure or a channel hung up.

Definition at line 1113 of file main/app.c.

{
    int res;
    if (!is_external && !chan2 && peer && ast_autoservice_start(peer)) {
        return -1;
    }
    res = mf_stream(chan, chan2, digits, between, duration, durationkp, durationst, is_external);
    if (!is_external && !chan2 && peer && ast_autoservice_stop(peer)) {
        res = -1;
    }
    return res;
}

References ast_autoservice_start(), ast_autoservice_stop(), and mf_stream().

Referenced by manager_play_mf(), sendmf_exec(), and wait_for_answer().

ast_play_and_prepend()

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

Record a file based on input frm a channel. Recording is performed in 'prepend' mode which works a little differently from normal recordings This function will not play a success message due to post-recording control in the application this was added for.

Parameters

chan	the channel being recorded
playfile	Filename of sound to play before recording begins
recordfile	Filename to save the recording
maxtime_sec	Longest possible message length in seconds
fmt	string containing all formats to be recorded delimited by '|'
duration	pointer to integer for storing length of the recording
sound_duration	pointer to integer for storing length of the recording minus all silence
beep	whether to play a beep to prompt the recording
silencethreshold	tolerance of noise levels that can be considered silence for the purpose of silence timeout, -1 for default
maxsilence_ms	length of time in milliseconds which will trigger a timeout from silence, -1 for default.

Return values

-1	failure or hangup
'S'	Recording ended from silence timeout
't'	Recording either exceeded maximum duration or the call was ended via DTMF

Definition at line 2160 of file main/app.c.

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

References __ast_play_and_record(), AST_RECORD_IF_EXISTS_OVERWRITE, default_acceptdtmf, default_canceldtmf, maxsilence, NULL, and silencethreshold.

Referenced by vm_forwardoptions().

ast_play_and_record()

int ast_play_and_record	(	struct ast_channel *	chan,
		const char *	playfile,
		const char *	recordfile,
		int	maxtime_sec,
		const char *	fmt,
		int *	duration,
		int *	sound_duration,
		int	silencethreshold,
		int	maxsilence_ms,
		const char *	path
	)

Record a file based on input from a channel. Use default accept and cancel DTMF. This function will play "auth-thankyou" upon successful recording.

Parameters

chan	the channel being recorded
playfile	Filename of sound to play before recording begins
recordfile	Filename to save the recording
maxtime_sec	Longest possible message length in seconds
fmt	string containing all formats to be recorded delimited by '|'
duration	pointer to integer for storing length of the recording
sound_duration	pointer to integer for storing length of the recording minus all silence
silencethreshold	tolerance of noise levels that can be considered silence for the purpose of silence timeout, -1 for default
maxsilence_ms	length of time in milliseconds which will trigger a timeout from silence, -1 for default
path	Optional filesystem path to unlock

Return values

-1	failure or hangup
'S'	Recording ended from silence timeout
't'	Recording ended from the message exceeding the maximum duration
dtmfchar	Recording ended via the return value's DTMF character for either cancel or accept.

Definition at line 2155 of file main/app.c.

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

References __ast_play_and_record(), AST_RECORD_IF_EXISTS_OVERWRITE, default_acceptdtmf, default_canceldtmf, maxsilence, and silencethreshold.

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

ast_play_and_record_full()

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 *	sound_duration,
		int	beep,
		int	silencethreshold,
		int	maxsilence_ms,
		const char *	path,
		const char *	acceptdtmf,
		const char *	canceldtmf,
		int	skip_confirmation_sound,
		enum ast_record_if_exists	if_exists
	)

Record a file based on input from a channel This function will play "auth-thankyou" upon successful recording if skip_confirmation_sound is false.

Parameters

chan	the channel being recorded
playfile	Filename of sound to play before recording begins. A beep is also played when playfile completes, before the recording begins.
recordfile	Filename to save the recording
maxtime_sec	Longest possible message length in seconds
fmt	string containing all formats to be recorded delimited by '|'
duration	pointer to integer for storing length of the recording
beep	If true, play a beep before recording begins (and doesn't play playfile)
sound_duration	pointer to integer for storing length of the recording minus all silence
silencethreshold	tolerance of noise levels that can be considered silence for the purpose of silence timeout, -1 for default
maxsilence_ms	Length of time in milliseconds which will trigger a timeout from silence, -1 for default
path	Optional filesystem path to unlock
acceptdtmf	Character of DTMF to end and accept the recording
canceldtmf	Character of DTMF to end and cancel the recording
skip_confirmation_sound	If true, don't play auth-thankyou at end. Nice for custom recording prompts in apps.
if_exists	Action to take if recording already exists.

Return values

-1	failure or hangup
'S'	Recording ended from silence timeout
't'	Recording ended from the message exceeding the maximum duration
dtmfchar	Recording ended via the return value's DTMF character for either cancel or accept.

Definition at line 2150 of file main/app.c.

{
    return __ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, sound_duration, beep, silencethreshold, maxsilence, path, 0, S_OR(acceptdtmf, ""), S_OR(canceldtmf, default_canceldtmf), skip_confirmation_sound, if_exists);
}

References __ast_play_and_record(), default_canceldtmf, maxsilence, S_OR, and silencethreshold.

Referenced by play_record_review(), play_record_review(), and record_file().

ast_play_and_wait()

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 1617 of file main/app.c.

{
    int d = 0;
 
    if ((d = ast_streamfile(chan, fn, ast_channel_language(chan)))) {
        return d;
    }
 
    d = ast_waitstream(chan, AST_DIGIT_ANY);
 
    ast_stopstream(chan);
 
    return d;
}

References ast_channel_language(), AST_DIGIT_ANY, ast_stopstream(), ast_streamfile(), ast_waitstream(), and d.

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(), get_folder_ja(), leave_voicemail(), minivm_greet_exec(), play_message_category(), play_message_duration(), play_record_review(), play_record_review(), vm_authenticate(), vm_browse_messages_en(), vm_browse_messages_es(), vm_browse_messages_gr(), vm_browse_messages_he(), vm_browse_messages_it(), vm_browse_messages_ja(), vm_browse_messages_pt(), vm_browse_messages_vi(), vm_browse_messages_zh(), vm_exec(), vm_execmain(), vm_forwardoptions(), vm_instructions_en(), vm_instructions_ja(), vm_instructions_zh(), vm_intro(), vm_intro_cs(), vm_intro_da(), vm_intro_de(), vm_intro_en(), vm_intro_es(), vm_intro_fr(), vm_intro_gr(), vm_intro_he(), vm_intro_is(), vm_intro_it(), vm_intro_ja(), vm_intro_multilang(), vm_intro_nl(), vm_intro_no(), vm_intro_pl(), vm_intro_pt(), vm_intro_pt_BR(), vm_intro_se(), vm_intro_vi(), vm_intro_zh(), vm_newuser_setup(), vm_options(), vm_play_folder_name(), vm_play_folder_name_gr(), vm_play_folder_name_ja(), vm_play_folder_name_pl(), vm_play_folder_name_ua(), vm_tempgreeting(), and vmauthenticate().

ast_queue_topic()

struct stasis_topic * ast_queue_topic

(

const char *

queuename

)

Get the Stasis Message Bus API topic for queue messages for a particular queue name.

Parameters

queuename

The name for which to get the topic

Returns

The topic structure for queue messages for a given name

Return values

NULL	if it failed to be found or allocated

Since

12

Definition at line 3350 of file main/app.c.

{
    return stasis_topic_pool_get_topic(queue_topic_pool, queuename);
}

References queue_topic_pool, and stasis_topic_pool_get_topic().

Referenced by send_agent_complete().

ast_queue_topic_all()

struct stasis_topic * ast_queue_topic_all

(

void

)

Get the Stasis Message Bus API topic for queue messages.

Returns

The topic structure for queue messages

Return values

NULL	if it has not been allocated

Since

12

Definition at line 3345 of file main/app.c.

{
    return queue_topic_all;
}

References queue_topic_all.

Referenced by load_module().

ast_read_textfile()

char * ast_read_textfile

(

const char *

filename

)

Read a file into asterisk.

Definition at line 2950 of file main/app.c.

{
    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;
}

References ast_free, ast_log, ast_malloc, errno, LOG_WARNING, and NULL.

Referenced by ast_tcptls_server_start().

ast_record_review()

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 2647 of file main/app.c.

{
    int silencethreshold;
    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 */
 
    silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
 
    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 */
            ast_verb(3, "R%secording\n", recorded == 1 ? "e-r" : "");
            recorded = 1;
            if ((cmd = ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, NULL, silencethreshold, maxsilence, path)) == -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 {
                if (!(cmd = ast_play_and_wait(chan, "vm-torerecord"))) {
                    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;
}

References AST_DIGIT_ANY, ast_dsp_get_threshold_from_settings(), ast_log, ast_play_and_record(), ast_play_and_wait(), ast_stream_and_wait(), ast_verb, ast_waitfordigit(), LOG_WARNING, maxsilence, NULL, path_lock::path, silencethreshold, and THRESHOLD_SILENCE.

Referenced by conf_rec_name(), and conf_run().

ast_safe_fork()

int ast_safe_fork

(

int

stop_reaper

)

Common routine to safely fork without a chance of a signal handler firing badly in the child.

Parameters

[in]

stop_reaper

flag to determine if sigchld handler is replaced or not

Since

1.6.1

Definition at line 3208 of file main/app.c.

{
    sigset_t signal_set, old_set;
    int pid;
 
    /* Don't let the default signal handler for children reap our status */
    if (stop_reaper) {
        ast_replace_sigchld();
    }
 
    /* GCC 4.9 gives a bogus "right-hand operand of comma expression has
     * no effect" warning */
    (void) sigfillset(&signal_set);
    pthread_sigmask(SIG_BLOCK, &signal_set, &old_set);
 
    pid = fork();
 
    if (pid != 0) {
        /* Fork failed or parent */
        pthread_sigmask(SIG_SETMASK, &old_set, NULL);
        if (!stop_reaper && pid > 0) {
            struct zombie *cur = ast_calloc(1, sizeof(*cur));
            if (cur) {
                cur->pid = pid;
                AST_LIST_LOCK(&zombies);
                AST_LIST_INSERT_TAIL(&zombies, cur, list);
                AST_LIST_UNLOCK(&zombies);
                if (shaun_of_the_dead_thread == AST_PTHREADT_NULL) {
                    if (ast_pthread_create_background(&shaun_of_the_dead_thread, NULL, shaun_of_the_dead, NULL)) {
                        ast_log(LOG_ERROR, "Shaun of the Dead wants to kill zombies, but can't?!!\n");
                        shaun_of_the_dead_thread = AST_PTHREADT_NULL;
                    }
                }
            }
        }
        return pid;
    } else {
        /* Child */
#ifdef HAVE_CAP
        cap_set_proc(child_cap);
#endif
 
        /* Before we unblock our signals, return our trapped signals back to the defaults */
        signal(SIGHUP, SIG_DFL);
        signal(SIGCHLD, SIG_DFL);
        signal(SIGINT, SIG_DFL);
        signal(SIGURG, SIG_DFL);
        signal(SIGTERM, SIG_DFL);
        signal(SIGPIPE, SIG_DFL);
        signal(SIGXFSZ, SIG_DFL);
 
        /* unblock important signal handlers */
        if (pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL)) {
            ast_log(LOG_WARNING, "unable to unblock signals: %s\n", strerror(errno));
            _exit(1);
        }
 
        return pid;
    }
}

References ast_calloc, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, ast_pthread_create_background, AST_PTHREADT_NULL, ast_replace_sigchld(), errno, zombie::list, LOG_ERROR, LOG_WARNING, NULL, zombie::pid, shaun_of_the_dead(), and shaun_of_the_dead_thread.

Referenced by app_exec(), filestream_destructor(), launch_script(), mp3play(), send_waveform_to_fd(), spawn_mp3(), and vm_check_password_shell().

ast_safe_fork_cleanup()

void ast_safe_fork_cleanup

(

void

)

Common routine to cleanup after fork'ed process is complete (if reaping was stopped)

Note

This must not be called unless ast_safe_fork(1) has been called previously.

Since

1.6.1

Definition at line 3269 of file main/app.c.

{
    ast_unreplace_sigchld();
}

References ast_unreplace_sigchld().

Referenced by agi_exec_full().

ast_set_lock_type()

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 2610 of file main/app.c.

{
    ast_lock_type = type;
}

References type.

Referenced by load_asterisk_conf().

ast_sf_stream()

int ast_sf_stream	(	struct ast_channel *	chan,
		struct ast_channel *	peer,
		struct ast_channel *	chan2,
		const char *	digits,
		int	frequency,
		int	is_external
	)

Send a string of SF digits to a channel.

Parameters

chan	The channel that will receive the SF digits
peer	(optional) Peer channel that will be autoserviced while the primary channel is receiving SF
chan2	A second channel that will simultaneously receive SF digits. This option may only be used if is_external is 0.
digits	This is a string of characters representing the SF digits to be sent to the channel. Valid characters are "0123456789". Note: You can pass arguments 'f' or 'F', if you want to Flash the channel (if supported by the channel), or 'w' or 'W' to add a wink (if supported by the channel).
frequency	The frequency to use for signaling. 0 can be specified for the default, which is 2600 Hz.
is_external	1 if called by a thread that is not the channel's media handler thread, 0 if called by the channel's media handler thread.

Return values

0	on success.
-1	on failure or a channel hung up.

Definition at line 1097 of file main/app.c.

{
    int res;
    if (frequency <= 0) {
        frequency = 2600;
    }
    if (!is_external && !chan2 && peer && ast_autoservice_start(peer)) {
        return -1;
    }
    res = sf_stream(chan, chan2, digits, frequency, is_external);
    if (!is_external && !chan2 && peer && ast_autoservice_stop(peer)) {
        res = -1;
    }
    return res;
}

References ast_autoservice_start(), ast_autoservice_stop(), and sf_stream().

Referenced by sendsf_exec(), and wait_for_answer().

ast_str_get_encoded_str()

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 3176 of file main/app.c.

{
    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;
}

References ast_get_encoded_char(), ast_str_buffer(), ast_str_make_space, ast_str_set(), ast_str_size(), ast_str_update(), buf, and str.

Referenced by sendtext_exec(), and system_exec_helper().

AST_THREADSTORAGE_PUBLIC()

AST_THREADSTORAGE_PUBLIC

(

ast_str_thread_global_buf

)

ast_unlock_path()

int ast_unlock_path

(

const char *

path

)

Unlock a path.

Definition at line 2631 of file main/app.c.

{
    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;
}

References AST_LOCK_TYPE_FLOCK, AST_LOCK_TYPE_LOCKFILE, ast_unlock_path_flock(), ast_unlock_path_lockfile(), and path_lock::path.

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

ast_unlock_path_flock()

static int ast_unlock_path_flock ( const char *  path )

static

Definition at line 2580 of file main/app.c.

{
    char *s;
    struct path_lock *p;
 
    s = ast_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_debug(1, "Unlocked path '%s'\n", path);
    } else {
        ast_debug(1, "Failed to unlock path '%s': "
                "lock not found\n", path);
    }
 
    return 0;
}

References ast_alloca, ast_debug, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, path_lock::le, path_lock::path, and path_lock_destroy().

Referenced by ast_unlock_path().

ast_unlock_path_lockfile()

static int ast_unlock_path_lockfile ( const char *  path )

static

Definition at line 2458 of file main/app.c.

{
    char *s;
    int res;
 
    s = ast_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;
}

References ast_alloca, ast_debug, ast_log, errno, and LOG_ERROR.

Referenced by ast_unlock_path().

ast_vm_greeter_is_registered()

int ast_vm_greeter_is_registered

(

void

)

Determine if a voicemail greeter provider is registered.

Since

13.0.0

Return values

0	if no provider registered.
1	if a provider is registered.

Definition at line 468 of file main/app.c.

{
    struct ast_vm_greeter_functions *table;
    int is_registered;
 
    table = ao2_global_obj_ref(vm_greeter_provider);
    is_registered = table ? 1 : 0;
    ao2_cleanup(table);
    return is_registered;
}

References ao2_cleanup, and ao2_global_obj_ref.

ast_vm_greeter_unregister()

void ast_vm_greeter_unregister

(

const char *

module_name

)

Unregister the specified voicemail greeter provider.

Since

13.0.0

Parameters

module_name

The module name of the provider to unregister

Definition at line 511 of file main/app.c.

{
    struct ast_vm_greeter_functions *table;
 
    table = ao2_global_obj_ref(vm_greeter_provider);
    if (table && !strcmp(table->module_name, module_name)) {
        ao2_global_obj_release(vm_greeter_provider);
    }
    ao2_cleanup(table);
}

References ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_release, and ast_vm_greeter_functions::module_name.

Referenced by unload_module().

ast_vm_index_to_foldername()

const char * ast_vm_index_to_foldername

(

int

id

)

Return name of folder, given an id.

Parameters

[in]

id

Folder id

Returns

Name of folder

Definition at line 653 of file main/app.c.

{
    const char *res = NULL;
 
    VM_API_CALL(res, index_to_foldername, (id));
    return res;
}

References NULL, and VM_API_CALL.

ast_vm_is_registered()

int ast_vm_is_registered

(

void

)

Determine if a voicemail provider is registered.

Since

12.0.0

Return values

0	if no provider registered.
1	if a provider is registered.

Definition at line 357 of file main/app.c.

{
    struct ast_vm_functions *table;
    int is_registered;
 
    table = ao2_global_obj_ref(vm_provider);
    is_registered = table ? 1 : 0;
    ao2_cleanup(table);
    return is_registered;
}

References ao2_cleanup, and ao2_global_obj_ref.

ast_vm_mailbox_snapshot_create()

struct ast_vm_mailbox_snapshot * ast_vm_mailbox_snapshot_create	(	const char *	mailbox,
		const char *	context,
		const char *	folder,
		int	descending,
		enum ast_vm_snapshot_sort_val	sort_val,
		int	combine_INBOX_and_OLD
	)

Create a snapshot of a mailbox which contains information about every msg.

Parameters

mailbox	the mailbox to look for
context	the context to look for the mailbox in
folder	OPTIONAL. When not NULL only msgs from the specified folder will be included.
descending	list the msgs in descending order rather than ascending order.
sort_val	What to sort in the snapshot.
combine_INBOX_and_OLD	When this argument is set, The OLD folder will be represented in the INBOX folder of the snapshot. This allows the snapshot to represent the OLD and INBOX messages in sorted order merged together.

Returns

snapshot on success

Return values

NULL	on failure

Definition at line 661 of file main/app.c.

{
    struct ast_vm_mailbox_snapshot *res = NULL;
 
    VM_API_CALL(res, mailbox_snapshot_create, (mailbox, context, folder, descending,
        sort_val, combine_INBOX_and_OLD));
    return res;
}

References NULL, and VM_API_CALL.

Referenced by append_vmbox_info_astman(), complete_voicemail_move_message(), show_mailbox_snapshot(), and test_vm_api_remove_all_messages().

ast_vm_mailbox_snapshot_destroy()

struct ast_vm_mailbox_snapshot * ast_vm_mailbox_snapshot_destroy

(

struct ast_vm_mailbox_snapshot *

mailbox_snapshot

)

destroy a snapshot

Parameters

mailbox_snapshot

The snapshot to destroy.

Return values

NULL

Definition at line 675 of file main/app.c.

{
    struct ast_vm_mailbox_snapshot *res = NULL;
 
    VM_API_CALL(res, mailbox_snapshot_destroy, (mailbox_snapshot));
    return res;
}

References NULL, and VM_API_CALL.

Referenced by append_vmbox_info_astman(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), complete_voicemail_move_message(), show_mailbox_snapshot(), and test_vm_api_remove_all_messages().

ast_vm_msg_forward()

int ast_vm_msg_forward	(	const char *	from_mailbox,
		const char *	from_context,
		const char *	from_folder,
		const char *	to_mailbox,
		const char *	to_context,
		const char *	to_folder,
		size_t	num_msgs,
		const char *	msg_ids[],
		int	delete_old
	)

forward a message from one mailbox to another.

from_mailbox The original mailbox the message is being forwarded from

from_context The voicemail context of the from_mailbox

from_folder The folder from which the message is being forwarded

to_mailbox The mailbox to forward the message to

to_context The voicemail context of the to_mailbox

to_folder The folder to which the message is being forwarded

num_msgs The number of messages being forwarded

msg_ids The message IDs of the messages in from_mailbox to forward

delete_old If non-zero, the forwarded messages are also deleted from from_mailbox. Otherwise, the messages will remain in the from_mailbox.

Return values

-1	Failure
0	Success

Definition at line 709 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, msg_forward, (from_mailbox, from_context, from_folder, to_mailbox,
        to_context, to_folder, num_msgs, msg_ids, delete_old));
    return res;
}

References VM_API_CALL.

ast_vm_msg_move()

int ast_vm_msg_move	(	const char *	mailbox,
		const char *	context,
		size_t	num_msgs,
		const char *	oldfolder,
		const char *	old_msg_ids[],
		const char *	newfolder
	)

Move messages from one folder to another.

Parameters

mailbox	The mailbox to which the folders belong
context	The voicemail context for the mailbox
num_msgs	The number of messages to move
oldfolder	The folder from where messages should be moved
old_msg_ids	The message IDs of the messages to move
newfolder	The folder to which messages should be moved new folder. This array must be num_msgs sized.

Return values

-1	Failure
0	Success

Definition at line 683 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, msg_move, (mailbox, context, num_msgs, oldfolder, old_msg_ids,
        newfolder));
    return res;
}

References VM_API_CALL.

ast_vm_msg_play()

int ast_vm_msg_play	(	struct ast_channel *	chan,
		const char *	mailbox,
		const char *	context,
		const char *	folder,
		const char *	msg_num,
		ast_vm_msg_play_cb *	cb
	)

Play a voicemail msg back on a channel.

Parameters

chan
mailbox	msg is in.
context	of mailbox.
folder	voicemail folder to look in.
msg_num	message number in the voicemailbox to playback to the channel.
cb

Return values

0	success
-1	failure

Definition at line 726 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, msg_play, (chan, mailbox, context, folder, msg_num, cb));
    return res;
}

References VM_API_CALL.

ast_vm_msg_remove()

int ast_vm_msg_remove	(	const char *	mailbox,
		const char *	context,
		size_t	num_msgs,
		const char *	folder,
		const char *	msgs[]
	)

Remove/delete messages from a mailbox folder.

Parameters

mailbox	The mailbox from which to delete messages
context	The voicemail context for the mailbox
num_msgs	The number of messages to delete
folder	The folder from which to remove messages
msgs	The message IDs of the messages to delete

Return values

-1	Failure
0	Success

Definition at line 697 of file main/app.c.

{
    int res = 0;
 
    VM_API_CALL(res, msg_remove, (mailbox, context, num_msgs, folder, msgs));
    return res;
}

References VM_API_CALL.

ast_vm_unregister()

void ast_vm_unregister

(

const char *

module_name

)

Unregister the specified voicemail provider.

Parameters

module_name

The module name of the provider to unregister

Definition at line 400 of file main/app.c.

{
    struct ast_vm_functions *table;
 
    table = ao2_global_obj_ref(vm_provider);
    if (table && !strcmp(table->module_name, module_name)) {
        ao2_global_obj_release(vm_provider);
    }
    ao2_cleanup(table);
}

References ao2_cleanup, ao2_global_obj_ref, ao2_global_obj_release, and ast_vm_functions::module_name.

Referenced by unload_module(), and unload_module().

control_streamfile()

static int control_streamfile ( struct ast_channel *  chan, const char *  file, const char *  fwd, const char *  rev, const char *  stop, const char *  suspend, const char *  restart, int  skipms, long *  offsetms, const char *  lang, ast_waitstream_fr_cb  cb  )

static

Definition at line 1277 of file main/app.c.

{
    char *file_copy = ast_strdupa(file);
    char *breaks = NULL;
    char *end = NULL;
    int blen = 2;
    int res;
    long pause_restart_point = 0;
    long offset = 0;
    struct ast_silence_generator *silgen = NULL;
 
    if (!file) {
        return -1;
    }
    if (offsetms) {
        offset = *offsetms * 8; /* XXX Assumes 8kHz */
    }
    if (lang == NULL) {
        lang = ast_channel_language(chan);
    }
 
    if (stop) {
        blen += strlen(stop);
    }
    if (suspend) {
        blen += strlen(suspend);
    }
    if (restart) {
        blen += strlen(restart);
    }
 
    if (blen > 2) {
        breaks = ast_alloca(blen + 1);
        breaks[0] = '\0';
        if (stop) {
            strcat(breaks, stop);
        }
        if (suspend) {
            strcat(breaks, suspend);
        }
        if (restart) {
            strcat(breaks, restart);
        }
    }
 
    if ((end = strchr(file_copy, ':'))) {
        if (!strcasecmp(end, ":end")) {
            *end = '\0';
            end++;
        } else {
            end = NULL;
        }
    }
 
    for (;;) {
        ast_stopstream(chan);
        res = ast_streamfile(chan, file_copy, lang);
        if (!res) {
            if (pause_restart_point) {
                ast_seekstream(ast_channel_stream(chan), 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(ast_channel_stream(chan), offset, SEEK_END);
                end = NULL;
                offset = 0;
            } else if (offset) {
                ast_verb(3, "ControlPlayback seek to offset %ld\n", offset);
                ast_seekstream(ast_channel_stream(chan), offset, SEEK_SET);
                offset = 0;
            }
            if (cb) {
                res = ast_waitstream_fr_w_cb(chan, breaks, fwd, rev, skipms, cb);
            } else {
                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)) || res == AST_CONTROL_STREAM_RESTART) {
            ast_debug(1, "we'll restart the stream here at next loop\n");
            pause_restart_point = 0;
            ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
                "Control: %s\r\n",
                ast_channel_name(chan),
                "Restart");
            continue;
        }
 
        if ((suspend && strchr(suspend, res)) || res == AST_CONTROL_STREAM_SUSPEND) {
            pause_restart_point = ast_tellstream(ast_channel_stream(chan));
 
            if (ast_opt_transmit_silence) {
                silgen = ast_channel_start_silence_generator(chan);
            }
            ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
                "Control: %s\r\n",
                ast_channel_name(chan),
                "Pause");
            for (;;) {
                ast_stopstream(chan);
                if (!(res = ast_waitfordigit(chan, 1000))) {
                    continue;
                } else if (res == -1 || (suspend && strchr(suspend, res)) || (stop && strchr(stop, res))
                        || res == AST_CONTROL_STREAM_SUSPEND || res == AST_CONTROL_STREAM_STOP) {
                    break;
                }
            }
            if (silgen) {
                ast_channel_stop_silence_generator(chan, silgen);
                silgen = NULL;
            }
 
            if ((suspend && (res == *suspend)) || res == AST_CONTROL_STREAM_SUSPEND) {
                res = 0;
                ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
                    "Control: %s\r\n",
                    ast_channel_name(chan),
                    "Unpause");
                continue;
            }
        }
 
        if (res == -1) {
            break;
        }
 
        /* if we get one of our stop chars, return it to the calling function */
        if ((stop && strchr(stop, res)) || res == AST_CONTROL_STREAM_STOP) {
            ast_test_suite_event_notify("PLAYBACK","Channel: %s\r\n"
                "Control: %s\r\n",
                ast_channel_name(chan),
                "Stop");
            break;
        }
    }
 
    if (pause_restart_point) {
        offset = pause_restart_point;
    } else {
        if (ast_channel_stream(chan)) {
            offset = ast_tellstream(ast_channel_stream(chan));
        } else {
            offset = -8;  /* indicate end of file */
        }
    }
 
    if (offsetms) {
        *offsetms = offset / 8; /* samples --> ms ... XXX Assumes 8 kHz */
    }
 
    ast_stopstream(chan);
 
    return res;
}

References ast_alloca, ast_channel_language(), ast_channel_name(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_channel_stream(), AST_CONTROL_STREAM_RESTART, AST_CONTROL_STREAM_STOP, AST_CONTROL_STREAM_SUSPEND, ast_debug, ast_opt_transmit_silence, ast_seekstream(), ast_stopstream(), ast_strdupa, ast_streamfile(), ast_tellstream(), ast_test_suite_event_notify, ast_verb, ast_waitfordigit(), ast_waitstream_fr(), ast_waitstream_fr_w_cb(), end, NULL, skipms, stop, and suspend().

Referenced by ast_control_streamfile(), ast_control_streamfile_lang(), and ast_control_streamfile_w_cb().

control_tone_frame_response()

static enum control_tone_frame_response_result control_tone_frame_response ( struct ast_channel *  chan, struct ast_frame *  fr, struct ast_tone_zone_sound *  ts, const char *  tone, int *  paused  )

static

Definition at line 1487 of file main/app.c.

{
    switch (fr->subclass.integer) {
    case AST_CONTROL_STREAM_STOP:
        ast_playtones_stop(chan);
        return CONTROL_TONE_RESPONSE_FINISHED;
    case AST_CONTROL_STREAM_SUSPEND:
        if (*paused) {
            *paused = 0;
            if (ast_playtones_start(chan, 0, ts ? ts->data : tone, 0)) {
                return CONTROL_TONE_RESPONSE_FAILED;
            }
        } else {
            *paused = 1;
            ast_playtones_stop(chan);
        }
        return CONTROL_TONE_RESPONSE_NORMAL;
    case AST_CONTROL_STREAM_RESTART:
        ast_playtones_stop(chan);
        if (ast_playtones_start(chan, 0, ts ? ts->data : tone, 0)) {
            return CONTROL_TONE_RESPONSE_FAILED;
        }
        return CONTROL_TONE_RESPONSE_NORMAL;
    case AST_CONTROL_STREAM_REVERSE:
        ast_log(LOG_NOTICE, "Media control operation 'reverse' not supported for media type 'tone'\n");
        return CONTROL_TONE_RESPONSE_NORMAL;
    case AST_CONTROL_STREAM_FORWARD:
        ast_log(LOG_NOTICE, "Media control operation 'forward' not supported for media type 'tone'\n");
        return CONTROL_TONE_RESPONSE_NORMAL;
    case AST_CONTROL_HANGUP:
    case AST_CONTROL_BUSY:
    case AST_CONTROL_CONGESTION:
        return CONTROL_TONE_RESPONSE_FINISHED;
    }
 
    return CONTROL_TONE_RESPONSE_NORMAL;
}

References AST_CONTROL_BUSY, AST_CONTROL_CONGESTION, AST_CONTROL_HANGUP, AST_CONTROL_STREAM_FORWARD, AST_CONTROL_STREAM_RESTART, AST_CONTROL_STREAM_REVERSE, AST_CONTROL_STREAM_STOP, AST_CONTROL_STREAM_SUSPEND, ast_log, ast_playtones_start(), ast_playtones_stop(), CONTROL_TONE_RESPONSE_FAILED, CONTROL_TONE_RESPONSE_FINISHED, CONTROL_TONE_RESPONSE_NORMAL, ast_tone_zone_sound::data, ast_frame_subclass::integer, LOG_NOTICE, and ast_frame::subclass.

Referenced by ast_control_tone().

dtmf_stream()

static int dtmf_stream ( struct ast_channel *  chan, const char *  digits, int  between, unsigned int  duration, int  is_external  )

static

Definition at line 1029 of file main/app.c.

{
    const char *ptr;
    int res;
    struct ast_silence_generator *silgen = NULL;
    int (*my_sleep)(struct ast_channel *chan, int ms);
    int (*my_senddigit)(struct ast_channel *chan, char digit, unsigned int duration);
 
    if (is_external) {
        my_sleep = external_sleep;
        my_senddigit = ast_senddigit_external;
    } else {
        my_sleep = ast_safe_sleep;
        my_senddigit = ast_senddigit;
    }
 
    if (!between) {
        between = 100;
    }
 
    /* Need a quiet time before sending digits. */
    if (ast_opt_transmit_silence) {
        silgen = ast_channel_start_silence_generator(chan);
    }
    res = my_sleep(chan, 100);
    if (res) {
        goto dtmf_stream_cleanup;
    }
 
    for (ptr = digits; *ptr; ptr++) {
        if (*ptr == 'w') {
            /* 'w' -- wait half a second */
            res = my_sleep(chan, 500);
            if (res) {
                break;
            }
        } else if (*ptr == 'W') {
            /* 'W' -- wait a second */
            res = my_sleep(chan, 1000);
            if (res) {
                break;
            }
        } else if (strchr("0123456789*#abcdfABCDF", *ptr)) {
            if (*ptr == 'f' || *ptr == 'F') {
                /* ignore return values if not supported by channel */
                ast_indicate(chan, AST_CONTROL_FLASH);
            } else {
                /* Character represents valid DTMF */
                my_senddigit(chan, *ptr, duration);
            }
            /* pause between digits */
            res = my_sleep(chan, between);
            if (res) {
                break;
            }
        } else {
            ast_log(LOG_WARNING, "Illegal DTMF character '%c' in string. (0-9*#aAbBcCdD allowed)\n", *ptr);
        }
    }
 
dtmf_stream_cleanup:
    if (silgen) {
        ast_channel_stop_silence_generator(chan, silgen);
    }
 
    return res;
}

References 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_senddigit_external(), digit, external_sleep(), LOG_WARNING, and NULL.

Referenced by ast_dtmf_stream(), and ast_dtmf_stream_external().

external_sleep()

static int external_sleep ( struct ast_channel *  chan, int  ms  )

static

Definition at line 757 of file main/app.c.

{
    usleep(ms * 1000);
    return 0;
}

Referenced by dtmf_stream(), mf_stream(), and sf_stream().

ivr_dispatch()

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

static

Definition at line 2748 of file main/app.c.

{
    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:
        if ((res = ast_ivr_menu_run_internal(chan, (struct ast_ivr_menu *)option->adata, cbdata)) == -2) {
            /* Do not pass entry errors back up, treat as though it was an "UPONE" */
            res = 0;
        }
        return res;
    case AST_ACTION_WAITOPTION:
        if (!(res = ast_waitfordigit(chan, ast_channel_pbx(chan) ? ast_channel_pbx(chan)->rtimeoutms : 10000))) {
            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 %u, ignoring!\n", option->action);
        return 0;
    }
    return -1;
}

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_channel_pbx(), AST_DIGIT_ANY, ast_ivr_menu_run_internal(), ast_log, ast_parseable_goto(), ast_stopstream(), ast_strdupa, ast_stream_and_wait(), ast_waitfordigit(), c, LOG_NOTICE, RES_EXIT, RES_REPEAT, RES_RESTART, RES_UPONE, and strsep().

Referenced by ast_ivr_menu_run_internal().

linear_alloc()

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

static

Definition at line 1201 of file main/app.c.

{
    struct linear_state *ls = params;
 
    if (!params) {
        return NULL;
    }
 
    /* In this case, params is already malloc'd */
    if (ls->allowoverride) {
        ast_set_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
    } else {
        ast_clear_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
    }
 
    ls->origwfmt = ao2_bump(ast_channel_writeformat(chan));
 
    if (ast_set_write_format(chan, ast_format_slin)) {
        ast_log(LOG_WARNING, "Unable to set '%s' to linear format (write)\n", ast_channel_name(chan));
        ao2_cleanup(ls->origwfmt);
        ast_free(ls);
        ls = params = NULL;
    }
 
    return params;
}

References linear_state::allowoverride, ao2_bump, ao2_cleanup, ast_channel_flags(), ast_channel_name(), ast_channel_writeformat(), ast_clear_flag, AST_FLAG_WRITE_INT, ast_format_slin, ast_free, ast_log, ast_set_flag, ast_set_write_format(), LOG_WARNING, NULL, and linear_state::origwfmt.

linear_generator()

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

static

Definition at line 1171 of file main/app.c.

{
    short buf[2048 + AST_FRIENDLY_OFFSET / 2];
    struct linear_state *ls = data;
    struct ast_frame f = {
        .frametype = AST_FRAME_VOICE,
        .data.ptr = buf + AST_FRIENDLY_OFFSET / 2,
        .offset = AST_FRIENDLY_OFFSET,
    };
    int res;
 
    f.subclass.format = ast_format_slin;
 
    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;
}

References ast_format_slin, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log, ast_write(), buf, ast_frame::datalen, linear_state::fd, ast_frame_subclass::format, ast_frame::frametype, len(), LOG_WARNING, ast_frame::samples, and ast_frame::subclass.

linear_release()

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

static

Definition at line 1154 of file main/app.c.

{
    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 '%s'\n",
            ast_channel_name(chan), ast_format_get_name(ls->origwfmt));
    }
    ao2_cleanup(ls->origwfmt);
 
    if (ls->autoclose) {
        close(ls->fd);
    }
 
    ast_free(params);
}

References ao2_cleanup, ast_channel_name(), ast_format_get_name(), ast_free, ast_log, ast_set_write_format(), linear_state::autoclose, linear_state::fd, LOG_WARNING, and linear_state::origwfmt.

make_silence()

static struct ast_frame * make_silence ( const struct ast_frame *  orig )

static

Construct a silence frame of the same duration as orig.

The orig frame must be ast_format_slin.

Parameters

orig	Frame as basis for silence to generate.

Returns

New frame of silence; free with ast_frfree().

Return values

NULL

on error.

Definition at line 1641 of file main/app.c.

{
    struct ast_frame *silence;
    size_t size;
    size_t datalen;
    size_t samples = 0;
 
    if (!orig) {
        return NULL;
    }
    do {
        if (ast_format_cmp(orig->subclass.format, ast_format_slin) == AST_FORMAT_CMP_NOT_EQUAL) {
            ast_log(LOG_WARNING, "Attempting to silence non-slin frame\n");
            return NULL;
        }
 
        samples += orig->samples;
 
        orig = AST_LIST_NEXT(orig, frame_list);
    } while (orig);
 
    ast_verb(4, "Silencing %zu samples\n", samples);
 
 
    datalen = sizeof(short) * samples;
    size = sizeof(*silence) + datalen;
    silence = ast_calloc(1, size);
    if (!silence) {
        return NULL;
    }
 
    silence->mallocd = AST_MALLOCD_HDR;
    silence->frametype = AST_FRAME_VOICE;
    silence->data.ptr = (void *)(silence + 1);
    silence->samples = samples;
    silence->datalen = datalen;
 
    silence->subclass.format = ao2_bump(ast_format_slin);
 
    return silence;
}

References ao2_bump, ast_calloc, ast_format_cmp(), AST_FORMAT_CMP_NOT_EQUAL, ast_format_slin, AST_FRAME_VOICE, AST_LIST_NEXT, ast_log, AST_MALLOCD_HDR, ast_verb, ast_frame::data, ast_frame::datalen, ast_frame_subclass::format, ast_frame::frametype, LOG_WARNING, ast_frame::mallocd, NULL, ast_frame::ptr, ast_frame::samples, and ast_frame::subclass.

Referenced by __ast_play_and_record().

mf_stream()

static int mf_stream ( struct ast_channel *  chan, struct ast_channel *  chan2, const char *  digits, int  between, unsigned int  duration, unsigned int  durationkp, unsigned int  durationst, int  is_external  )

static

Definition at line 914 of file main/app.c.

{
    const char *ptr;
    int res;
    struct ast_silence_generator *silgen = NULL, *silgen2 = NULL;
    int (*my_sleep)(struct ast_channel *chan, int ms);
 
    if (is_external) {
        my_sleep = external_sleep;
    } else {
        my_sleep = ast_safe_sleep;
    }
 
    if (!between) {
        between = 100;
    }
 
    /* Need a quiet time before sending digits. */
    if (ast_opt_transmit_silence) {
        silgen = ast_channel_start_silence_generator(chan);
        if (chan2) {
            silgen2 = ast_channel_start_silence_generator(chan2);
        }
    }
    if (chan2) {
        ast_autoservice_start(chan2);
    }
    res = my_sleep(chan, 100);
    if (chan2) {
        ast_autoservice_stop(chan2);
    }
    if (res) {
        goto mf_stream_cleanup;
    }
 
    for (ptr = digits; *ptr; ptr++) {
        if (*ptr == 'w') {
            /* 'w' -- wait half a second */
            if (chan2) {
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, 500);
            if (chan2) {
                ast_autoservice_stop(chan2);
            }
            if (res) {
                break;
            }
        } else if (*ptr == 'h' || *ptr == 'H') {
            /* 'h' -- 2600 Hz for half a second, but
                only to far end of trunk, not near end */
            ast_playtones_start(chan, 0, "2600", 0);
            if (chan2) {
                ast_playtones_start(chan2, 0, "0", 0);
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, 250);
            ast_senddigit_mf_end(chan);
            if (chan2) {
                ast_autoservice_stop(chan2);
                ast_senddigit_mf_end(chan2);
            }
            if (res) {
                break;
            }
        } else if (strchr("0123456789*#ABCwWfF", *ptr)) {
            if (*ptr == 'f' || *ptr == 'F') {
                /* ignore return values if not supported by channel */
                ast_indicate(chan, AST_CONTROL_FLASH);
            } else if (*ptr == 'W') {
                /* ignore return values if not supported by channel */
                ast_indicate(chan, AST_CONTROL_WINK);
            } else {
                /* Character represents valid MF */
                ast_senddigit_mf(chan, *ptr, duration, durationkp, durationst, is_external);
                if (chan2) {
                    ast_senddigit_mf(chan2, *ptr, duration, durationkp, durationst, is_external);
                }
            }
            /* pause between digits */
            /* The DSP code in Asterisk does not currently properly receive repeated tones
                if no audio is sent in the middle. Simply sending audio (even 0 Hz)
                works around this limitation and guarantees the correct behavior.
                */
            ast_playtones_start(chan, 0, "0", 0);
            if (chan2) {
                ast_playtones_start(chan2, 0, "0", 0);
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, between);
            ast_senddigit_mf_end(chan);
            if (chan2) {
                ast_autoservice_stop(chan2);
                ast_senddigit_mf_end(chan2);
            }
            if (res) {
                break;
            }
        } else {
            ast_log(LOG_WARNING, "Illegal MF character '%c' in string. (0-9*#ABCwWfFhH allowed)\n", *ptr);
        }
    }
 
mf_stream_cleanup:
    if (silgen) {
        ast_channel_stop_silence_generator(chan, silgen);
    }
    if (silgen2) {
        ast_channel_stop_silence_generator(chan2, silgen2);
    }
 
    return res;
}

References ast_autoservice_start(), ast_autoservice_stop(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), AST_CONTROL_FLASH, AST_CONTROL_WINK, ast_indicate(), ast_log, ast_opt_transmit_silence, ast_playtones_start(), ast_safe_sleep(), ast_senddigit_mf(), ast_senddigit_mf_end(), external_sleep(), LOG_WARNING, and NULL.

Referenced by ast_mf_stream().

option_exists()

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

static

Definition at line 2817 of file main/app.c.

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

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

Referenced by ast_ivr_menu_run_internal().

option_matchmore()

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

static

Definition at line 2828 of file main/app.c.

{
    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;
}

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

Referenced by read_newoption().

parse_options()

static int parse_options ( const struct ast_app_option *  options, void *  _flags, char **  args, char *  optstr, int  flaglen  )

static

Definition at line 2984 of file main/app.c.

{
    char *s, *arg;
    int curarg, res = 0;
    unsigned int argloc;
    struct ast_flags *flags = _flags;
    struct ast_flags64 *flags64 = _flags;
 
    if (flaglen == 32) {
        ast_clear_flag(flags, AST_FLAGS_ALL);
    } else {
        flags64->flags = 0;
    }
 
    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 == '(') {
            int paren = 1, quote = 0;
            int parsequotes = (s[1] == '"') ? 1 : 0;
 
            /* Has argument */
            arg = ++s;
            for (; *s; s++) {
                if (*s == '(' && !quote) {
                    paren++;
                } else if (*s == ')' && !quote) {
                    /* Count parentheses, unless they're within quotes (or backslashed, below) */
                    paren--;
                } else if (*s == '"' && parsequotes) {
                    /* Leave embedded quotes alone, unless they are the first character */
                    quote = quote ? 0 : 1;
                    ast_copy_string(s, s + 1, INT_MAX);
                    s--;
                } else if (*s == '\\') {
                    if (!quote) {
                        /* If a backslash is found outside of quotes, remove it */
                        ast_copy_string(s, s + 1, INT_MAX);
                    } else if (quote && s[1] == '"') {
                        /* Backslash for a quote character within quotes, remove the backslash */
                        ast_copy_string(s, s + 1, INT_MAX);
                    } else {
                        /* Backslash within quotes, keep both characters */
                        s++;
                    }
                }
 
                if (paren == 0) {
                    break;
                }
            }
            /* This will find the closing paren we found above, or none, if the string ended before we found one. */
            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] = "";
        }
        if (!options[curarg].flag) {
            ast_log(LOG_WARNING, "Unrecognized option: '%c'\n", curarg);
        }
        if (flaglen == 32) {
            ast_set_flag(flags, options[curarg].flag);
        } else {
            ast_set_flag64(flags64, options[curarg].flag);
        }
    }
 
    return res;
}

References args, ast_clear_flag, ast_copy_string(), AST_FLAGS_ALL, ast_log, ast_set_flag, ast_set_flag64, ast_flags::flags, ast_flags64::flags, LOG_WARNING, options, paren, and quote().

Referenced by ast_app_parse_options(), and ast_app_parse_options64().

parse_tone_uri()

static int parse_tone_uri ( char *  tone_parser, const char **  tone_indication, const char **  tone_zone  )

static

Definition at line 1525 of file main/app.c.

{
    *tone_indication = strsep(&tone_parser, ";");
 
    if (ast_strlen_zero(tone_parser)) {
        /* Only the indication is included */
        return 0;
    }
 
    if (!(strncmp(tone_parser, "tonezone=", 9))) {
        *tone_zone = tone_parser + 9;
    } else {
        ast_log(LOG_ERROR, "Unexpected Tone URI component: %s\n", tone_parser);
        return -1;
    }
 
    return 0;
}

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

Referenced by ast_control_tone().

path_lock_destroy()

static void path_lock_destroy ( struct path_lock *  obj )

static

Definition at line 2484 of file main/app.c.

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

References ast_free, path_lock::fd, and path_lock::path.

Referenced by ast_lock_path_flock(), and ast_unlock_path_flock().

read_newoption()

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

static

Definition at line 2840 of file main/app.c.

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

References ast_channel_pbx(), ast_waitfordigit(), ast_pbx::dtimeoutms, ast_channel::exten, and option_matchmore().

Referenced by ast_ivr_menu_run_internal().

set_read_to_slin()

static int set_read_to_slin ( struct ast_channel *  chan, struct ast_format **  orig_format  )

static

Sets a channel's read format to ast_format_slin, recording its original format.

Parameters

	chan	Channel to modify.
[out]	orig_format	Output variable to store channel's original read format.

Returns

0 on success.

-1 on error.

Definition at line 1693 of file main/app.c.

{
    if (!chan || !orig_format) {
        return -1;
    }
    *orig_format = ao2_bump(ast_channel_readformat(chan));
    return ast_set_read_format(chan, ast_format_slin);
}

References ao2_bump, ast_channel_readformat(), ast_format_slin, and ast_set_read_format().

Referenced by __ast_play_and_record().

sf_stream()

static int sf_stream ( struct ast_channel *  chan, struct ast_channel *  chan2, const char *  digits, int  frequency, int  is_external  )

static

Definition at line 763 of file main/app.c.

{
    /* Bell System Technical Journal 39 (Nov. 1960) */
    #define SF_ON 67
    #define SF_OFF 33
    #define SF_BETWEEN 600
 
    const char *ptr;
    int res;
    struct ast_silence_generator *silgen = NULL, *silgen2 = NULL;
    char *freq;
    int (*my_sleep)(struct ast_channel *chan, int ms);
 
    if (frequency >= 100000) {
        ast_log(LOG_WARNING, "Frequency too large: %d\n", frequency);
        return -1;
    }
 
    if (is_external) {
        my_sleep = external_sleep;
    } else {
        my_sleep = ast_safe_sleep;
    }
 
    /* Need a quiet time before sending digits. */
    if (ast_opt_transmit_silence) {
        silgen = ast_channel_start_silence_generator(chan);
        if (chan2) {
            silgen2 = ast_channel_start_silence_generator(chan2);
        }
    }
    if (chan2) {
        ast_autoservice_start(chan2);
    }
    res = my_sleep(chan, 100);
    if (chan2) {
        ast_autoservice_stop(chan2);
    }
    if (res) {
        goto sf_stream_cleanup;
    }
 
/* len(SF_ON) + len(SF_OFF) + len(0) + maxlen(frequency) + /,/ + null terminator = 2 + 2 + 1 + 5 at most + 3 + 1 = 14 */
#define SF_BUF_LEN  20
    freq = ast_alloca(SF_BUF_LEN); /* min 20 to avoid compiler warning about insufficient buffer */
    /* pauses need to send audio, so send 0 Hz */
    snprintf(freq, SF_BUF_LEN, "%d/%d,%d/%d", frequency, SF_ON, 0, SF_OFF);
 
    for (ptr = digits; *ptr; ptr++) {
        if (*ptr == 'w') {
            /* 'w' -- wait half a second */
            if (chan2) {
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, 500);
            if (chan2) {
                ast_autoservice_stop(chan2);
            }
            if (res) {
                break;
            }
        } else if (*ptr == 'h' || *ptr == 'H') {
            /* 'h' -- 2600 Hz for half a second, but
                only to far end of trunk, not near end */
            ast_playtones_start(chan, 0, "2600", 0);
            if (chan2) {
                ast_playtones_start(chan2, 0, "0", 0);
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, 250);
            ast_senddigit_mf_end(chan);
            if (chan2) {
                ast_autoservice_stop(chan2);
                ast_senddigit_mf_end(chan2);
            }
            if (res) {
                break;
            }
        } else if (strchr("0123456789*#ABCDabcdwWfF", *ptr)) {
            if (*ptr == 'f' || *ptr == 'F') {
                /* ignore return values if not supported by channel */
                ast_indicate(chan, AST_CONTROL_FLASH);
            } else if (*ptr == 'W') {
                /* ignore return values if not supported by channel */
                ast_indicate(chan, AST_CONTROL_WINK);
            } else {
                /* Character represents valid SF */
                int beeps;
                if (*ptr == '*') {
                    beeps = 11;
                } else if (*ptr == '#') {
                    beeps = 12;
                } else if (*ptr == 'D') {
                    beeps = 13;
                } else if (*ptr == 'C') {
                    beeps = 14;
                } else if (*ptr == 'B') {
                    beeps = 15;
                } else if (*ptr == 'A') {
                    beeps = 16;
                } else {
                    beeps = (*ptr == '0') ? 10 : *ptr - '0';
                }
                while (beeps-- > 0) {
                    ast_playtones_start(chan, 0, freq, 0);
                    if (chan2) {
                        ast_playtones_start(chan2, 0, freq, 0);
                        ast_autoservice_start(chan2);
                    }
                    res = my_sleep(chan, SF_ON + SF_OFF);
                    ast_senddigit_mf_end(chan);
                    if (chan2) {
                        ast_autoservice_stop(chan2);
                        ast_senddigit_mf_end(chan2);
                    }
                    if (res) {
                        break;
                    }
                }
            }
            /* pause between digits */
            ast_playtones_start(chan, 0, "0", 0);
            if (chan2) {
                ast_playtones_start(chan2, 0, "0", 0);
                ast_autoservice_start(chan2);
            }
            res = my_sleep(chan, SF_BETWEEN);
            if (chan2) {
                ast_autoservice_stop(chan2);
                ast_senddigit_mf_end(chan2);
            }
            ast_senddigit_mf_end(chan);
            if (res) {
                break;
            }
        } else {
            ast_log(LOG_WARNING, "Illegal SF character '%c' in string. (0-9A-DwWfFhH allowed)\n", *ptr);
        }
    }
 
sf_stream_cleanup:
    if (silgen) {
        ast_channel_stop_silence_generator(chan, silgen);
    }
    if (silgen2) {
        ast_channel_stop_silence_generator(chan2, silgen2);
    }
 
    return res;
}

References ast_alloca, ast_autoservice_start(), ast_autoservice_stop(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), AST_CONTROL_FLASH, AST_CONTROL_WINK, ast_indicate(), ast_log, ast_opt_transmit_silence, ast_playtones_start(), ast_safe_sleep(), ast_senddigit_mf_end(), external_sleep(), LOG_WARNING, NULL, SF_BETWEEN, SF_BUF_LEN, SF_OFF, and SF_ON.

Referenced by ast_sf_stream().

shaun_of_the_dead()

static void * shaun_of_the_dead ( void *  data )

static

Definition at line 95 of file main/app.c.

{
    struct zombie *cur;
    int status;
    for (;;) {
        if (!AST_LIST_EMPTY(&zombies)) {
            /* Don't allow cancellation while we have a lock. */
            pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
            AST_LIST_LOCK(&zombies);
            AST_LIST_TRAVERSE_SAFE_BEGIN(&zombies, cur, list) {
                if (waitpid(cur->pid, &status, WNOHANG) != 0) {
                    AST_LIST_REMOVE_CURRENT(list);
                    ast_free(cur);
                }
            }
            AST_LIST_TRAVERSE_SAFE_END
            AST_LIST_UNLOCK(&zombies);
            pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
        }
        pthread_testcancel();
        /* Wait for 60 seconds, without engaging in a busy loop. */
        ast_poll(NULL, 0, AST_LIST_FIRST(&zombies) ? 5000 : 60000);
    }
    return NULL;
}

References ast_free, AST_LIST_EMPTY, AST_LIST_FIRST, AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_poll, zombie::list, NULL, zombie::pid, and status.

Referenced by ast_safe_fork().

vm_greeter_warn_no_provider()

static void vm_greeter_warn_no_provider ( void  )

static

Definition at line 561 of file main/app.c.

{
    if (vm_greeter_warnings++ % 10 == 0) {
        ast_verb(3, "No voicemail greeter provider registered.\n");
    }
}

References ast_verb, and vm_greeter_warnings.

vm_warn_no_provider()

static void vm_warn_no_provider ( void  )

static

Definition at line 540 of file main/app.c.

{
    if (vm_warnings++ % 10 == 0) {
        ast_verb(3, "No voicemail provider registered.\n");
    }
}

References ast_verb, and vm_warnings.

Variable Documentation

app_stack_callbacks

const struct ast_app_stack_funcs* app_stack_callbacks

static

Definition at line 271 of file main/app.c.

Referenced by ast_app_exec_sub(), ast_app_expand_sub_args(), and ast_install_stack_functions().

ast_lock_type

enum AST_LOCK_TYPE ast_lock_type = AST_LOCK_TYPE_LOCKFILE

static

Definition at line 245 of file main/app.c.

default_acceptdtmf

const char default_acceptdtmf[] = "#"

static

Definition at line 2147 of file main/app.c.

Referenced by ast_play_and_prepend(), and ast_play_and_record().

default_canceldtmf

const char default_canceldtmf[] = ""

static

Definition at line 2148 of file main/app.c.

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

global_maxsilence

int global_maxsilence = 0

static

Definition at line 1703 of file main/app.c.

Referenced by __ast_play_and_record().

global_silence_threshold

int global_silence_threshold = 128

static

Definition at line 1702 of file main/app.c.

Referenced by __ast_play_and_record().

groups

struct groups groups = AST_RWLIST_HEAD_INIT_VALUE

static

linearstream

struct ast_generator linearstream

static

Definition at line 1228 of file main/app.c.

{
    .alloc = linear_alloc,
    .release = linear_release,
    .generate = linear_generator,
};

Referenced by ast_linear_stream().

path_lock_list

struct path_lock_list path_lock_list = AST_LIST_HEAD_INIT_VALUE

static

queue_topic_all

struct stasis_topic* queue_topic_all

static

Define Stasis Message Bus API topic objects.

Definition at line 90 of file main/app.c.

Referenced by app_cleanup(), app_init(), and ast_queue_topic_all().

queue_topic_pool

struct stasis_topic_pool* queue_topic_pool

static

Definition at line 91 of file main/app.c.

Referenced by app_cleanup(), app_init(), and ast_queue_topic().

shaun_of_the_dead_thread

pthread_t shaun_of_the_dead_thread = AST_PTHREADT_NULL

static

Definition at line 74 of file main/app.c.

Referenced by ast_safe_fork().

vm_greeter_warnings

int vm_greeter_warnings

static

Voicemail greeter not registered warning

Definition at line 466 of file main/app.c.

Referenced by vm_greeter_warn_no_provider().

vm_warnings

int vm_warnings

static

Voicemail not registered warning

Definition at line 355 of file main/app.c.

Referenced by vm_warn_no_provider().

zombies

struct zombies zombies = AST_LIST_HEAD_INIT_VALUE

static