Mon Jun 27 16:50:57 2011

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"

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 beep, int silencethreshold, int maxsilence, const char *path, int prepend, const char *acceptdtmf, const char *canceldtmf)
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 beep, int silencethreshold, int maxsilence)
 Record a message and prepend the message to the given record file after playing the optional playfile (or a beep), storing the duration in 'duration' and with a maximum permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults.
int ast_play_and_record (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int silencethreshold, int maxsilence, const char *path)
 Record a file for a max amount of time (in seconds), in a given list of formats separated by '|', outputting the duration of the recording, and with a maximum
permitted silence time in milliseconds of 'maxsilence' under 'silencethreshold' or use '-1' for either or both parameters for defaults. calls ast_unlock_path() on 'path' if passed.
int ast_play_and_record_full (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, int silencethreshold, int maxsilence, const char *path, const char *acceptdtmf, const char *canceldtmf)
int ast_play_and_wait (struct ast_channel *chan, const char *fn)
 Play a stream and wait for a digit, returning the digit that was pressed.
char * ast_read_textfile (const char *filename)
 Read a file into asterisk.
int ast_record_review (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, const char *path)
 Allow to record message and have a review option.
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 96 of file app.c.

#define FMT   "%30Lf%9s"

Referenced by ast_app_parse_timelen().

#define RES_EXIT   (1 << 17)

Definition at line 1622 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_REPEAT   (1 << 18)

Definition at line 1623 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

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

Definition at line 1624 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_UPONE   (1 << 16)

Definition at line 1621 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 1231 of file app.c.

References paren, and quote().

Referenced by ast_app_separate_args().

01232 {
01233    int argc;
01234    char *scan, *wasdelim = NULL;
01235    int paren = 0, quote = 0, bracket = 0;
01236 
01237    if (!array || !arraylen) {
01238       return 0;
01239    }
01240 
01241    memset(array, 0, arraylen * sizeof(*array));
01242 
01243    if (!buf) {
01244       return 0;
01245    }
01246 
01247    scan = buf;
01248 
01249    for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
01250       array[argc] = scan;
01251       for (; *scan; scan++) {
01252          if (*scan == '(') {
01253             paren++;
01254          } else if (*scan == ')') {
01255             if (paren) {
01256                paren--;
01257             }
01258          } else if (*scan == '[') {
01259             bracket++;
01260          } else if (*scan == ']') {
01261             if (bracket) {
01262                bracket--;
01263             }
01264          } else if (*scan == '"' && delim != '"') {
01265             quote = quote ? 0 : 1;
01266             if (remove_chars) {
01267                /* Remove quote character from argument */
01268                memmove(scan, scan + 1, strlen(scan));
01269                scan--;
01270             }
01271          } else if (*scan == '\\') {
01272             if (remove_chars) {
01273                /* Literal character, don't parse */
01274                memmove(scan, scan + 1, strlen(scan));
01275             } else {
01276                scan++;
01277             }
01278          } else if ((*scan == delim) && !paren && !quote && !bracket) {
01279             wasdelim = scan;
01280             *scan++ = '\0';
01281             break;
01282          }
01283       }
01284    }
01285 
01286    /* If the last character in the original string was the delimiter, then
01287     * there is one additional argument. */
01288    if (*scan || (scan > buf && (scan - 1) == wasdelim)) {
01289       array[argc++] = scan;
01290    }
01291 
01292    return argc;
01293 }

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

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

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

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

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

Same logic as above.

Definition at line 730 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().

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

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 seconds
Returns:
0 if extension does not exist, 1 if extension exists

Definition at line 114 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().

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

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 170 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().

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

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

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

Referenced by handle_getdata().

00224 {
00225    int res, to = 2000, fto = 6000;
00226 
00227    if (!ast_strlen_zero(prompt)) {
00228       res = ast_streamfile(c, prompt, c->language);
00229       if (res < 0) {
00230          return res;
00231       }
00232    }
00233 
00234    if (timeout > 0) {
00235       fto = to = timeout;
00236    }
00237    if (timeout < 0) {
00238       fto = to = 1000000000;
00239    }
00240 
00241    res = ast_readstring_full(c, s, maxlen, to, fto, "#", audiofd, ctrlfd);
00242 
00243    return res;
00244 }

int ast_app_group_discard ( struct ast_channel chan  ) 

Discard all group counting for a channel.

Definition at line 1191 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().

01192 {
01193    struct ast_group_info *gi = NULL;
01194 
01195    AST_RWLIST_WRLOCK(&groups);
01196    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01197       if (gi->chan == chan) {
01198          AST_RWLIST_REMOVE_CURRENT(group_list);
01199          ast_free(gi);
01200       }
01201    }
01202    AST_RWLIST_TRAVERSE_SAFE_END;
01203    AST_RWLIST_UNLOCK(&groups);
01204 
01205    return 0;
01206 }

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 1113 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().

01114 {
01115    struct ast_group_info *gi = NULL;
01116    int count = 0;
01117 
01118    if (ast_strlen_zero(group)) {
01119       return 0;
01120    }
01121 
01122    AST_RWLIST_RDLOCK(&groups);
01123    AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
01124       if (!strcasecmp(gi->group, group) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
01125          count++;
01126       }
01127    }
01128    AST_RWLIST_UNLOCK(&groups);
01129 
01130    return count;
01131 }

struct ast_group_info* ast_app_group_list_head ( void   ) 

Get the head of the group count list.

Definition at line 1218 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().

01219 {
01220    return AST_RWLIST_FIRST(&groups);
01221 }

int ast_app_group_list_rdlock ( void   ) 

Read Lock the group count list.

Definition at line 1213 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().

01214 {
01215    return AST_RWLIST_RDLOCK(&groups);
01216 }

int ast_app_group_list_unlock ( void   ) 

Unlock the group count list.

Definition at line 1223 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().

