Mon Oct 8 12:39:06 2012

Asterisk developer's documentation


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 <dirent.h>
#include <sys/capability.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"

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

Defines

#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)

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)
int ast_app_dtget (struct ast_channel *chan, const char *context, char *collect, size_t size, int maxlen, int timeout)
 Present a dialtone and collect a certain length extension.
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.
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.
ast_group_infoast_app_group_list_head (void)
 Get the head of the group count list.
int ast_app_group_list_rdlock (void)
 Read Lock the group count list.
int ast_app_group_list_unlock (void)
 Unlock the group count list.
int ast_app_group_list_wrlock (void)
 Write Lock the group count list.
int ast_app_group_match_get_count (const char *groupmatch, const char *category)
 Get the current channel count of all groups that match the specified pattern and category.
int ast_app_group_set_channel (struct ast_channel *chan, const char *data)
 Set the group for a channel, splitting the provided data into group and category, if specified.
int ast_app_group_split_group (const char *data, char *group, int group_max, char *category, int category_max)
 Split a group string into group and category, returning a default category if none is provided.
int ast_app_group_update (struct ast_channel *old, struct ast_channel *new)
 Update all group counting for a channel to a new one.
int ast_app_has_voicemail (const char *mailbox, const char *folder)
 Determine if a given mailbox has any voicemail 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 *mailbox, int *newmsgs, int *oldmsgs)
 Determine number of new/old messages in a mailbox.
int ast_app_inboxcount2 (const char *mailbox, int *urgentmsgs, int *newmsgs, int *oldmsgs)
 Determine number of urgent/new/old messages in a mailbox.
int ast_app_messagecount (const char *context, const char *mailbox, const char *folder)
 Check number of messages in a given context, mailbox, and folder.
void ast_app_options2str64 (const struct ast_app_option *options, struct ast_flags64 *flags, char *buf, size_t len)
 Given a list of options array, return an option string based on passed flags.
int ast_app_parse_options (const struct ast_app_option *options, struct ast_flags *flags, char **args, char *optstr)
 Parses a string containing application options and sets flags/arguments.
int ast_app_parse_options64 (const struct ast_app_option *options, struct ast_flags64 *flags, char **args, char *optstr)
 Parses a string containing application options and sets flags/arguments.
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_macro (struct ast_channel *autoservice_chan, struct ast_channel *macro_chan, const char *const macro_name, const char *const macro_args)
 Run a macro on a channel, placing a second channel into autoservice.
int ast_app_sayname (struct ast_channel *chan, const char *mailbox, const char *context)
 Given a mailbox and context, play that mailbox owner's name to the channel specified.
unsigned int ast_app_separate_args (char *buf, char delim, char **array, int arraylen)
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_dtmf_stream (struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between, unsigned int duration)
 Send DTMF to a channel.
int ast_get_encoded_char (const char *stream, char *result, size_t *consumed)
 Decode an encoded control or extended ASCII character.
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_vm_functions (int(*has_voicemail_func)(const char *mailbox, const char *folder), int(*inboxcount_func)(const char *mailbox, int *newmsgs, int *oldmsgs), int(*inboxcount2_func)(const char *mailbox, int *urgentmsgs, int *newmsgs, int *oldmsgs), int(*messagecount_func)(const char *context, const char *mailbox, const char *folder), int(*sayname_func)(struct ast_channel *chan, const char *mailbox, const char *context))
 Set voicemail 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_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 silencethreshold, int maxsilence, const char *path, const char *acceptdtmf, const char *canceldtmf)
 Record a file based on input from a channel This function will play "auth-thankyou" upon successful recording.
int ast_play_and_wait (struct ast_channel *chan, const char *fn)
 Play a stream and wait for a digit, returning the digit that was pressed.
char * ast_read_textfile (const char *filename)
 Read a file into asterisk.
int ast_record_review (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, const char *path)
 Allow to record message and have a review option.
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_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)
void ast_uninstall_vm_functions (void)
int ast_unlock_path (const char *path)
 Unlock a path.
static int ast_unlock_path_flock (const char *path)
static int ast_unlock_path_lockfile (const char *path)
static int ivr_dispatch (struct ast_channel *chan, struct ast_ivr_option *option, char *exten, void *cbdata)
static void * linear_alloc (struct ast_channel *chan, void *params)
static int linear_generator (struct ast_channel *chan, void *data, int len, int samples)
static void linear_release (struct ast_channel *chan, void *params)
static int option_exists (struct ast_ivr_menu *menu, char *option)
static int option_matchmore (struct ast_ivr_menu *menu, char *option)
static int parse_options (const struct ast_app_option *options, void *_flags, char **args, char *optstr, int flaglen)
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 void * shaun_of_the_dead (void *data)

Variables

static int(*) ast_has_voicemail_func (const char *mailbox, const char *folder) = NULL
static int(*) ast_inboxcount2_func (const char *mailbox, int *urgentmsgs, int *newmsgs, int *oldmsgs) = NULL
static int(*) ast_inboxcount_func (const char *mailbox, int *newmsgs, int *oldmsgs) = NULL
static enum AST_LOCK_TYPE ast_lock_type = AST_LOCK_TYPE_LOCKFILE
static int(*) ast_messagecount_func (const char *context, const char *mailbox, const char *folder) = NULL
static int(*) ast_sayname_func (struct ast_channel *chan, const char *mailbox, const char *context) = NULL
static const char default_acceptdtmf [] = "#"
static const char default_canceldtmf [] = ""
static int global_maxsilence = 0
static int global_silence_threshold = 128
static struct ast_generator linearstream
static pthread_t shaun_of_the_dead_thread = AST_PTHREADT_NULL


Detailed Description

Convenient Application Routines.

Author:
Mark Spencer <markster@digium.com>

Definition in file app.c.


Define Documentation

#define AST_MAX_FORMATS   10

Definition at line 101 of file app.c.

#define FMT   "%30Lf%9s"

Referenced by ast_app_parse_timelen().

#define RES_EXIT   (1 << 17)

Definition at line 1651 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_REPEAT   (1 << 18)

Definition at line 1652 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

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

Definition at line 1653 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_UPONE   (1 << 16)

Definition at line 1650 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().


Function Documentation

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

Separate a string into arguments in an array.

Parameters:
buf The string to be parsed (this must be a writable copy, as it will be modified)
delim The character to be used to delimit arguments
remove_chars Remove backslashes and quote characters, while parsing
array An array of 'char *' to be filled in with pointers to the found arguments
arraylen The number of elements in the array (i.e. the number of arguments you will accept)
Note: if there are more arguments in the string than the array will hold, the last element of the array will contain the remaining arguments, not separated.

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

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

Definition at line 1260 of file app.c.

References paren, and quote().

Referenced by ast_app_separate_args().

01261 {
01262    int argc;
01263    char *scan, *wasdelim = NULL;
01264    int paren = 0, quote = 0, bracket = 0;
01265 
01266    if (!array || !arraylen) {
01267       return 0;
01268    }
01269 
01270    memset(array, 0, arraylen * sizeof(*array));
01271 
01272    if (!buf) {
01273       return 0;
01274    }
01275 
01276    scan = buf;
01277 
01278    for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
01279       array[argc] = scan;
01280       for (; *scan; scan++) {
01281          if (*scan == '(') {
01282             paren++;
01283          } else if (*scan == ')') {
01284             if (paren) {
01285                paren--;
01286             }
01287          } else if (*scan == '[') {
01288             bracket++;
01289          } else if (*scan == ']') {
01290             if (bracket) {
01291                bracket--;
01292             }
01293          } else if (*scan == '"' && delim != '"') {
01294             quote = quote ? 0 : 1;
01295             if (remove_chars) {
01296                /* Remove quote character from argument */
01297                memmove(scan, scan + 1, strlen(scan));
01298                scan--;
01299             }
01300          } else if (*scan == '\\') {
01301             if (remove_chars) {
01302                /* Literal character, don't parse */
01303                memmove(scan, scan + 1, strlen(scan));
01304             } else {
01305                scan++;
01306             }
01307          } else if ((*scan == delim) && !paren && !quote && !bracket) {
01308             wasdelim = scan;
01309             *scan++ = '\0';
01310             break;
01311          }
01312       }
01313    }
01314 
01315    /* If the last character in the original string was the delimiter, then
01316     * there is one additional argument. */
01317    if (*scan || (scan > buf && (scan - 1) == wasdelim)) {
01318       array[argc++] = scan;
01319    }
01320 
01321    return argc;
01322 }

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 
) [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.
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 745 of file app.c.

References ast_channel_start_silence_generator(), 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_FORMAT_SLINEAR, AST_FRAME_DTMF, 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_set_read_format(), ast_strdupa, ast_stream_and_wait(), ast_unlock_path(), ast_verb, ast_waitfor(), ast_writefile(), ast_writestream(), comment, f, LOG_WARNING, ast_channel::name, ast_channel::readformat, strsep(), and ast_dsp::totalsilence.

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

00746 {
00747    int d = 0;
00748    char *fmts;
00749    char comment[256];
00750    int x, fmtcnt = 1, res = -1, outmsg = 0;
00751    struct ast_filestream *others[AST_MAX_FORMATS];
00752    char *sfmt[AST_MAX_FORMATS];
00753    char *stringp = NULL;
00754    time_t start, end;
00755    struct ast_dsp *sildet = NULL;   /* silence detector dsp */
00756    int totalsilence = 0;
00757    int dspsilence = 0;
00758    int olddspsilence = 0;
00759    int rfmt = 0;
00760    struct ast_silence_generator *silgen = NULL;
00761    char prependfile[80];
00762 
00763    if (silencethreshold < 0) {
00764       silencethreshold = global_silence_threshold;
00765    }
00766 
00767    if (maxsilence < 0) {
00768       maxsilence = global_maxsilence;
00769    }
00770 
00771    /* barf if no pointer passed to store duration in */
00772    if (!duration) {
00773       ast_log(LOG_WARNING, "Error play_and_record called without duration pointer\n");
00774       return -1;
00775    }
00776 
00777    ast_debug(1, "play_and_record: %s, %s, '%s'\n", playfile ? playfile : "<None>", recordfile, fmt);
00778    snprintf(comment, sizeof(comment), "Playing %s, Recording to: %s on %s\n", playfile ? playfile : "<None>", recordfile, chan->name);
00779 
00780    if (playfile || beep) {
00781       if (!beep) {
00782          d = ast_play_and_wait(chan, playfile);
00783       }
00784       if (d > -1) {
00785          d = ast_stream_and_wait(chan, "beep", "");
00786       }
00787       if (d < 0) {
00788          return -1;
00789       }
00790    }
00791 
00792    if (prepend) {
00793       ast_copy_string(prependfile, recordfile, sizeof(prependfile));
00794       strncat(prependfile, "-prepend", sizeof(prependfile) - strlen(prependfile) - 1);
00795    }
00796 
00797    fmts = ast_strdupa(fmt);
00798 
00799    stringp = fmts;
00800    strsep(&stringp, "|");
00801    ast_debug(1, "Recording Formats: sfmts=%s\n", fmts);
00802    sfmt[0] = ast_strdupa(fmts);
00803 
00804    while ((fmt = strsep(&stringp, "|"))) {
00805       if (fmtcnt > AST_MAX_FORMATS - 1) {
00806          ast_log(LOG_WARNING, "Please increase AST_MAX_FORMATS in file.h\n");
00807          break;
00808       }
00809       sfmt[fmtcnt++] = ast_strdupa(fmt);
00810    }
00811 
00812    end = start = time(NULL);  /* pre-initialize end to be same as start in case we never get into loop */
00813    for (x = 0; x < fmtcnt; x++) {
00814       others[x] = ast_writefile(prepend ? prependfile : recordfile, sfmt[x], comment, O_TRUNC, 0, AST_FILE_MODE);
00815       ast_verb(3, "x=%d, open writing:  %s format: %s, %p\n", x, prepend ? prependfile : recordfile, sfmt[x], others[x]);
00816 
00817       if (!others[x]) {
00818          break;
00819       }
00820    }
00821 
00822    if (path) {
00823       ast_unlock_path(path);
00824    }
00825 
00826    if (maxsilence > 0) {
00827       sildet = ast_dsp_new(); /* Create the silence detector */
00828       if (!sildet) {
00829          ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
00830          return -1;
00831       }
00832       ast_dsp_set_threshold(sildet, silencethreshold);
00833       rfmt = chan->readformat;
00834       res = ast_set_read_format(chan, AST_FORMAT_SLINEAR);
00835       if (res < 0) {
00836          ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
00837          ast_dsp_free(sildet);
00838          return -1;
00839       }
00840    }
00841 
00842    if (!prepend) {
00843       /* Request a video update */
00844       ast_indicate(chan, AST_CONTROL_VIDUPDATE);
00845 
00846       if (ast_opt_transmit_silence) {
00847          silgen = ast_channel_start_silence_generator(chan);
00848       }
00849    }
00850 
00851    if (x == fmtcnt) {
00852       /* Loop forever, writing the packets we read to the writer(s), until
00853          we read a digit or get a hangup */
00854       struct ast_frame *f;
00855       for (;;) {
00856          if (!(res = ast_waitfor(chan, 2000))) {
00857             ast_debug(1, "One waitfor failed, trying another\n");
00858             /* Try one more time in case of masq */
00859             if (!(res = ast_waitfor(chan, 2000))) {
00860                ast_log(LOG_WARNING, "No audio available on %s??\n", chan->name);
00861                res = -1;
00862             }
00863          }
00864 
00865          if (res < 0) {
00866             f = NULL;
00867             break;
00868          }
00869          if (!(f = ast_read(chan))) {
00870             break;
00871          }
00872          if (f->frametype == AST_FRAME_VOICE) {
00873             /* write each format */
00874             for (x = 0; x < fmtcnt; x++) {
00875                if (prepend && !others[x]) {
00876                   break;
00877                }
00878                res = ast_writestream(others[x], f);
00879             }
00880 
00881             /* Silence Detection */
00882             if (maxsilence > 0) {
00883                dspsilence = 0;
00884                ast_dsp_silence(sildet, f, &dspsilence);
00885                if (olddspsilence > dspsilence) {
00886                   totalsilence += olddspsilence;
00887                }
00888                olddspsilence = dspsilence;
00889 
00890                if (dspsilence > maxsilence) {
00891                   /* Ended happily with silence */
00892                   ast_verb(3, "Recording automatically stopped after a silence of %d seconds\n", dspsilence/1000);
00893                   res = 'S';
00894                   outmsg = 2;
00895                   break;
00896                }
00897             }
00898             /* Exit on any error */
00899             if (res) {
00900                ast_log(LOG_WARNING, "Error writing frame\n");
00901                break;
00902             }
00903          } else if (f->frametype == AST_FRAME_VIDEO) {
00904             /* Write only once */
00905             ast_writestream(others[0], f);
00906          } else if (f->frametype == AST_FRAME_DTMF) {
00907             if (prepend) {
00908             /* stop recording with any digit */
00909                ast_verb(3, "User ended message by pressing %c\n", f->subclass.integer);
00910                res = 't';
00911                outmsg = 2;
00912                break;
00913             }
00914             if (strchr(acceptdtmf, f->subclass.integer)) {
00915                ast_verb(3, "User ended message by pressing %c\n", f->subclass.integer);
00916                res = f->subclass.integer;
00917                outmsg = 2;
00918                break;
00919             }
00920             if (strchr(canceldtmf, f->subclass.integer)) {
00921                ast_verb(3, "User cancelled message by pressing %c\n", f->subclass.integer);
00922                res = f->subclass.integer;
00923                outmsg = 0;
00924                break;
00925             }
00926          }
00927          if (maxtime) {
00928             end = time(NULL);
00929             if (maxtime < (end - start)) {
00930                ast_verb(3, "Took too long, cutting it short...\n");
00931                res = 't';
00932                outmsg = 2;
00933                break;
00934             }
00935          }
00936          ast_frfree(f);
00937       }
00938       if (!f) {
00939          ast_verb(3, "User hung up\n");
00940          res = -1;
00941          outmsg = 1;
00942       } else {
00943          ast_frfree(f);
00944       }
00945    } else {
00946       ast_log(LOG_WARNING, "Error creating writestream '%s', format '%s'\n", recordfile, sfmt[x]);
00947    }
00948 
00949    if (!prepend) {
00950       if (silgen) {
00951          ast_channel_stop_silence_generator(chan, silgen);
00952       }
00953    }
00954 
00955    /*!\note
00956     * Instead of asking how much time passed (end - start), calculate the number
00957     * of seconds of audio which actually went into the file.  This fixes a
00958     * problem where audio is stopped up on the network and never gets to us.
00959     *
00960     * Note that we still want to use the number of seconds passed for the max
00961     * message, otherwise we could get a situation where this stream is never
00962     * closed (which would create a resource leak).
00963     */
00964    *duration = others[0] ? ast_tellstream(others[0]) / 8000 : 0;
00965    if (sound_duration) {
00966       *sound_duration = *duration;
00967    }
00968 
00969    if (!prepend) {
00970       /* Reduce duration by a total silence amount */
00971       if (olddspsilence <= dspsilence) {
00972          totalsilence += dspsilence;
00973       }
00974 
00975       if (sound_duration) {
00976          if (totalsilence > 0) {
00977             *sound_duration -= (totalsilence - 200) / 1000;
00978          }
00979          if (*sound_duration < 0) {
00980             *sound_duration = 0;
00981          }
00982       }
00983 
00984       if (dspsilence > 0) {
00985          *duration -= (dspsilence - 200) / 1000;
00986       }
00987       if (*duration < 0) {
00988          *duration = 0;
00989       }
00990 
00991       for (x = 0; x < fmtcnt; x++) {
00992          if (!others[x]) {
00993             break;
00994          }
00995          /*!\note
00996           * If we ended with silence, trim all but the first 200ms of silence
00997           * off the recording.  However, if we ended with '#', we don't want
00998           * to trim ANY part of the recording.
00999           */
01000          if (res > 0 && dspsilence) {
01001                                 /* rewind only the trailing silence */
01002             ast_stream_rewind(others[x], dspsilence - 200);
01003          }
01004          ast_truncstream(others[x]);
01005          ast_closestream(others[x]);
01006       }
01007    }
01008 
01009    if (prepend && outmsg) {
01010       struct ast_filestream *realfiles[AST_MAX_FORMATS];
01011       struct ast_frame *fr;
01012 
01013       for (x = 0; x < fmtcnt; x++) {
01014          snprintf(comment, sizeof(comment), "Opening the real file %s.%s\n", recordfile, sfmt[x]);
01015          realfiles[x] = ast_readfile(recordfile, sfmt[x], comment, O_RDONLY, 0, 0);
01016          if (!others[x] || !realfiles[x]) {
01017             break;
01018          }
01019          /*!\note Same logic as above. */
01020          if (dspsilence) {
01021             ast_stream_rewind(others[x], dspsilence - 200);
01022          }
01023          ast_truncstream(others[x]);
01024          /* add the original file too */
01025          while ((fr = ast_readframe(realfiles[x]))) {
01026             ast_writestream(others[x], fr);
01027             ast_frfree(fr);
01028          }
01029          ast_closestream(others[x]);
01030          ast_closestream(realfiles[x]);
01031          ast_filerename(prependfile, recordfile, sfmt[x]);
01032          ast_verb(4, "Recording Format: sfmts=%s, prependfile %s, recordfile %s\n", sfmt[x], prependfile, recordfile);
01033          ast_filedelete(prependfile, sfmt[x]);
01034       }
01035    }
01036    if (rfmt && ast_set_read_format(chan, rfmt)) {
01037       ast_log(LOG_WARNING, "Unable to restore format %s to channel '%s'\n", ast_getformatname(rfmt), chan->name);
01038    }
01039    if ((outmsg == 2) && (!skip_confirmation_sound)) {
01040       ast_stream_and_wait(chan, "auth-thankyou", "");
01041    }
01042    if (sildet) {
01043       ast_dsp_free(sildet);
01044    }
01045    return res;
01046 }

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

Present a dialtone and collect a certain length extension.

Parameters:
chan struct.
context 
collect 
size 
maxlen 
timeout timeout in milliseconds
Returns:
0 if extension does not exist, 1 if extension exists

Definition at line 119 of file app.c.

References 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_channel::caller, ast_tone_zone_sound::data, ast_pbx::dtimeoutms, ast_party_caller::id, LOG_NOTICE, ast_party_id::number, ast_channel::pbx, S_COR, ast_party_number::str, ast_party_number::valid, and ast_channel::zone.

Referenced by builtin_atxfer(), builtin_blindtransfer(), and grab_transfer().

00120 {
00121    struct ast_tone_zone_sound *ts;
00122    int res = 0, x = 0;
00123 
00124    if (maxlen > size) {
00125       maxlen = size;
00126    }
00127 
00128    if (!timeout) {
00129       if (chan->pbx && chan->pbx->dtimeoutms) {
00130          timeout = chan->pbx->dtimeoutms;
00131       } else {
00132          timeout = 5000;
00133       }
00134    }
00135 
00136    if ((ts = ast_get_indication_tone(chan->zone, "dial"))) {
00137       res = ast_playtones_start(chan, 0, ts->data, 0);
00138       ts = ast_tone_zone_sound_unref(ts);
00139    } else {
00140       ast_log(LOG_NOTICE, "Huh....? no dial for indications?\n");
00141    }
00142 
00143    for (x = strlen(collect); x < maxlen; ) {
00144       res = ast_waitfordigit(chan, timeout);
00145       if (!ast_ignore_pattern(context, collect)) {
00146          ast_playtones_stop(chan);
00147       }
00148       if (res < 1) {
00149          break;
00150       }
00151       if (res == '#') {
00152          break;
00153       }
00154       collect[x++] = res;
00155       if (!ast_matchmore_extension(chan, context, collect, 1,
00156          S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, NULL))) {
00157          break;
00158       }
00159    }
00160 
00161    if (res >= 0) {
00162       res = ast_exists_extension(chan, context, collect, 1,
00163          S_COR(chan->caller.id.number.valid, chan->caller.id.number.str, NULL)) ? 1 : 0;
00164    }
00165 
00166    return res;
00167 }

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