01224 {
01225    return AST_RWLIST_UNLOCK(&groups);
01226 }

int ast_app_group_list_wrlock ( void   ) 

Write Lock the group count list.

Definition at line 1208 of file app.c.

References AST_RWLIST_WRLOCK.

01209 {
01210    return AST_RWLIST_WRLOCK(&groups);
01211 }

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 1133 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().

01134 {
01135    struct ast_group_info *gi = NULL;
01136    regex_t regexbuf_group;
01137    regex_t regexbuf_category;
01138    int count = 0;
01139 
01140    if (ast_strlen_zero(groupmatch)) {
01141       ast_log(LOG_NOTICE, "groupmatch empty\n");
01142       return 0;
01143    }
01144 
01145    /* if regex compilation fails, return zero matches */
01146    if (regcomp(&regexbuf_group, groupmatch, REG_EXTENDED | REG_NOSUB)) {
01147       ast_log(LOG_ERROR, "Regex compile failed on: %s\n", groupmatch);
01148       return 0;
01149    }
01150 
01151    if (!ast_strlen_zero(category) && regcomp(&regexbuf_category, category, REG_EXTENDED | REG_NOSUB)) {
01152       ast_log(LOG_ERROR, "Regex compile failed on: %s\n", category);
01153       return 0;
01154    }
01155 
01156    AST_RWLIST_RDLOCK(&groups);
01157    AST_RWLIST_TRAVERSE(&groups, gi, group_list) {
01158       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)))) {
01159          count++;
01160       }
01161    }
01162    AST_RWLIST_UNLOCK(&groups);
01163 
01164    regfree(&regexbuf_group);
01165    if (!ast_strlen_zero(category)) {
01166       regfree(&regexbuf_category);
01167    }
01168 
01169    return count;
01170 }

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 1066 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().

01067 {
01068    int res = 0;
01069    char group[80] = "", category[80] = "";
01070    struct ast_group_info *gi = NULL;
01071    size_t len = 0;
01072 
01073    if (ast_app_group_split_group(data, group, sizeof(group), category, sizeof(category))) {
01074       return -1;
01075    }
01076 
01077    /* Calculate memory we will need if this is new */
01078    len = sizeof(*gi) + strlen(group) + 1;
01079    if (!ast_strlen_zero(category)) {
01080       len += strlen(category) + 1;
01081    }
01082 
01083    AST_RWLIST_WRLOCK(&groups);
01084    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01085       if ((gi->chan == chan) && ((ast_strlen_zero(category) && ast_strlen_zero(gi->category)) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
01086          AST_RWLIST_REMOVE_CURRENT(group_list);
01087          free(gi);
01088          break;
01089       }
01090    }
01091    AST_RWLIST_TRAVERSE_SAFE_END;
01092 
01093    if (ast_strlen_zero(group)) {
01094       /* Enable unsetting the group */
01095    } else if ((gi = calloc(1, len))) {
01096       gi->chan = chan;
01097       gi->group = (char *) gi + sizeof(*gi);
01098       strcpy(gi->group, group);
01099       if (!ast_strlen_zero(category)) {
01100          gi->category = (char *) gi + sizeof(*gi) + strlen(group) + 1;
01101          strcpy(gi->category, category);
01102       }
01103       AST_RWLIST_INSERT_TAIL(&groups, gi, group_list);
01104    } else {
01105       res = -1;
01106    }
01107 
01108    AST_RWLIST_UNLOCK(&groups);
01109 
01110    return res;
01111 }

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 1039 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().

01040 {
01041    int res = 0;
01042    char tmp[256];
01043    char *grp = NULL, *cat = NULL;
01044 
01045    if (!ast_strlen_zero(data)) {
01046       ast_copy_string(tmp, data, sizeof(tmp));
01047       grp = tmp;
01048       if ((cat = strchr(tmp, '@'))) {
01049          *cat++ = '\0';
01050       }
01051    }
01052 
01053    if (!ast_strlen_zero(grp)) {
01054       ast_copy_string(group, grp, group_max);
01055    } else {
01056       *group = '\0';
01057    }
01058 
01059    if (!ast_strlen_zero(cat)) {
01060       ast_copy_string(category, cat, category_max);
01061    }
01062 
01063    return res;
01064 }

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 1172 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().

01173 {
01174    struct ast_group_info *gi = NULL;
01175 
01176    AST_RWLIST_WRLOCK(&groups);
01177    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&groups, gi, group_list) {
01178       if (gi->chan == old) {
01179          gi->chan = new;
01180       } else if (gi->chan == new) {
01181          AST_RWLIST_REMOVE_CURRENT(group_list);
01182          ast_free(gi);
01183       }
01184    }
01185    AST_RWLIST_TRAVERSE_SAFE_END;
01186    AST_RWLIST_UNLOCK(&groups);
01187 
01188    return 0;
01189 }

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 296 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().

00297 {
00298    static int warned = 0;
00299    if (ast_has_voicemail_func) {
00300       return ast_has_voicemail_func(mailbox, folder);
00301    }
00302 
00303    if (warned++ % 10 == 0) {
00304       ast_verb(3, "Message check requested for mailbox %s/folder %s but voicemail not loaded.\n", mailbox, folder ? folder : "INBOX");
00305    }
00306    return 0;
00307 }

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

References ast_inboxcount_func, and ast_verb.

Referenced by sip_send_mwi_to_peer(), and update_registry().