Definition at line 177 of file app.c.

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

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

00178 {
00179    int res = 0, to, fto;
00180    char *front, *filename;
00181 
00182    /* XXX Merge with full version? XXX */
00183 
00184    if (maxlen)
00185       s[0] = '\0';
00186 
00187    if (!prompt)
00188       prompt = "";
00189 
00190    filename = ast_strdupa(prompt);
00191    while ((front = strsep(&filename, "&"))) {
00192       if (!ast_strlen_zero(front)) {
00193          res = ast_streamfile(c, front, c->language);
00194          if (res)
00195             continue;
00196       }
00197       if (ast_strlen_zero(filename)) {
00198          /* set timeouts for the last prompt */
00199          fto = c->pbx ? c->pbx->rtimeoutms : 6000;
00200          to = c->pbx ? c->pbx->dtimeoutms : 2000;
00201 
00202          if (timeout > 0) {
00203             fto = to = timeout;
00204          }
00205          if (timeout < 0) {
00206             fto = to = 1000000000;
00207          }
00208       } else {
00209          /* there is more than one prompt, so
00210           * get rid of the long timeout between
00211           * prompts, and make it 50ms */
00212          fto = 50;
00213          to = c->pbx ? c->pbx->dtimeoutms : 2000;
00214       }
00215       res = ast_readstring(c, s, maxlen, to, fto, "#");
00216       if (res == AST_GETDATA_EMPTY_END_TERMINATED) {
00217          return res;
00218       }
00219       if (!ast_strlen_zero(s)) {
00220          return res;
00221       }
00222    }
00223 
00224    return res;
00225 }

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

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

Referenced by handle_getdata().

00231 {
00232    int res, to = 2000, fto = 6000;
00233 
00234    if (!ast_strlen_zero(prompt)) {
00235       res = ast_streamfile(c, prompt, c->language);
00236       if (res < 0) {
00237          return res;
00238       }
00239    }
00240 
00241    if (timeout > 0) {
00242       fto = to = timeout;
00243    }
00244    if (timeout < 0) {
00245       fto = to = 1000000000;
00246    }
00247 
00248    res = ast_readstring_full(c, s, maxlen, to, fto, "#", audiofd, ctrlfd);
00249 
00250    return res;
00251 }

int ast_app_group_discard ( struct ast_channel chan  ) 

Discard all group counting for a channel.

Definition at line 1220 of file app.c.

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

Referenced by ast_channel_destructor().

01221 {
01222    struct ast_group_info *gi = NULL;
01223 
01224    AST_RWLIST_WRLOCK(&groups);
01225    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01226       if (gi->chan == chan) {
01227          AST_RWLIST_REMOVE_CURRENT(group_list);
01228          ast_free(gi);
01229       }
01230    }
01231    AST_RWLIST_TRAVERSE_SAFE_END;
01232    AST_RWLIST_UNLOCK(&groups);
01233 
01234    return 0;
01235 }

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

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

Referenced by group_count_function_read().

01143 {
01144    struct ast_group_info *gi = NULL;
01145    int count = 0;
01146 
01147    if (ast_strlen_zero(group)) {
01148       return 0;
01149    }
01150 
01151    AST_RWLIST_RDLOCK(&groups);
01152    AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
01153       if (!strcasecmp(gi->group, group) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
01154          count++;
01155       }
01156    }
01157    AST_RWLIST_UNLOCK(&groups);
01158 
01159    return count;
01160 }

struct ast_group_info* ast_app_group_list_head ( void   ) 

Get the head of the group count list.

Definition at line 1247 of file app.c.

References AST_RWLIST_FIRST.

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

01248 {
01249    return AST_RWLIST_FIRST(&groups);
01250 }

int ast_app_group_list_rdlock ( void   ) 

Read Lock the group count list.

Definition at line 1242 of file app.c.

References AST_RWLIST_RDLOCK.

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

01243 {
01244    return AST_RWLIST_RDLOCK(&groups);
01245 }

int ast_app_group_list_unlock ( void   ) 

Unlock the group count list.

Definition at line 1252 of file app.c.

References AST_RWLIST_UNLOCK.

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

01253 {
01254    return AST_RWLIST_UNLOCK(&groups);
01255 }

int ast_app_group_list_wrlock ( void   ) 

Write Lock the group count list.

Definition at line 1237 of file app.c.

References AST_RWLIST_WRLOCK.

01238 {
01239    return AST_RWLIST_WRLOCK(&groups);
01240 }

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

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, and LOG_NOTICE.

Referenced by group_match_count_function_read().

01163 {
01164    struct ast_group_info *gi = NULL;
01165    regex_t regexbuf_group;
01166    regex_t regexbuf_category;
01167    int count = 0;
01168 
01169    if (ast_strlen_zero(groupmatch)) {
01170       ast_log(LOG_NOTICE, "groupmatch empty\n");
01171       return 0;
01172    }
01173 
01174    /* if regex compilation fails, return zero matches */
01175    if (regcomp(&regexbuf_group, groupmatch, REG_EXTENDED | REG_NOSUB)) {
01176       ast_log(LOG_ERROR, "Regex compile failed on: %s\n", groupmatch);
01177       return 0;
01178    }
01179 
01180    if (!ast_strlen_zero(category) && regcomp(&regexbuf_category, category, REG_EXTENDED | REG_NOSUB)) {
01181       ast_log(LOG_ERROR, "Regex compile failed on: %s\n", category);
01182       return 0;
01183    }
01184 
01185    AST_RWLIST_RDLOCK(&groups);
01186    AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
01187       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)))) {
01188          count++;
01189       }
01190    }
01191    AST_RWLIST_UNLOCK(&groups);
01192 
01193    regfree(&regexbuf_group);
01194    if (!ast_strlen_zero(category)) {
01195       regfree(&regexbuf_category);
01196    }
01197 
01198    return count;
01199 }

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

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

Referenced by dial_exec_full(), and group_function_write().

01096 {
01097    int res = 0;
01098    char group[80] = "", category[80] = "";
01099    struct ast_group_info *gi = NULL;
01100    size_t len = 0;
01101 
01102    if (ast_app_group_split_group(data, group, sizeof(group), category, sizeof(category))) {
01103       return -1;
01104    }
01105 
01106    /* Calculate memory we will need if this is new */
01107    len = sizeof(*gi) + strlen(group) + 1;
01108    if (!ast_strlen_zero(category)) {
01109       len += strlen(category) + 1;
01110    }
01111 
01112    AST_RWLIST_WRLOCK(&groups);
01113    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01114       if ((gi->chan == chan) && ((ast_strlen_zero(category) && ast_strlen_zero(gi->category)) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
01115          AST_RWLIST_REMOVE_CURRENT(group_list);
01116          free(gi);
01117          break;
01118       }
01119    }
01120    AST_RWLIST_TRAVERSE_SAFE_END;
01121 
01122    if (ast_strlen_zero(group)) {
01123       /* Enable unsetting the group */
01124    } else if ((gi = calloc(1, len))) {
01125       gi->chan = chan;
01126       gi->group = (char *) gi + sizeof(*gi);
01127       strcpy(gi->group, group);
01128       if (!ast_strlen_zero(category)) {
01129          gi->category = (char *) gi + sizeof(*gi) + strlen(group) + 1;
01130          strcpy(gi->category, category);
01131       }
01132       AST_RWLIST_INSERT_TAIL(&groups, gi, group_list);
01133    } else {
01134       res = -1;
01135    }
01136 
01137    AST_RWLIST_UNLOCK(&groups);
01138 
01139    return res;
01140 }

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

References ast_copy_string(), and ast_strlen_zero().

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

01069 {
01070    int res = 0;
01071    char tmp[256];
01072    char *grp = NULL, *cat = NULL;
01073 
01074    if (!ast_strlen_zero(data)) {
01075       ast_copy_string(tmp, data, sizeof(tmp));
01076       grp = tmp;
01077       if ((cat = strchr(tmp, '@'))) {
01078          *cat++ = '\0';
01079       }
01080    }
01081 
01082    if (!ast_strlen_zero(grp)) {
01083       ast_copy_string(group, grp, group_max);
01084    } else {
01085       *group = '\0';
01086    }
01087 
01088    if (!ast_strlen_zero(cat)) {
01089       ast_copy_string(category, cat, category_max);
01090    }
01091 
01092    return res;
01093 }

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

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

Referenced by ast_do_masquerade(), and check_bridge().

01202 {
01203    struct ast_group_info *gi = NULL;
01204 
01205    AST_RWLIST_WRLOCK(&groups);
01206    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01207       if (gi->chan == old) {
01208          gi->chan = new;
01209       } else if (gi->chan == new) {
01210          AST_RWLIST_REMOVE_CURRENT(group_list);
01211          ast_free(gi);
01212       }
01213    }
01214    AST_RWLIST_TRAVERSE_SAFE_END;
01215    AST_RWLIST_UNLOCK(&groups);
01216 
01217    return 0;
01218 }

int ast_app_has_voicemail ( const char *  mailbox,
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 303 of file app.c.

References ast_has_voicemail_func, and ast_verb.

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

00304 {
00305    static int warned = 0;
00306    if (ast_has_voicemail_func) {
00307       return ast_has_voicemail_func(mailbox, folder);
00308    }
00309 
00310    if (warned++ % 10 == 0) {
00311       ast_verb(3, "Message check requested for mailbox %s/folder %s but voicemail not loaded.\n", mailbox, folder ? folder : "INBOX");
00312    }
00313    return 0;
00314 }

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

Determine number of new/old messages in a mailbox.

Since:
1.0
Parameters:
[in] mailbox Mailbox specification in the format mbox[][&mbox2[]][...]
[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 317 of file app.c.

References ast_inboxcount_func, and ast_verb.

Referenced by sip_send_mwi_to_peer(), and update_registry().

00318 {
00319    static int warned = 0;
00320    if (newmsgs) {
00321       *newmsgs = 0;
00322    }
00323    if (oldmsgs) {
00324       *oldmsgs = 0;
00325    }
00326    if (ast_inboxcount_func) {
00327       return ast_inboxcount_func(mailbox, newmsgs, oldmsgs);
00328    }
00329 
00330    if (warned++ % 10 == 0) {
00331       ast_verb(3, "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
00332    }
00333 
00334    return 0;
00335 }

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

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

Parameters:
[in] mailbox the mailbox context to use
[out] urgentmsgs the urgent message count
[out] newmsgs the new message count
[out] oldmsgs the old message count
Returns:
Returns 0 for success, negative upon error
Since:
1.6.1

Definition at line 337 of file app.c.

References ast_inboxcount2_func, and ast_verb.

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

00338 {
00339    static int warned = 0;
00340    if (newmsgs) {
00341       *newmsgs = 0;
00342    }
00343    if (oldmsgs) {
00344       *oldmsgs = 0;
00345    }
00346    if (urgentmsgs) {
00347       *urgentmsgs = 0;
00348    }
00349    if (ast_inboxcount2_func) {
00350       return ast_inboxcount2_func(mailbox, urgentmsgs, newmsgs, oldmsgs);
00351    }
00352 
00353    if (warned++ % 10 == 0) {
00354       ast_verb(3, "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
00355    }
00356 
00357    return 0;
00358 }

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

Check number of messages in a given context, mailbox, and folder.

Since:
1.4
Parameters:
[in] context Mailbox context
[in] mailbox Mailbox number
[in] folder Mailbox folder
Returns:
Number of messages in the given context, mailbox, and folder. If folder is NULL, folder "INBOX" is assumed. If folder is "INBOX", includes number of messages in the "Urgent" folder.

Definition at line 368 of file app.c.

References ast_messagecount_func, and ast_verb.

Referenced by acf_vmcount_exec().

00369 {
00370    static int warned = 0;
00371    if (ast_messagecount_func) {
00372       return ast_messagecount_func(context, mailbox, folder);
00373    }
00374 
00375    if (!warned) {
00376       warned++;
00377       ast_verb(3, "Message count requested for mailbox %s@%s/%s but voicemail not loaded.\n", mailbox, context, folder);
00378    }
00379 
00380    return 0;
00381 }

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

References ast_test_flag64, and ast_flags64::flags.

01984 {
01985    unsigned int i, found = 0;
01986    for (i = 32; i < 128 && found < len; i++) {
01987       if (ast_test_flag64(flags, options[i].flag)) {
01988          buf[found++] = i;
01989       }
01990    }
01991    buf[found] = '\0';
01992 }

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

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

Parameters:
options The array of possible options declared with AST_APP_OPTIONS
flags The flag structure to have option flags set
args The array of argument pointers to hold arguments found
optstr The string containing the options to be parsed
Returns:
zero for success, non-zero if an error occurs
See also:
AST_APP_OPTIONS

Definition at line 1973 of file app.c.

References ast_flags64::flags, and parse_options().

Referenced by app_exec(), auth_exec(), bridge_exec(), cdr_read(), cdr_write(), chanspy_exec(), confbridge_exec(), connectedline_write(), controlplayback_exec(), directory_exec(), disa_exec(), dundi_query_read(), dundifunc_read(), extenspy_exec(), handle_options(), hint_read(), minivm_accmess_exec(), minivm_greet_exec(), minivm_record_exec(), mixmonitor_exec(), page_exec(), park_call_exec(), pbx_builtin_background(), pbx_builtin_resetcdr(), pbx_builtin_waitexten(), read_exec(), readexten_exec(), realtime_common(), receivefax_exec(), record_exec(), redirecting_write(), sendfax_exec(), sendurl_exec(), sig_pri_call(), sla_trunk_exec(), smdi_msg_retrieve_read(), sms_exec(), softhangup_exec(), speech_background(), vm_exec(), vm_execmain(), and volume_write().

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

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

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

Parameters:
options The array of possible options declared with AST_APP_OPTIONS
flags The 64-bit flag structure to have option flags set
args The array of argument pointers to hold arguments found
optstr The string containing the options to be parsed
Returns:
zero for success, non-zero if an error occurs
See also:
AST_APP_OPTIONS

Definition at line 1978 of file app.c.

References ast_flags64::flags, and parse_options().

Referenced by conf_exec(), and dial_exec_full().

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

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

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

Referenced by ast_eivr_senddtmf(), pbx_builtin_wait(), pbx_builtin_waitexten(), and senddtmf_exec().

02184 {
02185    int res;
02186    char u[10];
02187 #ifdef HAVE_LONG_DOUBLE_WIDER
02188    long double amount;
02189    #define FMT "%30Lf%9s"
02190 #else
02191    double amount;
02192    #define FMT "%30lf%9s"
02193 #endif
02194    if (!timestr) {
02195       return -1;
02196    }
02197 
02198    if ((res = sscanf(timestr, FMT, &amount, u)) == 0) {
02199 #undef FMT
02200       return -1;
02201    } else if (res == 2) {
02202       switch (u[0]) {
02203       case 'h':
02204       case 'H':
02205          unit = TIMELEN_HOURS;
02206          break;
02207       case 's':
02208       case 'S':
02209          unit = TIMELEN_SECONDS;
02210          break;
02211       case 'm':
02212       case 'M':
02213          if (toupper(u[1]) == 'S') {
02214             unit = TIMELEN_MILLISECONDS;
02215          } else if (u[1] == '\0') {
02216             unit = TIMELEN_MINUTES;
02217          }
02218          break;
02219       }
02220    }
02221 
02222    switch (unit) {
02223    case TIMELEN_HOURS:
02224       amount *= 60;
02225       /* fall-through */
02226    case TIMELEN_MINUTES:
02227       amount *= 60;
02228       /* fall-through */
02229    case TIMELEN_SECONDS:
02230       amount *= 1000;
02231       /* fall-through */
02232    case TIMELEN_MILLISECONDS:
02233       ;
02234    }
02235    *result = amount > INT_MAX ? INT_MAX : (int) amount;
02236    return 0;
02237 }

int ast_app_run_macro ( struct ast_channel autoservice_chan,
struct ast_channel macro_chan,
const char *const   macro_name,
const char *const   macro_args 
)

Run a macro on a channel, placing a second channel into autoservice.

Since:
1.8
This is a shorthand method that makes it very easy to run a macro 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. It is very important that the autoservice_chan parameter is not locked prior to calling ast_app_run_macro. A deadlock could result, otherwise.

Parameters:
autoservice_chan A channel to place into autoservice while the macro is run
macro_chan The channel to run the macro on
macro_name The name of the macro to run
macro_args The arguments to pass to the macro
Return values:
0 success
-1 failure

Definition at line 253 of file app.c.

References ast_autoservice_start(), ast_autoservice_stop(), ast_log(), ast_strlen_zero(), LOG_WARNING, pbx_exec(), pbx_findapp(), and S_OR.

Referenced by ast_channel_connected_line_macro(), ast_channel_redirecting_macro(), and generic_recall().

00254 {
00255    struct ast_app *macro_app;
00256    int res;
00257    char buf[1024];
00258 
00259    macro_app = pbx_findapp("Macro");
00260    if (!macro_app) {
00261       ast_log(LOG_WARNING, "Cannot run macro '%s' because the 'Macro' application in not available\n", macro_name);
00262       return -1;
00263    }
00264    snprintf(buf, sizeof(buf), "%s%s%s", macro_name, ast_strlen_zero(macro_args) ? "" : ",", S_OR(macro_args, ""));
00265    if (autoservice_chan) {
00266       ast_autoservice_start(autoservice_chan);
00267    }
00268    res = pbx_exec(macro_chan, macro_app, buf);
00269    if (autoservice_chan) {
00270       ast_autoservice_stop(autoservice_chan);
00271    }
00272    return res;
00273 }

int ast_app_sayname ( struct ast_channel chan,
const char *  mailbox,
const char *  context 
)

Given a mailbox and context, play that mailbox owner's name to the channel specified.

Parameters:
[in] chan Channel on which to play the name
[in] mailbox Mailbox number from which to retrieve the recording
[in] context Mailbox context from which to locate the mailbox number
Return values:
0 Name played without interruption
dtmf ASCII value of the DTMF which interrupted playback.
-1 Unable to locate mailbox or hangup occurred.
Since:
1.6.1

Definition at line 360 of file app.c.

References ast_sayname_func.

Referenced by common_exec(), and play_mailbox_owner().

00361 {
00362    if (ast_sayname_func) {
00363       return ast_sayname_func(chan, mailbox, context);
00364    }
00365    return -1;
00366 }

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

Definition at line 1325 of file app.c.

References __ast_app_separate_args().

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

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

References closefrom().

Referenced by ast_safe_system(), icesencode(), launch_script(), main(), mp3play(), NBScatplay(), send_waveform_to_fd(), spawn_mp3(), spawn_ras(), and vm_check_password_shell().

02110 {
02111    closefrom(n + 1);
02112 }

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

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

Parameters:
chan 
file filename
fwd,rev,stop,pause,restart,skipms,offsetms Before calling this function, set this to be the number of ms to start from the beginning of the file. When the function returns, it will be the number of ms from the beginning where the playback stopped. Pass NULL if you don't care.

Definition at line 565 of file app.c.

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

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

00569 {
00570    char *breaks = NULL;
00571    char *end = NULL;
00572    int blen = 2;
00573    int res;
00574    long pause_restart_point = 0;
00575    long offset = 0;
00576 
00577    if (!file) {
00578       return -1;
00579    }
00580    if (offsetms) {
00581       offset = *offsetms * 8; /* XXX Assumes 8kHz */
00582    }
00583 
00584    if (stop) {
00585       blen += strlen(stop);
00586    }
00587    if (suspend) {
00588       blen += strlen(suspend);
00589    }
00590    if (restart) {
00591       blen += strlen(restart);
00592    }
00593 
00594    if (blen > 2) {
00595       breaks = alloca(blen + 1);
00596       breaks[0] = '\0';
00597       if (stop) {
00598          strcat(breaks, stop);
00599       }
00600       if (suspend) {
00601          strcat(breaks, suspend);
00602       }
00603       if (restart) {
00604          strcat(breaks, restart);
00605       }
00606    }
00607    if (chan->_state != AST_STATE_UP) {
00608       res = ast_answer(chan);
00609    }
00610 
00611    if ((end = strchr(file, ':'))) {
00612       if (!strcasecmp(end, ":end")) {
00613          *end = '\0';
00614          end++;
00615       }
00616    }
00617 
00618    for (;;) {
00619       ast_stopstream(chan);
00620       res = ast_streamfile(chan, file, chan->language);
00621       if (!res) {
00622          if (pause_restart_point) {
00623             ast_seekstream(chan->stream, pause_restart_point, SEEK_SET);
00624             pause_restart_point = 0;
00625          }
00626          else if (end || offset < 0) {
00627             if (offset == -8) {
00628                offset = 0;
00629             }
00630             ast_verb(3, "ControlPlayback seek to offset %ld from end\n", offset);
00631 
00632             ast_seekstream(chan->stream, offset, SEEK_END);
00633             end = NULL;
00634             offset = 0;
00635          } else if (offset) {
00636             ast_verb(3, "ControlPlayback seek to offset %ld\n", offset);
00637             ast_seekstream(chan->stream, offset, SEEK_SET);
00638             offset = 0;
00639          }
00640          res = ast_waitstream_fr(chan, breaks, fwd, rev, skipms);
00641       }
00642 
00643       if (res < 1) {
00644          break;
00645       }
00646 
00647       /* We go at next loop if we got the restart char */
00648       if (restart && strchr(restart, res)) {
00649          ast_debug(1, "we'll restart the stream here at next loop\n");
00650          pause_restart_point = 0;
00651          continue;
00652       }
00653 
00654       if (suspend && strchr(suspend, res)) {
00655          pause_restart_point = ast_tellstream(chan->stream);
00656          for (;;) {
00657             ast_stopstream(chan);
00658             if (!(res = ast_waitfordigit(chan, 1000))) {
00659                continue;
00660             } else if (res == -1 || strchr(suspend, res) || (stop && strchr(stop, res))) {
00661                break;
00662             }
00663          }
00664          if (res == *suspend) {
00665             res = 0;
00666             continue;
00667          }
00668       }
00669 
00670       if (res == -1) {
00671          break;
00672       }
00673 
00674       /* if we get one of our stop chars, return it to the calling function */
00675       if (stop && strchr(stop, res)) {
00676          break;
00677       }
00678    }
00679 
00680    if (pause_restart_point) {
00681       offset = pause_restart_point;
00682    } else {
00683       if (chan->stream) {
00684          offset = ast_tellstream(chan->stream);
00685       } else {
00686          offset = -8;  /* indicate end of file */
00687       }
00688    }
00689 
00690    if (offsetms) {
00691       *offsetms = offset / 8; /* samples --> ms ... XXX Assumes 8 kHz */
00692    }
00693 
00694    /* If we are returning a digit cast it as char */
00695    if (res > 0 || chan->stream) {
00696       res = (char)res;
00697    }
00698 
00699    ast_stopstream(chan);
00700 
00701    return res;
00702 }

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

Send DTMF to a channel.

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

Definition at line 383 of file app.c.

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

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

00384 {
00385    const char *ptr;
00386    int res = 0;
00387    struct ast_silence_generator *silgen = NULL;
00388 
00389    if (!between) {
00390       between = 100;
00391    }
00392 
00393    if (peer) {
00394       res = ast_autoservice_start(peer);
00395    }
00396 
00397    if (!res) {
00398       res = ast_waitfor(chan, 100);
00399    }
00400 
00401    /* ast_waitfor will return the number of remaining ms on success */
00402    if (res < 0) {
00403       if (peer) {
00404          ast_autoservice_stop(peer);
00405       }
00406       return res;
00407    }
00408 
00409    if (ast_opt_transmit_silence) {
00410       silgen = ast_channel_start_silence_generator(chan);
00411    }
00412 
00413    for (ptr = digits; *ptr; ptr++) {
00414       if (*ptr == 'w') {
00415          /* 'w' -- wait half a second */
00416          if ((res = ast_safe_sleep(chan, 500))) {
00417             break;
00418          }
00419       } else if (strchr("0123456789*#abcdfABCDF", *ptr)) {
00420          /* Character represents valid DTMF */
00421          if (*ptr == 'f' || *ptr == 'F') {
00422             /* ignore return values if not supported by channel */
00423             ast_indicate(chan, AST_CONTROL_FLASH);
00424          } else {
00425             ast_senddigit(chan, *ptr, duration);
00426          }
00427          /* pause between digits */
00428          if ((res = ast_safe_sleep(chan, between))) {
00429             break;
00430          }
00431       } else {
00432          ast_log(LOG_WARNING, "Illegal DTMF character '%c' in string. (0-9*#aAbBcCdD allowed)\n", *ptr);
00433       }
00434    }
00435 
00436    if (peer) {
00437       /* Stop autoservice on the peer channel, but don't overwrite any error condition
00438          that has occurred previously while acting on the primary channel */
00439       if (ast_autoservice_stop(peer) && !res) {
00440          res = -1;
00441       }
00442    }
00443 
00444    if (silgen) {
00445       ast_channel_stop_silence_generator(chan, silgen);
00446    }
00447 
00448    return res;
00449 }

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

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

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

01995 {
01996    int i;
01997    *consumed = 1;
01998    *result = 0;
01999    if (ast_strlen_zero(stream)) {
02000       *consumed = 0;
02001       return -1;
02002    }
02003 
02004    if (*stream == '\\') {
02005       *consumed = 2;
02006       switch (*(stream + 1)) {
02007       case 'n':
02008          *result = '\n';
02009          break;
02010       case 'r':
02011          *result = '\r';
02012          break;
02013       case 't':
02014          *result = '\t';
02015          break;
02016       case 'x':
02017          /* Hexadecimal */
02018          if (strchr("0123456789ABCDEFabcdef", *(stream + 2)) && *(stream + 2) != '\0') {
02019             *consumed = 3;
02020             if (*(stream + 2) <= '9') {
02021                *result = *(stream + 2) - '0';
02022             } else if (*(stream + 2) <= 'F') {
02023                *result = *(stream + 2) - 'A' + 10;
02024             } else {
02025                *result = *(stream + 2) - 'a' + 10;
02026             }
02027          } else {
02028             ast_log(LOG_ERROR, "Illegal character '%c' in hexadecimal string\n", *(stream + 2));
02029             return -1;
02030          }
02031 
02032          if (strchr("0123456789ABCDEFabcdef", *(stream + 3)) && *(stream + 3) != '\0') {
02033             *consumed = 4;
02034             *result <<= 4;
02035             if (*(stream + 3) <= '9') {
02036                *result += *(stream + 3) - '0';
02037             } else if (*(stream + 3) <= 'F') {
02038                *result += *(stream + 3) - 'A' + 10;
02039             } else {
02040                *result += *(stream + 3) - 'a' + 10;
02041             }
02042          }
02043          break;
02044       case '0':
02045          /* Octal */
02046          *consumed = 2;
02047          for (i = 2; ; i++) {
02048             if (strchr("01234567", *(stream + i)) && *(stream + i) != '\0') {
02049                (*consumed)++;
02050                ast_debug(5, "result was %d, ", *result);
02051                *result <<= 3;
02052                *result += *(stream + i) - '0';
02053                ast_debug(5, "is now %d\n", *result);
02054             } else {
02055                break;
02056             }
02057          }
02058          break;
02059       default:
02060          *result = *(stream + 1);
02061       }
02062    } else {
02063       *result = *stream;
02064       *consumed = 1;
02065    }
02066    return 0;
02067 }

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

References ast_get_encoded_char().

Referenced by listfilter(), mgcp_new(), replace(), sip_addheader(), and sip_new().

02070 {
02071    char *cur = result;
02072    size_t consumed;
02073 
02074    while (cur < result + result_size - 1 && !ast_get_encoded_char(stream, cur, &consumed)) {
02075       cur++;
02076       stream += consumed;
02077    }
02078    *cur = '\0';
02079    return result;
02080 }

void ast_install_vm_functions ( int(*)(const char *mailbox, const char *folder)  has_voicemail_func,
int(*)(const char *mailbox, int *newmsgs, int *oldmsgs)  inboxcount_func,
int(*)(const char *mailbox, int *urgentmsgs, int *newmsgs, int *oldmsgs)  inboxcount2_func,
int(*)(const char *context, const char *mailbox, const char *folder)  messagecount_func,
int(*)(struct ast_channel *chan, const char *mailbox, const char *context sayname_func 
)

Set voicemail function callbacks.

Parameters:
[in] has_voicemail_func set function pointer
[in] inboxcount2_func set function pointer
[in] sayname_func set function pointer
[in] inboxcount_func set function pointer
[in] messagecount_func set function pointer
Version:
1.6.1 Added inboxcount2_func, sayname_func

Definition at line 281 of file app.c.

References ast_has_voicemail_func, ast_inboxcount2_func, ast_inboxcount_func, ast_messagecount_func, and ast_sayname_func.

Referenced by load_module().

00286 {
00287    ast_has_voicemail_func = has_voicemail_func;
00288    ast_inboxcount_func = inboxcount_func;
00289    ast_inboxcount2_func = inboxcount2_func;
00290    ast_messagecount_func = messagecount_func;
00291    ast_sayname_func = sayname_func;
00292 }

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

Runs an IVR menu.

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

Definition at line 1852 of file app.c.

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

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

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

Definition at line 1767 of file app.c.

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

Referenced by ast_ivr_menu_run(), and ivr_dispatch().

01768 {
01769    /* Execute an IVR menu structure */
01770    int res = 0;
01771    int pos = 0;
01772    int retries = 0;
01773    char exten[AST_MAX_EXTENSION] = "s";
01774    if (option_exists(menu, "s") < 0) {
01775       strcpy(exten, "g");
01776       if (option_exists(menu, "g") < 0) {
01777          ast_log(LOG_WARNING, "No 's' nor 'g' extension in menu '%s'!\n", menu->title);
01778          return -1;
01779       }
01780    }
01781    while (!res) {
01782       while (menu->options[pos].option) {
01783          if (!strcasecmp(menu->options[pos].option, exten)) {
01784             res = ivr_dispatch(chan, menu->options + pos, exten, cbdata);
01785             ast_debug(1, "IVR Dispatch of '%s' (pos %d) yields %d\n", exten, pos, res);
01786             if (res < 0) {
01787                break;
01788             } else if (res & RES_UPONE) {
01789                return 0;
01790             } else if (res & RES_EXIT) {
01791                return res;
01792             } else if (res & RES_REPEAT) {
01793                int maxretries = res & 0xffff;
01794                if ((res & RES_RESTART) == RES_RESTART) {
01795                   retries = 0;
01796                } else {
01797                   retries++;
01798                }
01799                if (!maxretries) {
01800                   maxretries = 3;
01801                }
01802                if ((maxretries > 0) && (retries >= maxretries)) {
01803                   ast_debug(1, "Max retries %d exceeded\n", maxretries);
01804                   return -2;
01805                } else {
01806                   if (option_exists(menu, "g") > -1) {
01807                      strcpy(exten, "g");
01808                   } else if (option_exists(menu, "s") > -1) {
01809                      strcpy(exten, "s");
01810                   }
01811                }
01812                pos = 0;
01813                continue;
01814             } else if (res && strchr(AST_DIGIT_ANY, res)) {
01815                ast_debug(1, "Got start of extension, %c\n", res);
01816                exten[1] = '\0';
01817                exten[0] = res;
01818                if ((res = read_newoption(chan, menu, exten, sizeof(exten)))) {
01819                   break;
01820                }
01821                if (option_exists(menu, exten) < 0) {
01822                   if (option_exists(menu, "i")) {
01823                      ast_debug(1, "Invalid extension entered, going to 'i'!\n");
01824                      strcpy(exten, "i");
01825                      pos = 0;
01826                      continue;
01827                   } else {
01828                      ast_debug(1, "Aborting on invalid entry, with no 'i' option!\n");
01829                      res = -2;
01830                      break;
01831                   }
01832                } else {
01833                   ast_debug(1, "New existing extension: %s\n", exten);
01834                   pos = 0;
01835                   continue;
01836                }
01837             }
01838          }
01839          pos++;
01840       }
01841       ast_debug(1, "Stopping option '%s', res is %d\n", exten, res);
01842       pos = 0;
01843       if (!strcasecmp(exten, "s")) {
01844          strcpy(exten, "g");
01845       } else {
01846          break;
01847       }
01848    }
01849    return res;
01850 }

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

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

00536 {
00537    struct linear_state *lin;
00538    char tmpf[256];
00539    int res = -1;
00540    int autoclose = 0;
00541    if (fd < 0) {
00542       if (ast_strlen_zero(filename)) {
00543          return -1;
00544       }
00545       autoclose = 1;
00546       if (filename[0] == '/') {
00547          ast_copy_string(tmpf, filename, sizeof(tmpf));
00548       } else {
00549          snprintf(tmpf, sizeof(tmpf), "%s/%s/%s", ast_config_AST_DATA_DIR, "sounds", filename);
00550       }
00551       if ((fd = open(tmpf, O_RDONLY)) < 0) {
00552          ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", tmpf, strerror(errno));
00553          return -1;
00554       }
00555    }
00556    if ((lin = ast_calloc(1, sizeof(*lin)))) {
00557       lin->fd = fd;
00558       lin->allowoverride = allowoverride;
00559       lin->autoclose = autoclose;
00560       res = ast_activate_generator(chan, &linearstream, lin);
00561    }
00562    return res;
00563 }

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

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

Referenced by ast_module_reload(), and vm_lock_path().

01525 {
01526    enum AST_LOCK_RESULT r = AST_LOCK_FAILURE;
01527 
01528    switch (ast_lock_type) {
01529    case AST_LOCK_TYPE_LOCKFILE:
01530       r = ast_lock_path_lockfile(path);
01531       break;
01532    case AST_LOCK_TYPE_FLOCK:
01533       r = ast_lock_path_flock(path);
01534       break;
01535    }
01536 
01537    return r;
01538 }

static enum AST_LOCK_RESULT ast_lock_path_flock ( const char *  path  )  [static]

Definition at line 1404 of file app.c.

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

Referenced by ast_lock_path().

01405 {
01406    char *fs;
01407    int res;
01408    int fd;
01409    time_t start;
01410    struct path_lock *pl;
01411    struct stat st, ost;
01412 
01413    fs = alloca(strlen(path) + 20);
01414 
01415    snprintf(fs, strlen(path) + 19, "%s/lock", path);
01416    if (lstat(fs, &st) == 0) {
01417       if ((st.st_mode & S_IFMT) == S_IFLNK) {
01418          ast_log(LOG_WARNING, "Unable to create lock file "
01419                "'%s': it's already a symbolic link\n",
01420                fs);
01421          return AST_LOCK_FAILURE;
01422       }
01423       if (st.st_nlink > 1) {
01424          ast_log(LOG_WARNING, "Unable to create lock file "
01425                "'%s': %u hard links exist\n",
01426                fs, (unsigned int) st.st_nlink);
01427          return AST_LOCK_FAILURE;
01428       }
01429    }
01430    if ((fd = open(fs, O_WRONLY | O_CREAT, 0600)) < 0) {
01431       ast_log(LOG_WARNING, "Unable to create lock file '%s': %s\n",
01432             fs, strerror(errno));
01433       return AST_LOCK_PATH_NOT_FOUND;
01434    }
01435    if (!(pl = ast_calloc(1, sizeof(*pl)))) {
01436       /* We don't unlink the lock file here, on the possibility that
01437        * someone else created it - better to leave a little mess
01438        * than create a big one by destroying someone else's lock
01439        * and causing something to be corrupted.
01440        */
01441       close(fd);
01442       return AST_LOCK_FAILURE;
01443    }
01444    pl->fd = fd;
01445    pl->path = strdup(path);
01446 
01447    time(&start);
01448    while (
01449       #ifdef SOLARIS
01450       ((res = fcntl(pl->fd, F_SETLK, fcntl(pl->fd, F_GETFL) | O_NONBLOCK)) < 0) &&
01451       #else
01452       ((res = flock(pl->fd, LOCK_EX | LOCK_NB)) < 0) &&
01453       #endif
01454          (errno == EWOULDBLOCK) &&
01455          (time(NULL) - start < 5))
01456       usleep(1000);
01457    if (res) {
01458       ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n",
01459             path, strerror(errno));
01460       /* No unlinking of lock done, since we tried and failed to
01461        * flock() it.
01462        */
01463       path_lock_destroy(pl);
01464       return AST_LOCK_TIMEOUT;
01465    }
01466 
01467    /* Check for the race where the file is recreated or deleted out from
01468     * underneath us.
01469     */
01470    if (lstat(fs, &st) != 0 && fstat(pl->fd, &ost) != 0 &&
01471          st.st_dev != ost.st_dev &&
01472          st.st_ino != ost.st_ino) {
01473       ast_log(LOG_WARNING, "Unable to create lock file '%s': "
01474             "file changed underneath us\n", fs);
01475       path_lock_destroy(pl);
01476       return AST_LOCK_FAILURE;
01477    }
01478 
01479    /* Success: file created, flocked, and is the one we started with */
01480    AST_LIST_LOCK(&path_lock_list);
01481    AST_LIST_INSERT_TAIL(&path_lock_list, pl, le);
01482    AST_LIST_UNLOCK(&path_lock_list);
01483 
01484    ast_debug(1, "Locked path '%s'\n", path);
01485 
01486    return AST_LOCK_SUCCESS;
01487 }

static enum AST_LOCK_RESULT ast_lock_path_lockfile ( const char *  path  )  [static]

Definition at line 1330 of file app.c.

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

Referenced by ast_lock_path().

01331 {
01332    char *s;
01333    char *fs;
01334    int res;
01335    int fd;
01336    int lp = strlen(path);
01337    time_t start;
01338 
01339    s = alloca(lp + 10);
01340    fs = alloca(lp + 20);
01341 
01342    snprintf(fs, strlen(path) + 19, "%s/.lock-%08lx", path, ast_random());
01343    fd = open(fs, O_WRONLY | O_CREAT | O_EXCL, AST_FILE_MODE);
01344    if (fd < 0) {
01345       ast_log(LOG_ERROR, "Unable to create lock file '%s': %s\n", path, strerror(errno));
01346       return AST_LOCK_PATH_NOT_FOUND;
01347    }
01348    close(fd);
01349 
01350    snprintf(s, strlen(path) + 9, "%s/.lock", path);
01351    start = time(NULL);
01352    while (((res = link(fs, s)) < 0) && (errno == EEXIST) && (time(NULL) - start < 5)) {
01353       sched_yield();
01354    }
01355 
01356    unlink(fs);
01357 
01358    if (res) {
01359       ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n", path, strerror(errno));
01360       return AST_LOCK_TIMEOUT;
01361    } else {
01362       ast_debug(1, "Locked path '%s'\n", path);
01363       return AST_LOCK_SUCCESS;
01364    }
01365 }

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

References __ast_play_and_record().

Referenced by vm_forwardoptions().

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

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

References __ast_play_and_record().

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

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

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  silencethreshold,
int  maxsilence_ms,
const char *  path,
const char *  acceptdtmf,
const char *  canceldtmf 
)

Record a file based on input from a channel 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
acceptdtmf Character of DTMF to end and accept the recording
canceldtmf Character of DTMF to end and cancel the recording
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 1051 of file app.c.

References __ast_play_and_record(), and S_OR.

Referenced by play_record_review().

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

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

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

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

00705 {
00706    int d = 0;
00707 
00708    ast_test_suite_event_notify("PLAYBACK", "Message: %s", fn);
00709    if ((d = ast_streamfile(chan, fn, chan->language))) {
00710       return d;
00711    }
00712 
00713    d = ast_waitstream(chan, AST_DIGIT_ANY);
00714 
00715    ast_stopstream(chan);
00716 
00717    return d;
00718 }

char* ast_read_textfile ( const char *  filename  ) 

Read a file into asterisk.

Definition at line 1859 of file app.c.

References ast_free, ast_log(), ast_malloc, errno, and LOG_WARNING.

Referenced by readfile_exec().

01860 {
01861    int fd, count = 0, res;
01862    char *output = NULL;
01863    struct stat filesize;
01864 
01865    if (stat(filename, &filesize) == -1) {
01866       ast_log(LOG_WARNING, "Error can't stat %s\n", filename);
01867       return NULL;
01868    }
01869 
01870    count = filesize.st_size + 1;
01871 
01872    if ((fd = open(filename, O_RDONLY)) < 0) {
01873       ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", filename, strerror(errno));
01874       return NULL;
01875    }
01876 
01877    if ((output = ast_malloc(count))) {
01878       res = read(fd, output, count - 1);
01879       if (res == count - 1) {
01880          output[res] = '\0';
01881       } else {
01882          ast_log(LOG_WARNING, "Short read of %s (%d of %d): %s\n", filename, res, count - 1, strerror(errno));
01883          ast_free(output);
01884          output = NULL;
01885       }
01886    }
01887 
01888    close(fd);
01889 
01890    return output;
01891 }

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

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, silencethreshold, and THRESHOLD_SILENCE.

Referenced by conf_run().

01557 {
01558    int silencethreshold;
01559    int maxsilence = 0;
01560    int res = 0;
01561    int cmd = 0;
01562    int max_attempts = 3;
01563    int attempts = 0;
01564    int recorded = 0;
01565    int message_exists = 0;
01566    /* Note that urgent and private are for flagging messages as such in the future */
01567 
01568    /* barf if no pointer passed to store duration in */
01569    if (!duration) {
01570       ast_log(LOG_WARNING, "Error ast_record_review called without duration pointer\n");
01571       return -1;
01572    }
01573 
01574    cmd = '3';   /* Want to start by recording */
01575 
01576    silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
01577 
01578    while ((cmd >= 0) && (cmd != 't')) {
01579       switch (cmd) {
01580       case '1':
01581          if (!message_exists) {
01582             /* In this case, 1 is to record a message */
01583             cmd = '3';
01584             break;
01585          } else {
01586             ast_stream_and_wait(chan, "vm-msgsaved", "");
01587             cmd = 't';
01588             return res;
01589          }
01590       case '2':
01591          /* Review */
01592          ast_verb(3, "Reviewing the recording\n");
01593          cmd = ast_stream_and_wait(chan, recordfile, AST_DIGIT_ANY);
01594          break;
01595       case '3':
01596          message_exists = 0;
01597          /* Record */
01598          ast_verb(3, "R%secording\n", recorded == 1 ? "e-r" : "");
01599          recorded = 1;
01600          if ((cmd = ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, NULL, silencethreshold, maxsilence, path)) == -1) {
01601             /* User has hung up, no options to give */
01602             return cmd;
01603          }
01604          if (cmd == '0') {
01605             break;
01606          } else if (cmd == '*') {
01607             break;
01608          } else {
01609             /* If all is well, a message exists */
01610             message_exists = 1;
01611             cmd = 0;
01612          }
01613          break;
01614       case '4':
01615       case '5':
01616       case '6':
01617       case '7':
01618       case '8':
01619       case '9':
01620       case '*':
01621       case '#':
01622          cmd = ast_play_and_wait(chan, "vm-sorry");
01623          break;
01624       default:
01625          if (message_exists) {
01626             cmd = ast_play_and_wait(chan, "vm-review");
01627          } else {
01628             if (!(cmd = ast_play_and_wait(chan, "vm-torerecord"))) {
01629                cmd = ast_waitfordigit(chan, 600);
01630             }
01631          }
01632 
01633          if (!cmd) {
01634             cmd = ast_waitfordigit(chan, 6000);
01635          }
01636          if (!cmd) {
01637             attempts++;
01638          }
01639          if (attempts > max_attempts) {
01640             cmd = 't';
01641          }
01642       }
01643    }
01644    if (cmd == 't') {
01645       cmd = 0;
01646    }
01647    return cmd;
01648 }

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

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, and shaun_of_the_dead().

Referenced by filestream_destructor(), icesencode(), launch_script(), mp3play(), NBScatplay(), send_waveform_to_fd(), spawn_mp3(), spawn_ras(), and vm_check_password_shell().

02115 {
02116    sigset_t signal_set, old_set;
02117    int pid;
02118 
02119    /* Don't let the default signal handler for children reap our status */
02120    if (stop_reaper) {
02121       ast_replace_sigchld();
02122    }
02123 
02124    sigfillset(&signal_set);
02125    pthread_sigmask(SIG_BLOCK, &signal_set, &old_set);
02126 
02127    pid = fork();
02128 
02129    if (pid != 0) {
02130       /* Fork failed or parent */
02131       pthread_sigmask(SIG_SETMASK, &old_set, NULL);
02132       if (!stop_reaper && pid > 0) {
02133          struct zombie *cur = ast_calloc(1, sizeof(*cur));
02134          if (cur) {
02135             cur->pid = pid;
02136             AST_LIST_LOCK(&zombies);
02137             AST_LIST_INSERT_TAIL(&zombies, cur, list);
02138             AST_LIST_UNLOCK(&zombies);
02139             if (shaun_of_the_dead_thread == AST_PTHREADT_NULL) {
02140                if (ast_pthread_create_background(&shaun_of_the_dead_thread, NULL, shaun_of_the_dead, NULL)) {
02141                   ast_log(LOG_ERROR, "Shaun of the Dead wants to kill zombies, but can't?!!\n");
02142                   shaun_of_the_dead_thread = AST_PTHREADT_NULL;
02143                }
02144             }
02145          }
02146       }
02147       return pid;
02148    } else {
02149       /* Child */
02150 #ifdef HAVE_CAP
02151       cap_t cap = cap_from_text("cap_net_admin-eip");
02152 
02153       if (cap_set_proc(cap)) {
02154          ast_log(LOG_WARNING, "Unable to remove capabilities.\n");
02155       }
02156       cap_free(cap);
02157 #endif
02158 
02159       /* Before we unblock our signals, return our trapped signals back to the defaults */
02160       signal(SIGHUP, SIG_DFL);
02161       signal(SIGCHLD, SIG_DFL);
02162       signal(SIGINT, SIG_DFL);
02163       signal(SIGURG, SIG_DFL);
02164       signal(SIGTERM, SIG_DFL);
02165       signal(SIGPIPE, SIG_DFL);
02166       signal(SIGXFSZ, SIG_DFL);
02167 
02168       /* unblock important signal handlers */
02169       if (pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL)) {
02170          ast_log(LOG_WARNING, "unable to unblock signals: %s\n", strerror(errno));
02171          _exit(1);
02172       }
02173 
02174       return pid;
02175    }
02176 }

void ast_safe_fork_cleanup ( void   ) 

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

Since:
1.6.1

Definition at line 2178 of file app.c.

References ast_unreplace_sigchld().

Referenced by agi_exec_full(), and run_ras().

02179 {
02180    ast_unreplace_sigchld();
02181 }

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

01520 {
01521    ast_lock_type = type;
01522 }

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

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

Referenced by sendtext_exec(), and system_exec_helper().

02083 {
02084    char next, *buf;
02085    size_t offset = 0;
02086    size_t consumed;
02087 
02088    if (strchr(stream, '\\')) {
02089       while (!ast_get_encoded_char(stream, &next, &consumed)) {
02090          if (offset + 2 > ast_str_size(*str) && maxlen > -1) {
02091             ast_str_make_space(str, maxlen > 0 ? maxlen : (ast_str_size(*str) + 48) * 2 - 48);
02092          }
02093          if (offset + 2 > ast_str_size(*str)) {
02094             break;
02095          }
02096          buf = ast_str_buffer(*str);
02097          buf[offset++] = next;
02098          stream += consumed;
02099       }
02100       buf = ast_str_buffer(*str);
02101       buf[offset++] = '\0';
02102       ast_str_update(*str);
02103    } else {
02104       ast_str_set(str, maxlen, "%s", stream);
02105    }
02106    return 0;
02107 }

AST_THREADSTORAGE_PUBLIC ( ast_str_thread_global_buf   ) 

void ast_uninstall_vm_functions ( void   ) 

Definition at line 294 of file app.c.

References ast_has_voicemail_func, ast_inboxcount2_func, ast_inboxcount_func, ast_messagecount_func, and ast_sayname_func.

Referenced by unload_module().

00295 {
00296    ast_has_voicemail_func = NULL;
00297    ast_inboxcount_func = NULL;
00298    ast_inboxcount2_func = NULL;
00299    ast_messagecount_func = NULL;
00300    ast_sayname_func = NULL;
00301 }

int ast_unlock_path ( const char *  path  ) 

Unlock a path.

Definition at line 1540 of file app.c.

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

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

01541 {
01542    int r = 0;
01543 
01544    switch (ast_lock_type) {
01545    case AST_LOCK_TYPE_LOCKFILE:
01546       r = ast_unlock_path_lockfile(path);
01547       break;
01548    case AST_LOCK_TYPE_FLOCK:
01549       r = ast_unlock_path_flock(path);
01550       break;
01551    }
01552 
01553    return r;
01554 }

static int ast_unlock_path_flock ( const char *  path  )  [static]

Definition at line 1489 of file app.c.

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

Referenced by ast_unlock_path().

01490 {
01491    char *s;
01492    struct path_lock *p;
01493 
01494    s = alloca(strlen(path) + 20);
01495 
01496    AST_LIST_LOCK(&path_lock_list);
01497    AST_LIST_TRAVERSE_SAFE_BEGIN(&path_lock_list, p, le) {
01498       if (!strcmp(p->path, path)) {
01499          AST_LIST_REMOVE_CURRENT(le);
01500          break;
01501       }
01502    }
01503    AST_LIST_TRAVERSE_SAFE_END;
01504    AST_LIST_UNLOCK(&path_lock_list);
01505 
01506    if (p) {
01507       snprintf(s, strlen(path) + 19, "%s/lock", path);
01508       unlink(s);
01509       path_lock_destroy(p);
01510       ast_log(LOG_DEBUG, "Unlocked path '%s'\n", path);
01511    } else {
01512       ast_log(LOG_DEBUG, "Failed to unlock path '%s': "
01513             "lock not found\n", path);
01514    }
01515 
01516    return 0;
01517 }

static int ast_unlock_path_lockfile ( const char *  path  )  [static]

Definition at line 1367 of file app.c.

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

Referenced by ast_unlock_path().

01368 {
01369    char *s;
01370    int res;
01371 
01372    s = alloca(strlen(path) + 10);
01373 
01374    snprintf(s, strlen(path) + 9, "%s/%s", path, ".lock");
01375 
01376    if ((res = unlink(s))) {
01377       ast_log(LOG_ERROR, "Could not unlock path '%s': %s\n", path, strerror(errno));
01378    } else {
01379       ast_debug(1, "Unlocked path '%s'\n", path);
01380    }
01381 
01382    return res;
01383 }

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

Definition at line 1657 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01658 {
01659    int res;
01660    int (*ivr_func)(struct ast_channel *, void *);
01661    char *c;
01662    char *n;
01663 
01664    switch (option->action) {
01665    case AST_ACTION_UPONE:
01666       return RES_UPONE;
01667    case AST_ACTION_EXIT:
01668       return RES_EXIT | (((unsigned long)(option->adata)) & 0xffff);
01669    case AST_ACTION_REPEAT:
01670       return RES_REPEAT | (((unsigned long)(option->adata)) & 0xffff);
01671    case AST_ACTION_RESTART:
01672       return RES_RESTART ;
01673    case AST_ACTION_NOOP:
01674       return 0;
01675    case AST_ACTION_BACKGROUND:
01676       res = ast_stream_and_wait(chan, (char *)option->adata, AST_DIGIT_ANY);
01677       if (res < 0) {
01678          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01679          res = 0;
01680       }
01681       return res;
01682    case AST_ACTION_PLAYBACK:
01683       res = ast_stream_and_wait(chan, (char *)option->adata, "");
01684       if (res < 0) {
01685          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01686          res = 0;
01687       }
01688       return res;
01689    case AST_ACTION_MENU:
01690       if ((res = ast_ivr_menu_run_internal(chan, (struct ast_ivr_menu *)option->adata, cbdata)) == -2) {
01691          /* Do not pass entry errors back up, treat as though it was an "UPONE" */
01692          res = 0;
01693       }
01694       return res;
01695    case AST_ACTION_WAITOPTION:
01696       if (!(res = ast_waitfordigit(chan, chan->pbx ? chan->pbx->rtimeoutms : 10000))) {
01697          return 't';
01698       }
01699       return res;
01700    case AST_ACTION_CALLBACK:
01701       ivr_func = option->adata;
01702       res = ivr_func(chan, cbdata);
01703       return res;
01704    case AST_ACTION_TRANSFER:
01705       res = ast_parseable_goto(chan, option->adata);
01706       return 0;
01707    case AST_ACTION_PLAYLIST:
01708    case AST_ACTION_BACKLIST:
01709       res = 0;
01710       c = ast_strdupa(option->adata);
01711       while ((n = strsep(&c, ";"))) {
01712          if ((res = ast_stream_and_wait(chan, n,
01713                (option->action == AST_ACTION_BACKLIST) ? AST_DIGIT_ANY : ""))) {
01714             break;
01715          }
01716       }
01717       ast_stopstream(chan);
01718       return res;
01719    default:
01720       ast_log(LOG_NOTICE, "Unknown dispatch function %d, ignoring!\n", option->action);
01721       return 0;
01722    }
01723    return -1;
01724 }

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

Definition at line 502 of file app.c.

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

00503 {
00504    struct linear_state *ls = params;
00505 
00506    if (!params) {
00507       return NULL;
00508    }
00509 
00510    /* In this case, params is already malloc'd */
00511    if (ls->allowoverride) {
00512       ast_set_flag(chan, AST_FLAG_WRITE_INT);
00513    } else {
00514       ast_clear_flag(chan, AST_FLAG_WRITE_INT);
00515    }
00516 
00517    ls->origwfmt = chan->writeformat;
00518 
00519    if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
00520       ast_log(LOG_WARNING, "Unable to set '%s' to linear format (write)\n", chan->name);
00521       ast_free(ls);
00522       ls = params = NULL;
00523    }
00524 
00525    return params;
00526 }

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