00311 {
00312    static int warned = 0;
00313    if (newmsgs) {
00314       *newmsgs = 0;
00315    }
00316    if (oldmsgs) {
00317       *oldmsgs = 0;
00318    }
00319    if (ast_inboxcount_func) {
00320       return ast_inboxcount_func(mailbox, newmsgs, oldmsgs);
00321    }
00322 
00323    if (warned++ % 10 == 0) {
00324       ast_verb(3, "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
00325    }
00326 
00327    return 0;
00328 }

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

References ast_inboxcount2_func, ast_inboxcount_func, and ast_verb.

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

00331 {
00332    static int warned = 0;
00333    if (newmsgs) {
00334       *newmsgs = 0;
00335    }
00336    if (oldmsgs) {
00337       *oldmsgs = 0;
00338    }
00339    if (urgentmsgs) {
00340       *urgentmsgs = 0;
00341    }
00342    if (ast_inboxcount_func) {
00343       return ast_inboxcount2_func(mailbox, urgentmsgs, newmsgs, oldmsgs);
00344    }
00345 
00346    if (warned++ % 10 == 0) {
00347       ast_verb(3, "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
00348    }
00349 
00350    return 0;
00351 }

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

References ast_messagecount_func, and ast_verb.

Referenced by acf_vmcount_exec().

00362 {
00363    static int warned = 0;
00364    if (ast_messagecount_func) {
00365       return ast_messagecount_func(context, mailbox, folder);
00366    }
00367 
00368    if (!warned) {
00369       warned++;
00370       ast_verb(3, "Message count requested for mailbox %s@%s/%s but voicemail not loaded.\n", mailbox, context, folder);
00371    }
00372 
00373    return 0;
00374 }

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

References ast_test_flag64, and ast_flags64::flags.

01955 {
01956    unsigned int i, found = 0;
01957    for (i = 32; i < 128 && found < len; i++) {
01958       if (ast_test_flag64(flags, options[i].flag)) {
01959          buf[found++] = i;
01960       }
01961    }
01962    buf[found] = '\0';
01963 }

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

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

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

References ast_flags64::flags, and parse_options().

Referenced by conf_exec(), and dial_exec_full().

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

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 2154 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().

02155 {
02156    int res;
02157    char u[10];
02158 #ifdef HAVE_LONG_DOUBLE_WIDER
02159    long double amount;
02160    #define FMT "%30Lf%9s"
02161 #else
02162    double amount;
02163    #define FMT "%30lf%9s"
02164 #endif
02165    if (!timestr) {
02166       return -1;
02167    }
02168 
02169    if ((res = sscanf(timestr, FMT, &amount, u)) == 0) {
02170 #undef FMT
02171       return -1;
02172    } else if (res == 2) {
02173       switch (u[0]) {
02174       case 'h':
02175       case 'H':
02176          unit = TIMELEN_HOURS;
02177          break;
02178       case 's':
02179       case 'S':
02180          unit = TIMELEN_SECONDS;
02181          break;
02182       case 'm':
02183       case 'M':
02184          if (toupper(u[1]) == 'S') {
02185             unit = TIMELEN_MILLISECONDS;
02186          } else if (u[1] == '\0') {
02187             unit = TIMELEN_MINUTES;
02188          }
02189          break;
02190       }
02191    }
02192 
02193    switch (unit) {
02194    case TIMELEN_HOURS:
02195       amount *= 60;
02196       /* fall-through */
02197    case TIMELEN_MINUTES:
02198       amount *= 60;
02199       /* fall-through */
02200    case TIMELEN_SECONDS:
02201       amount *= 1000;
02202       /* fall-through */
02203    case TIMELEN_MILLISECONDS:
02204       ;
02205    }
02206    *result = amount > INT_MAX ? INT_MAX : (int) amount;
02207    return 0;
02208 }

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 246 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().

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

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

References ast_sayname_func.

Referenced by common_exec(), and play_mailbox_owner().

00354 {
00355    if (ast_sayname_func) {
00356       return ast_sayname_func(chan, mailbox, context);
00357    }
00358    return -1;
00359 }

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

Definition at line 1296 of file app.c.

References __ast_app_separate_args().

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

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 2080 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().

02081 {
02082    closefrom(n + 1);
02083 }

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 558 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().

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

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 376 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().

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

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 1965 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().

01966 {
01967    int i;
01968    *consumed = 1;
01969    *result = 0;
01970    if (ast_strlen_zero(stream)) {
01971       *consumed = 0;
01972       return -1;
01973    }
01974 
01975    if (*stream == '\\') {
01976       *consumed = 2;
01977       switch (*(stream + 1)) {
01978       case 'n':
01979          *result = '\n';
01980          break;
01981       case 'r':
01982          *result = '\r';
01983          break;
01984       case 't':
01985          *result = '\t';
01986          break;
01987       case 'x':
01988          /* Hexadecimal */
01989          if (strchr("0123456789ABCDEFabcdef", *(stream + 2)) && *(stream + 2) != '\0') {
01990             *consumed = 3;
01991             if (*(stream + 2) <= '9') {
01992                *result = *(stream + 2) - '0';
01993             } else if (*(stream + 2) <= 'F') {
01994                *result = *(stream + 2) - 'A' + 10;
01995             } else {
01996                *result = *(stream + 2) - 'a' + 10;
01997             }
01998          } else {
01999             ast_log(LOG_ERROR, "Illegal character '%c' in hexadecimal string\n", *(stream + 2));
02000             return -1;
02001          }
02002 
02003          if (strchr("0123456789ABCDEFabcdef", *(stream + 3)) && *(stream + 3) != '\0') {
02004             *consumed = 4;
02005             *result <<= 4;
02006             if (*(stream + 3) <= '9') {
02007                *result += *(stream + 3) - '0';
02008             } else if (*(stream + 3) <= 'F') {
02009                *result += *(stream + 3) - 'A' + 10;
02010             } else {
02011                *result += *(stream + 3) - 'a' + 10;
02012             }
02013          }
02014          break;
02015       case '0':
02016          /* Octal */
02017          *consumed = 2;
02018          for (i = 2; ; i++) {
02019             if (strchr("01234567", *(stream + i)) && *(stream + i) != '\0') {
02020                (*consumed)++;
02021                ast_debug(5, "result was %d, ", *result);
02022                *result <<= 3;
02023                *result += *(stream + i) - '0';
02024                ast_debug(5, "is now %d\n", *result);
02025             } else {
02026                break;
02027             }
02028          }
02029          break;
02030       default:
02031          *result = *(stream + 1);
02032       }
02033    } else {
02034       *result = *stream;
02035       *consumed = 1;
02036    }
02037    return 0;
02038 }

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

References ast_get_encoded_char().

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

02041 {
02042    char *cur = result;
02043    size_t consumed;
02044 
02045    while (cur < result + result_size - 1 && !ast_get_encoded_char(stream, cur, &consumed)) {
02046       cur++;
02047       stream += consumed;
02048    }
02049    *cur = '\0';
02050    return result;
02051 }

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 274 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().

00279 {
00280    ast_has_voicemail_func = has_voicemail_func;
00281    ast_inboxcount_func = inboxcount_func;
00282    ast_inboxcount2_func = inboxcount2_func;
00283    ast_messagecount_func = messagecount_func;
00284    ast_sayname_func = sayname_func;
00285 }

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

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

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

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

Definition at line 1738 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().

01739 {
01740    /* Execute an IVR menu structure */
01741    int res = 0;
01742    int pos = 0;
01743    int retries = 0;
01744    char exten[AST_MAX_EXTENSION] = "s";
01745    if (option_exists(menu, "s") < 0) {
01746       strcpy(exten, "g");
01747       if (option_exists(menu, "g") < 0) {
01748          ast_log(LOG_WARNING, "No 's' nor 'g' extension in menu '%s'!\n", menu->title);
01749          return -1;
01750       }
01751    }
01752    while (!res) {
01753       while (menu->options[pos].option) {
01754          if (!strcasecmp(menu->options[pos].option, exten)) {
01755             res = ivr_dispatch(chan, menu->options + pos, exten, cbdata);
01756             ast_debug(1, "IVR Dispatch of '%s' (pos %d) yields %d\n", exten, pos, res);
01757             if (res < 0) {
01758                break;
01759             } else if (res & RES_UPONE) {
01760                return 0;
01761             } else if (res & RES_EXIT) {
01762                return res;
01763             } else if (res & RES_REPEAT) {
01764                int maxretries = res & 0xffff;
01765                if ((res & RES_RESTART) == RES_RESTART) {
01766                   retries = 0;
01767                } else {
01768                   retries++;
01769                }
01770                if (!maxretries) {
01771                   maxretries = 3;
01772                }
01773                if ((maxretries > 0) && (retries >= maxretries)) {
01774                   ast_debug(1, "Max retries %d exceeded\n", maxretries);
01775                   return -2;
01776                } else {
01777                   if (option_exists(menu, "g") > -1) {
01778                      strcpy(exten, "g");
01779                   } else if (option_exists(menu, "s") > -1) {
01780                      strcpy(exten, "s");
01781                   }
01782                }
01783                pos = 0;
01784                continue;
01785             } else if (res && strchr(AST_DIGIT_ANY, res)) {
01786                ast_debug(1, "Got start of extension, %c\n", res);
01787                exten[1] = '\0';
01788                exten[0] = res;
01789                if ((res = read_newoption(chan, menu, exten, sizeof(exten)))) {
01790                   break;
01791                }
01792                if (option_exists(menu, exten) < 0) {
01793                   if (option_exists(menu, "i")) {
01794                      ast_debug(1, "Invalid extension entered, going to 'i'!\n");
01795                      strcpy(exten, "i");
01796                      pos = 0;
01797                      continue;
01798                   } else {
01799                      ast_debug(1, "Aborting on invalid entry, with no 'i' option!\n");
01800                      res = -2;
01801                      break;
01802                   }
01803                } else {
01804                   ast_debug(1, "New existing extension: %s\n", exten);
01805                   pos = 0;
01806                   continue;
01807                }
01808             }
01809          }
01810          pos++;
01811       }
01812       ast_debug(1, "Stopping option '%s', res is %d\n", exten, res);
01813       pos = 0;
01814       if (!strcasecmp(exten, "s")) {
01815          strcpy(exten, "g");
01816       } else {
01817          break;
01818       }
01819    }
01820    return res;
01821 }

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 528 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.

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

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 1495 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().

01496 {
01497    enum AST_LOCK_RESULT r = AST_LOCK_FAILURE;
01498 
01499    switch (ast_lock_type) {
01500    case AST_LOCK_TYPE_LOCKFILE:
01501       r = ast_lock_path_lockfile(path);
01502       break;
01503    case AST_LOCK_TYPE_FLOCK:
01504       r = ast_lock_path_flock(path);
01505       break;
01506    }
01507 
01508    return r;
01509 }

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

Definition at line 1375 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().

01376 {
01377    char *fs;
01378    int res;
01379    int fd;
01380    time_t start;
01381    struct path_lock *pl;
01382    struct stat st, ost;
01383 
01384    fs = alloca(strlen(path) + 20);
01385 
01386    snprintf(fs, strlen(path) + 19, "%s/lock", path);
01387    if (lstat(fs, &st) == 0) {
01388       if ((st.st_mode & S_IFMT) == S_IFLNK) {
01389          ast_log(LOG_WARNING, "Unable to create lock file "
01390                "'%s': it's already a symbolic link\n",
01391                fs);
01392          return AST_LOCK_FAILURE;
01393       }
01394       if (st.st_nlink > 1) {
01395          ast_log(LOG_WARNING, "Unable to create lock file "
01396                "'%s': %u hard links exist\n",
01397                fs, (unsigned int) st.st_nlink);
01398          return AST_LOCK_FAILURE;
01399       }
01400    }
01401    if ((fd = open(fs, O_WRONLY | O_CREAT, 0600)) < 0) {
01402       ast_log(LOG_WARNING, "Unable to create lock file '%s': %s\n",
01403             fs, strerror(errno));
01404       return AST_LOCK_PATH_NOT_FOUND;
01405    }
01406    if (!(pl = ast_calloc(1, sizeof(*pl)))) {
01407       /* We don't unlink the lock file here, on the possibility that
01408        * someone else created it - better to leave a little mess
01409        * than create a big one by destroying someone else's lock
01410        * and causing something to be corrupted.
01411        */
01412       close(fd);
01413       return AST_LOCK_FAILURE;
01414    }
01415    pl->fd = fd;
01416    pl->path = strdup(path);
01417 
01418    time(&start);
01419    while (
01420       #ifdef SOLARIS
01421       ((res = fcntl(pl->fd, F_SETLK, fcntl(pl->fd, F_GETFL) | O_NONBLOCK)) < 0) &&
01422       #else
01423       ((res = flock(pl->fd, LOCK_EX | LOCK_NB)) < 0) &&
01424       #endif
01425          (errno == EWOULDBLOCK) &&
01426          (time(NULL) - start < 5))
01427       usleep(1000);
01428    if (res) {
01429       ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n",
01430             path, strerror(errno));
01431       /* No unlinking of lock done, since we tried and failed to
01432        * flock() it.
01433        */
01434       path_lock_destroy(pl);
01435       return AST_LOCK_TIMEOUT;
01436    }
01437 
01438    /* Check for the race where the file is recreated or deleted out from
01439     * underneath us.
01440     */
01441    if (lstat(fs, &st) != 0 && fstat(pl->fd, &ost) != 0 &&
01442          st.st_dev != ost.st_dev &&
01443          st.st_ino != ost.st_ino) {
01444       ast_log(LOG_WARNING, "Unable to create lock file '%s': "
01445             "file changed underneath us\n", fs);
01446       path_lock_destroy(pl);
01447       return AST_LOCK_FAILURE;
01448    }
01449 
01450    /* Success: file created, flocked, and is the one we started with */
01451    AST_LIST_LOCK(&path_lock_list);
01452    AST_LIST_INSERT_TAIL(&path_lock_list, pl, le);
01453    AST_LIST_UNLOCK(&path_lock_list);
01454 
01455    ast_debug(1, "Locked path '%s'\n", path);
01456 
01457    return AST_LOCK_SUCCESS;
01458 }

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

Definition at line 1301 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().

01302 {
01303    char *s;
01304    char *fs;
01305    int res;
01306    int fd;
01307    int lp = strlen(path);
01308    time_t start;
01309 
01310    s = alloca(lp + 10);
01311    fs = alloca(lp + 20);
01312 
01313    snprintf(fs, strlen(path) + 19, "%s/.lock-%08lx", path, ast_random());
01314    fd = open(fs, O_WRONLY | O_CREAT | O_EXCL, AST_FILE_MODE);
01315    if (fd < 0) {
01316       ast_log(LOG_ERROR, "Unable to create lock file '%s': %s\n", path, strerror(errno));
01317       return AST_LOCK_PATH_NOT_FOUND;
01318    }
01319    close(fd);
01320 
01321    snprintf(s, strlen(path) + 9, "%s/.lock", path);
01322    start = time(NULL);
01323    while (((res = link(fs, s)) < 0) && (errno == EEXIST) && (time(NULL) - start < 5)) {
01324       sched_yield();
01325    }
01326 
01327    unlink(fs);
01328 
01329    if (res) {
01330       ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n", path, strerror(errno));
01331       return AST_LOCK_TIMEOUT;
01332    } else {
01333       ast_debug(1, "Locked path '%s'\n", path);
01334       return AST_LOCK_SUCCESS;
01335    }
01336 }

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

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

Definition at line 1032 of file app.c.

References __ast_play_and_record().

Referenced by vm_forwardoptions().

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

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

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

Definition at line 1027 of file app.c.

References __ast_play_and_record().

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

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

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

Definition at line 1022 of file app.c.

References __ast_play_and_record(), and S_OR.

Referenced by play_record_review().

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

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

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

Referenced by __ast_play_and_record(), advanced_options(), ast_record_review(), ast_say_counted_adjective(), ast_say_counted_noun(), dialout(), forward_message(), get_folder(), get_folder2(), 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().

00697 {
00698    int d = 0;
00699 
00700    if ((d = ast_streamfile(chan, fn, chan->language))) {
00701       return d;
00702    }
00703 
00704    d = ast_waitstream(chan, AST_DIGIT_ANY);
00705 
00706    ast_stopstream(chan);
00707 
00708    return d;
00709 }

char* ast_read_textfile ( const char *  filename  ) 

Read a file into asterisk.

Definition at line 1830 of file app.c.

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

Referenced by readfile_exec().

01831 {
01832    int fd, count = 0, res;
01833    char *output = NULL;
01834    struct stat filesize;
01835 
01836    if (stat(filename, &filesize) == -1) {
01837       ast_log(LOG_WARNING, "Error can't stat %s\n", filename);
01838       return NULL;
01839    }
01840 
01841    count = filesize.st_size + 1;
01842 
01843    if ((fd = open(filename, O_RDONLY)) < 0) {
01844       ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", filename, strerror(errno));
01845       return NULL;
01846    }
01847 
01848    if ((output = ast_malloc(count))) {
01849       res = read(fd, output, count - 1);
01850       if (res == count - 1) {
01851          output[res] = '\0';
01852       } else {
01853          ast_log(LOG_WARNING, "Short read of %s (%d of %d): %s\n", filename, res, count - 1, strerror(errno));
01854          ast_free(output);
01855          output = NULL;
01856       }
01857    }
01858 
01859    close(fd);
01860 
01861    return output;
01862 }

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 1527 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().

01528 {
01529    int silencethreshold;
01530    int maxsilence = 0;
01531    int res = 0;
01532    int cmd = 0;
01533    int max_attempts = 3;
01534    int attempts = 0;
01535    int recorded = 0;
01536    int message_exists = 0;
01537    /* Note that urgent and private are for flagging messages as such in the future */
01538 
01539    /* barf if no pointer passed to store duration in */
01540    if (!duration) {
01541       ast_log(LOG_WARNING, "Error ast_record_review called without duration pointer\n");
01542       return -1;
01543    }
01544 
01545    cmd = '3';   /* Want to start by recording */
01546 
01547    silencethreshold = ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE);
01548 
01549    while ((cmd >= 0) && (cmd != 't')) {
01550       switch (cmd) {
01551       case '1':
01552          if (!message_exists) {
01553             /* In this case, 1 is to record a message */
01554             cmd = '3';
01555             break;
01556          } else {
01557             ast_stream_and_wait(chan, "vm-msgsaved", "");
01558             cmd = 't';
01559             return res;
01560          }
01561       case '2':
01562          /* Review */
01563          ast_verb(3, "Reviewing the recording\n");
01564          cmd = ast_stream_and_wait(chan, recordfile, AST_DIGIT_ANY);
01565          break;
01566       case '3':
01567          message_exists = 0;
01568          /* Record */
01569          ast_verb(3, "R%secording\n", recorded == 1 ? "e-r" : "");
01570          recorded = 1;
01571          if ((cmd = ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, silencethreshold, maxsilence, path)) == -1) {
01572             /* User has hung up, no options to give */
01573             return cmd;
01574          }
01575          if (cmd == '0') {
01576             break;
01577          } else if (cmd == '*') {
01578             break;
01579          } else {
01580             /* If all is well, a message exists */
01581             message_exists = 1;
01582             cmd = 0;
01583          }
01584          break;
01585       case '4':
01586       case '5':
01587       case '6':
01588       case '7':
01589       case '8':
01590       case '9':
01591       case '*':
01592       case '#':
01593          cmd = ast_play_and_wait(chan, "vm-sorry");
01594          break;
01595       default:
01596          if (message_exists) {
01597             cmd = ast_play_and_wait(chan, "vm-review");
01598          } else {
01599             if (!(cmd = ast_play_and_wait(chan, "vm-torerecord"))) {
01600                cmd = ast_waitfordigit(chan, 600);
01601             }
01602          }
01603 
01604          if (!cmd) {
01605             cmd = ast_waitfordigit(chan, 6000);
01606          }
01607          if (!cmd) {
01608             attempts++;
01609          }
01610          if (attempts > max_attempts) {
01611             cmd = 't';
01612          }
01613       }
01614    }
01615    if (cmd == 't') {
01616       cmd = 0;
01617    }
01618    return cmd;
01619 }

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 2085 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(), statpost(), and vm_check_password_shell().