Definition at line 473 of file app.c.

References AST_FORMAT_SLINEAR, AST_FRAME_VOICE, AST_FRIENDLY_OFFSET, ast_log(), ast_write(), f, linear_state::fd, and LOG_WARNING.

00474 {
00475    short buf[2048 + AST_FRIENDLY_OFFSET / 2];
00476    struct linear_state *ls = data;
00477    struct ast_frame f = {
00478       .frametype = AST_FRAME_VOICE,
00479       .subclass.codec = AST_FORMAT_SLINEAR,
00480       .data.ptr = buf + AST_FRIENDLY_OFFSET / 2,
00481       .offset = AST_FRIENDLY_OFFSET,
00482    };
00483    int res;
00484 
00485    len = samples * 2;
00486    if (len > sizeof(buf) - AST_FRIENDLY_OFFSET) {
00487       ast_log(LOG_WARNING, "Can't generate %d bytes of data!\n" , len);
00488       len = sizeof(buf) - AST_FRIENDLY_OFFSET;
00489    }
00490    res = read(ls->fd, buf + AST_FRIENDLY_OFFSET/2, len);
00491    if (res > 0) {
00492       f.datalen = res;
00493       f.samples = res / 2;
00494       ast_write(chan, &f);
00495       if (res == len) {
00496          return 0;
00497       }
00498    }
00499    return -1;
00500 }

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