02086 {
02087    sigset_t signal_set, old_set;
02088    int pid;
02089 
02090    /* Don't let the default signal handler for children reap our status */
02091    if (stop_reaper) {
02092       ast_replace_sigchld();
02093    }
02094 
02095    sigfillset(&signal_set);
02096    pthread_sigmask(SIG_BLOCK, &signal_set, &old_set);
02097 
02098    pid = fork();
02099 
02100    if (pid != 0) {
02101       /* Fork failed or parent */
02102       pthread_sigmask(SIG_SETMASK, &old_set, NULL);
02103       if (!stop_reaper && pid > 0) {
02104          struct zombie *cur = ast_calloc(1, sizeof(*cur));
02105          if (cur) {
02106             cur->pid = pid;
02107             AST_LIST_LOCK(&zombies);
02108             AST_LIST_INSERT_TAIL(&zombies, cur, list);
02109             AST_LIST_UNLOCK(&zombies);
02110             if (shaun_of_the_dead_thread == AST_PTHREADT_NULL) {
02111                if (ast_pthread_create_background(&shaun_of_the_dead_thread, NULL, shaun_of_the_dead, NULL)) {
02112                   ast_log(LOG_ERROR, "Shaun of the Dead wants to kill zombies, but can't?!!\n");
02113                   shaun_of_the_dead_thread = AST_PTHREADT_NULL;
02114                }
02115             }
02116          }
02117       }
02118       return pid;
02119    } else {
02120       /* Child */
02121 #ifdef HAVE_CAP
02122       cap_t cap = cap_from_text("cap_net_admin-eip");
02123 
02124       if (cap_set_proc(cap)) {
02125          ast_log(LOG_WARNING, "Unable to remove capabilities.\n");
02126       }
02127       cap_free(cap);
02128 #endif
02129 
02130       /* Before we unblock our signals, return our trapped signals back to the defaults */
02131       signal(SIGHUP, SIG_DFL);
02132       signal(SIGCHLD, SIG_DFL);
02133       signal(SIGINT, SIG_DFL);
02134       signal(SIGURG, SIG_DFL);
02135       signal(SIGTERM, SIG_DFL);
02136       signal(SIGPIPE, SIG_DFL);
02137       signal(SIGXFSZ, SIG_DFL);
02138 
02139       /* unblock important signal handlers */
02140       if (pthread_sigmask(SIG_UNBLOCK, &signal_set, NULL)) {
02141          ast_log(LOG_WARNING, "unable to unblock signals: %s\n", strerror(errno));
02142          _exit(1);
02143       }
02144 
02145       return pid;
02146    }
02147 }

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