Definition at line 458 of file app.c.

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

00459 {
00460    struct linear_state *ls = params;
00461 
00462    if (ls->origwfmt && ast_set_write_format(chan, ls->origwfmt)) {
00463       ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, ls->origwfmt);
00464    }
00465 
00466    if (ls->autoclose) {
00467       close(ls->fd);
00468    }
00469 
00470    ast_free(params);
00471 }

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

Definition at line 1726 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01727 {
01728    int x;
01729    for (x = 0; menu->options[x].option; x++) {
01730       if (!strcasecmp(menu->options[x].option, option)) {
01731          return x;
01732       }
01733    }
01734    return -1;
01735 }

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

Definition at line 1737 of file app.c.

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

Referenced by read_newoption().

01738 {
01739    int x;
01740    for (x = 0; menu->options[x].option; x++) {
01741       if ((!strncasecmp(menu->options[x].option, option, strlen(option))) &&
01742             (menu->options[x].option[strlen(option)])) {
01743          return x;
01744       }
01745    }
01746    return -1;
01747 }

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

Definition at line 1893 of file app.c.

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

Referenced by ast_app_parse_options(), and ast_app_parse_options64().

01894 {
01895    char *s, *arg;
01896    int curarg, res = 0;
01897    unsigned int argloc;
01898    struct ast_flags *flags = _flags;
01899    struct ast_flags64 *flags64 = _flags;
01900 
01901    if (flaglen == 32) {
01902       ast_clear_flag(flags, AST_FLAGS_ALL);
01903    } else {
01904       flags64->flags = 0;
01905    }
01906 
01907    if (!optstr) {
01908       return 0;
01909    }
01910 
01911    s = optstr;
01912    while (*s) {
01913       curarg = *s++ & 0x7f;   /* the array (in app.h) has 128 entries */
01914       argloc = options[curarg].arg_index;
01915       if (*s == '(') {
01916          int paren = 1, quote = 0;
01917          int parsequotes = (s[1] == '"') ? 1 : 0;
01918 
01919          /* Has argument */
01920          arg = ++s;
01921          for (; *s; s++) {
01922             if (*s == '(' && !quote) {
01923                paren++;
01924             } else if (*s == ')' && !quote) {
01925                /* Count parentheses, unless they're within quotes (or backslashed, below) */
01926                paren--;
01927             } else if (*s == '"' && parsequotes) {
01928                /* Leave embedded quotes alone, unless they are the first character */
01929                quote = quote ? 0 : 1;
01930                ast_copy_string(s, s + 1, INT_MAX);
01931                s--;
01932             } else if (*s == '\\') {
01933                if (!quote) {
01934                   /* If a backslash is found outside of quotes, remove it */
01935                   ast_copy_string(s, s + 1, INT_MAX);
01936                } else if (quote && s[1] == '"') {
01937                   /* Backslash for a quote character within quotes, remove the backslash */
01938                   ast_copy_string(s, s + 1, INT_MAX);
01939                } else {
01940                   /* Backslash within quotes, keep both characters */
01941                   s++;
01942                }
01943             }
01944 
01945             if (paren == 0) {
01946                break;
01947             }
01948          }
01949          /* This will find the closing paren we found above, or none, if the string ended before we found one. */
01950          if ((s = strchr(s, ')'))) {
01951             if (argloc) {
01952                args[argloc - 1] = arg;
01953             }
01954             *s++ = '\0';
01955          } else {
01956             ast_log(LOG_WARNING, "Missing closing parenthesis for argument '%c' in string '%s'\n", curarg, arg);
01957             res = -1;
01958             break;
01959          }
01960       } else if (argloc) {
01961          args[argloc - 1] = "";
01962       }
01963       if (flaglen == 32) {
01964          ast_set_flag(flags, options[curarg].flag);
01965       } else {
01966          ast_set_flag64(flags64, options[curarg].flag);
01967       }
01968    }
01969 
01970    return res;
01971 }