References ast_unreplace_sigchld().

Referenced by agi_exec_full(), and run_ras().

02150 {
02151    ast_unreplace_sigchld();
02152 }

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

01491 {
01492    ast_lock_type = type;
01493 }

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 2053 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().

02054 {
02055    char next, *buf;
02056    size_t offset = 0;
02057    size_t consumed;
02058 
02059    if (strchr(stream, '\\')) {
02060       while (!ast_get_encoded_char(stream, &next, &consumed)) {
02061          if (offset + 2 > ast_str_size(*str) && maxlen > -1) {
02062             ast_str_make_space(str, maxlen > 0 ? maxlen : (ast_str_size(*str) + 48) * 2 - 48);
02063          }
02064          if (offset + 2 > ast_str_size(*str)) {
02065             break;
02066          }
02067          buf = ast_str_buffer(*str);
02068          buf[offset++] = next;
02069          stream += consumed;
02070       }
02071       buf = ast_str_buffer(*str);
02072       buf[offset++] = '\0';
02073       ast_str_update(*str);
02074    } else {
02075       ast_str_set(str, maxlen, "%s", stream);
02076    }
02077    return 0;
02078 }

AST_THREADSTORAGE_PUBLIC ( ast_str_thread_global_buf   ) 

void ast_uninstall_vm_functions ( void   ) 