static void path_lock_destroy ( struct path_lock obj  )  [static]

Definition at line 1393 of file app.c.

References free.

Referenced by ast_lock_path_flock(), and ast_unlock_path_flock().

01394 {
01395    if (obj->fd >= 0) {
01396       close(obj->fd);
01397    }
01398    if (obj->path) {
01399       free(obj->path);
01400    }
01401    free(obj);
01402 }

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

Definition at line 1749 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01750 {
01751    int res = 0;
01752    int ms;
01753    while (option_matchmore(menu, exten)) {
01754       ms = chan->pbx ? chan->pbx->dtimeoutms : 5000;
01755       if (strlen(exten) >= maxexten - 1) {
01756          break;
01757       }
01758       if ((res = ast_waitfordigit(chan, ms)) < 1) {
01759          break;
01760       }
01761       exten[strlen(exten) + 1] = '\0';
01762       exten[strlen(exten)] = res;
01763    }
01764    return res > 0 ? 0 : res;
01765 }

static void* shaun_of_the_dead ( void *  data  )  [static]

Definition at line 74 of file app.c.

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, zombie::pid, and status.

Referenced by ast_safe_fork().

00075 {
00076    struct zombie *cur;
00077    int status;
00078    for (;;) {
00079       if (!AST_LIST_EMPTY(&zombies)) {
00080          /* Don't allow cancellation while we have a lock. */
00081          pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
00082          AST_LIST_LOCK(&zombies);
00083          AST_LIST_TRAVERSE_SAFE_BEGIN(&zombies, cur, list) {
00084             if (waitpid(cur->pid, &status, WNOHANG) != 0) {
00085                AST_LIST_REMOVE_CURRENT(list);
00086                ast_free(cur);
00087             }
00088          }
00089          AST_LIST_TRAVERSE_SAFE_END
00090          AST_LIST_UNLOCK(&zombies);
00091          pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
00092       }
00093       pthread_testcancel();
00094       /* Wait for 60 seconds, without engaging in a busy loop. */
00095       ast_poll(NULL, 0, AST_LIST_FIRST(&zombies) ? 5000 : 60000);
00096    }
00097    return NULL;
00098 }


Variable Documentation

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

Definition at line 275 of file app.c.

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

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

Definition at line 277 of file app.c.

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

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

Definition at line 276 of file app.c.

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

enum AST_LOCK_TYPE ast_lock_type = AST_LOCK_TYPE_LOCKFILE [static]

Definition at line 228 of file app.c.

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

Definition at line 279 of file app.c.

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

int(*) ast_sayname_func(struct ast_channel *chan, const char *mailbox, const char *context) = NULL [static]

Definition at line 278 of file app.c.

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

const char default_acceptdtmf[] = "#" [static]

Definition at line 1048 of file app.c.

const char default_canceldtmf[] = "" [static]

Definition at line 1049 of file app.c.

int global_maxsilence = 0 [static]

Definition at line 721 of file app.c.

int global_silence_threshold = 128 [static]

Definition at line 720 of file app.c.

struct ast_generator linearstream [static]

Definition at line 528 of file app.c.

Referenced by ast_linear_stream().

pthread_t shaun_of_the_dead_thread = AST_PTHREADT_NULL [static]

Definition at line 65 of file app.c.


Generated on Mon Oct 8 12:39:06 2012 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7