Definition at line 287 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().

00288 {
00289    ast_has_voicemail_func = NULL;
00290    ast_inboxcount_func = NULL;
00291    ast_inboxcount2_func = NULL;
00292    ast_messagecount_func = NULL;
00293    ast_sayname_func = NULL;
00294 }

int ast_unlock_path ( const char *  path  ) 

Unlock a path.

Definition at line 1511 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().

01512 {
01513    int r = 0;
01514 
01515    switch (ast_lock_type) {
01516    case AST_LOCK_TYPE_LOCKFILE:
01517       r = ast_unlock_path_lockfile(path);
01518       break;
01519    case AST_LOCK_TYPE_FLOCK:
01520       r = ast_unlock_path_flock(path);
01521       break;
01522    }
01523 
01524    return r;
01525 }

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

Definition at line 1460 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().

01461 {
01462    char *s;
01463    struct path_lock *p;
01464 
01465    s = alloca(strlen(path) + 20);
01466 
01467    AST_LIST_LOCK(&path_lock_list);
01468    AST_LIST_TRAVERSE_SAFE_BEGIN(&path_lock_list, p, le) {
01469       if (!strcmp(p->path, path)) {
01470          AST_LIST_REMOVE_CURRENT(le);
01471          break;
01472       }
01473    }
01474    AST_LIST_TRAVERSE_SAFE_END;
01475    AST_LIST_UNLOCK(&path_lock_list);
01476 
01477    if (p) {
01478       snprintf(s, strlen(path) + 19, "%s/lock", path);
01479       unlink(s);
01480       path_lock_destroy(p);
01481       ast_log(LOG_DEBUG, "Unlocked path '%s'\n", path);
01482    } else {
01483       ast_log(LOG_DEBUG, "Failed to unlock path '%s': "
01484             "lock not found\n", path);
01485    }
01486 
01487    return 0;
01488 }

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

Definition at line 1338 of file app.c.

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

Referenced by ast_unlock_path().

01339 {
01340    char *s;
01341    int res;
01342 
01343    s = alloca(strlen(path) + 10);
01344 
01345    snprintf(s, strlen(path) + 9, "%s/%s", path, ".lock");
01346 
01347    if ((res = unlink(s))) {
01348       ast_log(LOG_ERROR, "Could not unlock path '%s': %s\n", path, strerror(errno));
01349    } else {
01350       ast_debug(1, "Unlocked path '%s'\n", path);
01351    }
01352 
01353    return res;
01354 }

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

Definition at line 1628 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().

01629 {
01630    int res;
01631    int (*ivr_func)(struct ast_channel *, void *);
01632    char *c;
01633    char *n;
01634 
01635    switch (option->action) {
01636    case AST_ACTION_UPONE:
01637       return RES_UPONE;
01638    case AST_ACTION_EXIT:
01639       return RES_EXIT | (((unsigned long)(option->adata)) & 0xffff);
01640    case AST_ACTION_REPEAT:
01641       return RES_REPEAT | (((unsigned long)(option->adata)) & 0xffff);
01642    case AST_ACTION_RESTART:
01643       return RES_RESTART ;
01644    case AST_ACTION_NOOP:
01645       return 0;
01646    case AST_ACTION_BACKGROUND:
01647       res = ast_stream_and_wait(chan, (char *)option->adata, AST_DIGIT_ANY);
01648       if (res < 0) {
01649          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01650          res = 0;
01651       }
01652       return res;
01653    case AST_ACTION_PLAYBACK:
01654       res = ast_stream_and_wait(chan, (char *)option->adata, "");
01655       if (res < 0) {
01656          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01657          res = 0;
01658       }
01659       return res;
01660    case AST_ACTION_MENU:
01661       if ((res = ast_ivr_menu_run_internal(chan, (struct ast_ivr_menu *)option->adata, cbdata)) == -2) {
01662          /* Do not pass entry errors back up, treat as though it was an "UPONE" */
01663          res = 0;
01664       }
01665       return res;
01666    case AST_ACTION_WAITOPTION:
01667       if (!(res = ast_waitfordigit(chan, chan->pbx ? chan->pbx->rtimeoutms : 10000))) {
01668          return 't';
01669       }
01670       return res;
01671    case AST_ACTION_CALLBACK:
01672       ivr_func = option->adata;
01673       res = ivr_func(chan, cbdata);
01674       return res;
01675    case AST_ACTION_TRANSFER:
01676       res = ast_parseable_goto(chan, option->adata);
01677       return 0;
01678    case AST_ACTION_PLAYLIST:
01679    case AST_ACTION_BACKLIST:
01680       res = 0;
01681       c = ast_strdupa(option->adata);
01682       while ((n = strsep(&c, ";"))) {
01683          if ((res = ast_stream_and_wait(chan, n,
01684                (option->action == AST_ACTION_BACKLIST) ? AST_DIGIT_ANY : ""))) {
01685             break;
01686          }
01687       }
01688       ast_stopstream(chan);
01689       return res;
01690    default:
01691       ast_log(LOG_NOTICE, "Unknown dispatch function %d, ignoring!\n", option->action);
01692       return 0;
01693    }
01694    return -1;
01695 }

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

Definition at line 495 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.

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

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

Definition at line 466 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.

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

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

Definition at line 451 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.

00452 {
00453    struct linear_state *ls = params;
00454 
00455    if (ls->origwfmt && ast_set_write_format(chan, ls->origwfmt)) {
00456       ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, ls->origwfmt);
00457    }
00458 
00459    if (ls->autoclose) {
00460       close(ls->fd);
00461    }
00462 
00463    ast_free(params);
00464 }

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

Definition at line 1697 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01698 {
01699    int x;
01700    for (x = 0; menu->options[x].option; x++) {
01701       if (!strcasecmp(menu->options[x].option, option)) {
01702          return x;
01703       }
01704    }
01705    return -1;
01706 }

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

Definition at line 1708 of file app.c.

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

Referenced by read_newoption().

01709 {
01710    int x;
01711    for (x = 0; menu->options[x].option; x++) {
01712       if ((!strncasecmp(menu->options[x].option, option, strlen(option))) &&
01713             (menu->options[x].option[strlen(option)])) {
01714          return x;
01715       }
01716    }
01717    return -1;
01718 }

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

Definition at line 1864 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().

01865 {
01866    char *s, *arg;
01867    int curarg, res = 0;
01868    unsigned int argloc;
01869    struct ast_flags *flags = _flags;
01870    struct ast_flags64 *flags64 = _flags;
01871 
01872    if (flaglen == 32) {
01873       ast_clear_flag(flags, AST_FLAGS_ALL);
01874    } else {
01875       flags64->flags = 0;
01876    }
01877 
01878    if (!optstr) {
01879       return 0;
01880    }
01881 
01882    s = optstr;
01883    while (*s) {
01884       curarg = *s++ & 0x7f;   /* the array (in app.h) has 128 entries */
01885       argloc = options[curarg].arg_index;
01886       if (*s == '(') {
01887          int paren = 1, quote = 0;
01888          int parsequotes = (s[1] == '"') ? 1 : 0;
01889 
01890          /* Has argument */
01891          arg = ++s;
01892          for (; *s; s++) {
01893             if (*s == '(' && !quote) {
01894                paren++;
01895             } else if (*s == ')' && !quote) {
01896                /* Count parentheses, unless they're within quotes (or backslashed, below) */
01897                paren--;
01898             } else if (*s == '"' && parsequotes) {
01899                /* Leave embedded quotes alone, unless they are the first character */
01900                quote = quote ? 0 : 1;
01901                ast_copy_string(s, s + 1, INT_MAX);
01902                s--;
01903             } else if (*s == '\\') {
01904                if (!quote) {
01905                   /* If a backslash is found outside of quotes, remove it */
01906                   ast_copy_string(s, s + 1, INT_MAX);
01907                } else if (quote && s[1] == '"') {
01908                   /* Backslash for a quote character within quotes, remove the backslash */
01909                   ast_copy_string(s, s + 1, INT_MAX);
01910                } else {
01911                   /* Backslash within quotes, keep both characters */
01912                   s++;
01913                }
01914             }
01915 
01916             if (paren == 0) {
01917                break;
01918             }
01919          }
01920          /* This will find the closing paren we found above, or none, if the string ended before we found one. */
01921          if ((s = strchr(s, ')'))) {
01922             if (argloc) {
01923                args[argloc - 1] = arg;
01924             }
01925             *s++ = '\0';
01926          } else {
01927             ast_log(LOG_WARNING, "Missing closing parenthesis for argument '%c' in string '%s'\n", curarg, arg);
01928             res = -1;
01929             break;
01930          }
01931       } else if (argloc) {
01932          args[argloc - 1] = "";
01933       }
01934       if (flaglen == 32) {
01935          ast_set_flag(flags, options[curarg].flag);
01936       } else {
01937          ast_set_flag64(flags64, options[curarg].flag);
01938       }
01939    }
01940 
01941    return res;
01942 }

static void path_lock_destroy ( struct path_lock obj  )  [static]

Definition at line 1364 of file app.c.

References free.

Referenced by ast_lock_path_flock(), and ast_unlock_path_flock().

01365 {
01366    if (obj->fd >= 0) {
01367       close(obj->fd);
01368    }
01369    if (obj->path) {
01370       free(obj->path);
01371    }
01372    free(obj);
01373 }

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

Definition at line 1720 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01721 {
01722    int res = 0;
01723    int ms;
01724    while (option_matchmore(menu, exten)) {
01725       ms = chan->pbx ? chan->pbx->dtimeoutms : 5000;
01726       if (strlen(exten) >= maxexten - 1) {
01727          break;
01728       }
01729       if ((res = ast_waitfordigit(chan, ms)) < 1) {
01730          break;
01731       }
01732       exten[strlen(exten) + 1] = '\0';
01733       exten[strlen(exten)] = res;
01734    }
01735    return res > 0 ? 0 : res;
01736 }

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

Definition at line 69 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().

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


Variable Documentation

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

Definition at line 268 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 270 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 269 of file app.c.

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

enum AST_LOCK_TYPE ast_lock_type = AST_LOCK_TYPE_LOCKFILE [static]

Definition at line 221 of file app.c.

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

Definition at line 272 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 271 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 1019 of file app.c.

const char default_canceldtmf[] = "" [static]

Definition at line 1020 of file app.c.

int global_maxsilence = 0 [static]

Definition at line 712 of file app.c.

int global_silence_threshold = 128 [static]

Definition at line 711 of file app.c.

struct ast_generator linearstream [static]

Definition at line 521 of file app.c.

Referenced by ast_linear_stream().

pthread_t shaun_of_the_dead_thread = AST_PTHREADT_NULL [static]

Definition at line 60 of file app.c.


Generated on Mon Jun 27 16:50:57 2011 for Asterisk - The Open Source Telephony Project by  doxygen 1.4.7