Sat Apr 12 07:12:28 2008

Asterisk developer's documentation


app.c File Reference

Convenient Application Routines. More...

#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <signal.h>
#include <errno.h>
#include <unistd.h>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <regex.h>
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/file.h"
#include "asterisk/app.h"
#include "asterisk/dsp.h"
#include "asterisk/logger.h"
#include "asterisk/options.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/indications.h"
#include "asterisk/linkedlists.h"

Include dependency graph for app.c:

Go to the source code of this file.

Data Structures

struct  linear_state

Defines

#define MAX_OTHER_FORMATS   10
#define RES_EXIT   (1 << 17)
#define RES_REPEAT   (1 << 18)
#define RES_RESTART   ((1 << 19) | RES_REPEAT)
#define RES_UPONE   (1 << 16)

Functions

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.
int ast_app_getdata (struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout)
 Plays a stream and gets DTMF data from a channel.
int ast_app_getdata_full (struct ast_channel *c, char *prompt, char *s, int maxlen, int timeout, int audiofd, int ctrlfd)
 Full version with audiofd and controlfd. NOTE: returns '2' on ctrlfd available, not '1' like other full functions.
int ast_app_group_discard (struct ast_channel *chan)
int ast_app_group_get_count (const char *group, const char *category)
struct ast_group_infoast_app_group_list_head (void)
int ast_app_group_list_lock (void)
int ast_app_group_list_unlock (void)
int ast_app_group_match_get_count (const char *groupmatch, const char *category)
int ast_app_group_set_channel (struct ast_channel *chan, const char *data)
int ast_app_group_split_group (const char *data, char *group, int group_max, char *category, int category_max)
int ast_app_group_update (struct ast_channel *old, struct ast_channel *new)
int ast_app_has_voicemail (const char *mailbox, const char *folder)
int ast_app_inboxcount (const char *mailbox, int *newmsgs, int *oldmsgs)
int ast_app_messagecount (const char *context, const char *mailbox, const char *folder)
int ast_app_parse_options (const struct ast_app_option *options, struct ast_flags *flags, char **args, char *optstr)
 Parses a string containing application options and sets flags/arguments.
unsigned int ast_app_separate_args (char *buf, char delim, char **array, int arraylen)
 Separate a string into arguments in an array.
int ast_control_streamfile (struct ast_channel *chan, const char *file, const char *fwd, const char *rev, const char *stop, const char *pause, const char *restart, int skipms)
int ast_dtmf_stream (struct ast_channel *chan, struct ast_channel *peer, const char *digits, int between)
 Send DTMF to a channel.
void ast_install_vm_functions (int(*has_voicemail_func)(const char *mailbox, const char *folder), int(*inboxcount_func)(const char *mailbox, int *newmsgs, int *oldmsgs), int(*messagecount_func)(const char *context, const char *mailbox, const char *folder))
int ast_ivr_menu_run (struct ast_channel *chan, struct ast_ivr_menu *menu, void *cbdata)
 Runs an IVR menu.
static int ast_ivr_menu_run_internal (struct ast_channel *chan, struct ast_ivr_menu *menu, void *cbdata)
int ast_linear_stream (struct ast_channel *chan, const char *filename, int fd, int allowoverride)
static AST_LIST_HEAD_STATIC (groups, ast_group_info)
enum AST_LOCK_RESULT ast_lock_path (const char *path)
 Lock a filesystem path.
int ast_play_and_prepend (struct ast_channel *chan, char *playfile, char *recordfile, int maxtime, char *fmt, int *duration, int beep, int silencethreshold, int maxsilence)
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)
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)
char * ast_read_textfile (const char *filename)
int ast_record_review (struct ast_channel *chan, const char *playfile, const char *recordfile, int maxtime, const char *fmt, int *duration, const char *path)
void ast_uninstall_vm_functions (void)
int ast_unlock_path (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 read_newoption (struct ast_channel *chan, struct ast_ivr_menu *menu, char *exten, int maxexten)

Variables

static int(* ast_has_voicemail_func )(const char *mailbox, const char *folder) = NULL
static int(* ast_inboxcount_func )(const char *mailbox, int *newmsgs, int *oldmsgs) = NULL
static int(* ast_messagecount_func )(const char *context, const char *mailbox, const char *folder) = NULL
static char default_acceptdtmf [] = "#"
static char default_canceldtmf [] = ""
static int global_maxsilence = 0
static int global_silence_threshold = 128
static struct ast_generator linearstream


Detailed Description

Convenient Application Routines.

Author:
Mark Spencer <markster@digium.com>

Definition in file app.c.


Define Documentation

#define MAX_OTHER_FORMATS   10

Definition at line 54 of file app.c.

Referenced by __ast_play_and_record().

#define RES_EXIT   (1 << 17)

Definition at line 1146 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_REPEAT   (1 << 18)

Definition at line 1147 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

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

Definition at line 1148 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().

#define RES_UPONE   (1 << 16)

Definition at line 1145 of file app.c.

Referenced by ast_ivr_menu_run_internal(), and ivr_dispatch().


Function Documentation

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

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

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

00492 {
00493    int d = 0;
00494    char *fmts;
00495    char comment[256];
00496    int x, fmtcnt = 1, res = -1, outmsg = 0;
00497    struct ast_filestream *others[MAX_OTHER_FORMATS];
00498    char *sfmt[MAX_OTHER_FORMATS];
00499    char *stringp = NULL;
00500    time_t start, end;
00501    struct ast_dsp *sildet = NULL;   /* silence detector dsp */
00502    int totalsilence = 0;
00503    int rfmt = 0;
00504    struct ast_silence_generator *silgen = NULL;
00505    char prependfile[80];
00506 
00507    if (silencethreshold < 0)
00508       silencethreshold = global_silence_threshold;
00509 
00510    if (maxsilence < 0)
00511       maxsilence = global_maxsilence;
00512 
00513    /* barf if no pointer passed to store duration in */
00514    if (duration == NULL) {
00515       ast_log(LOG_WARNING, "Error play_and_record called without duration pointer\n");
00516       return -1;
00517    }
00518 
00519    if (option_debug)
00520       ast_log(LOG_DEBUG,"play_and_record: %s, %s, '%s'\n", playfile ? playfile : "<None>", recordfile, fmt);
00521    snprintf(comment, sizeof(comment), "Playing %s, Recording to: %s on %s\n", playfile ? playfile : "<None>", recordfile, chan->name);
00522 
00523    if (playfile || beep) {
00524       if (!beep)
00525          d = ast_play_and_wait(chan, playfile);
00526       if (d > -1)
00527          d = ast_stream_and_wait(chan, "beep", chan->language, "");
00528       if (d < 0)
00529          return -1;
00530    }
00531 
00532    if (prepend) {
00533       ast_copy_string(prependfile, recordfile, sizeof(prependfile)); 
00534       strncat(prependfile, "-prepend", sizeof(prependfile) - strlen(prependfile) - 1);
00535    }
00536 
00537    fmts = ast_strdupa(fmt);
00538 
00539    stringp = fmts;
00540    strsep(&stringp, "|");
00541    if (option_debug)
00542       ast_log(LOG_DEBUG, "Recording Formats: sfmts=%s\n", fmts);
00543    sfmt[0] = ast_strdupa(fmts);
00544 
00545    while ((fmt = strsep(&stringp, "|"))) {
00546       if (fmtcnt > MAX_OTHER_FORMATS - 1) {
00547          ast_log(LOG_WARNING, "Please increase MAX_OTHER_FORMATS in app.c\n");
00548          break;
00549       }
00550       sfmt[fmtcnt++] = ast_strdupa(fmt);
00551    }
00552 
00553    end = start = time(NULL);  /* pre-initialize end to be same as start in case we never get into loop */
00554    for (x = 0; x < fmtcnt; x++) {
00555       others[x] = ast_writefile(prepend ? prependfile : recordfile, sfmt[x], comment, O_TRUNC, 0, 0777);
00556       if (option_verbose > 2)
00557          ast_verbose(VERBOSE_PREFIX_3 "x=%d, open writing:  %s format: %s, %p\n", x, prepend ? prependfile : recordfile, sfmt[x], others[x]);
00558 
00559       if (!others[x])
00560          break;
00561    }
00562 
00563    if (path)
00564       ast_unlock_path(path);
00565 
00566    if (maxsilence > 0) {
00567       sildet = ast_dsp_new(); /* Create the silence detector */
00568       if (!sildet) {
00569          ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
00570          return -1;
00571       }
00572       ast_dsp_set_threshold(sildet, silencethreshold);
00573       rfmt = chan->readformat;
00574       res = ast_set_read_format(chan, AST_FORMAT_SLINEAR);
00575       if (res < 0) {
00576          ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
00577          ast_dsp_free(sildet);
00578          return -1;
00579       }
00580    }
00581 
00582    if (!prepend) {
00583       /* Request a video update */
00584       ast_indicate(chan, AST_CONTROL_VIDUPDATE);
00585 
00586       if (ast_opt_transmit_silence)
00587          silgen = ast_channel_start_silence_generator(chan);
00588    }
00589 
00590    if (x == fmtcnt) {
00591       /* Loop forever, writing the packets we read to the writer(s), until
00592          we read a digit or get a hangup */
00593       struct ast_frame *f;
00594       for (;;) {
00595          res = ast_waitfor(chan, 2000);
00596          if (!res) {
00597             if (option_debug)
00598                ast_log(LOG_DEBUG, "One waitfor failed, trying another\n");
00599             /* Try one more time in case of masq */
00600             res = ast_waitfor(chan, 2000);
00601             if (!res) {
00602                ast_log(LOG_WARNING, "No audio available on %s??\n", chan->name);
00603                res = -1;
00604             }
00605          }
00606 
00607          if (res < 0) {
00608             f = NULL;
00609             break;
00610          }
00611          f = ast_read(chan);
00612          if (!f)
00613             break;
00614          if (f->frametype == AST_FRAME_VOICE) {
00615             /* write each format */
00616             for (x = 0; x < fmtcnt; x++) {
00617                if (prepend && !others[x])
00618                   break;
00619                res = ast_writestream(others[x], f);
00620             }
00621 
00622             /* Silence Detection */
00623             if (maxsilence > 0) {
00624                int dspsilence = 0;
00625                ast_dsp_silence(sildet, f, &dspsilence);
00626                if (dspsilence)
00627                   totalsilence = dspsilence;
00628                else
00629                   totalsilence = 0;
00630 
00631                if (totalsilence > maxsilence) {
00632                   /* Ended happily with silence */
00633                   if (option_verbose > 2)
00634                      ast_verbose( VERBOSE_PREFIX_3 "Recording automatically stopped after a silence of %d seconds\n", totalsilence/1000);
00635                   res = 'S';
00636                   outmsg = 2;
00637                   break;
00638                }
00639             }
00640             /* Exit on any error */
00641             if (res) {
00642                ast_log(LOG_WARNING, "Error writing frame\n");
00643                break;
00644             }
00645          } else if (f->frametype == AST_FRAME_VIDEO) {
00646             /* Write only once */
00647             ast_writestream(others[0], f);
00648          } else if (f->frametype == AST_FRAME_DTMF) {
00649             if (prepend) {
00650             /* stop recording with any digit */
00651                if (option_verbose > 2) 
00652                   ast_verbose(VERBOSE_PREFIX_3 "User ended message by pressing %c\n", f->subclass);
00653                res = 't';
00654                outmsg = 2;
00655                break;
00656             }
00657             if (strchr(acceptdtmf, f->subclass)) {
00658                if (option_verbose > 2)
00659                   ast_verbose(VERBOSE_PREFIX_3 "User ended message by pressing %c\n", f->subclass);
00660                res = f->subclass;
00661                outmsg = 2;
00662                break;
00663             }
00664             if (strchr(canceldtmf, f->subclass)) {
00665                if (option_verbose > 2)
00666                   ast_verbose(VERBOSE_PREFIX_3 "User cancelled message by pressing %c\n", f->subclass);
00667                res = f->subclass;
00668                outmsg = 0;
00669                break;
00670             }
00671          }
00672          if (maxtime) {
00673             end = time(NULL);
00674             if (maxtime < (end - start)) {
00675                if (option_verbose > 2)
00676                   ast_verbose(VERBOSE_PREFIX_3 "Took too long, cutting it short...\n");
00677                res = 't';
00678                outmsg = 2;
00679                break;
00680             }
00681          }
00682          ast_frfree(f);
00683       }
00684       if (!f) {
00685          if (option_verbose > 2)
00686             ast_verbose(VERBOSE_PREFIX_3 "User hung up\n");
00687          res = -1;
00688          outmsg = 1;
00689       } else {
00690          ast_frfree(f);
00691       }
00692    } else {
00693       ast_log(LOG_WARNING, "Error creating writestream '%s', format '%s'\n", recordfile, sfmt[x]);
00694    }
00695 
00696    if (!prepend) {
00697       if (silgen)
00698          ast_channel_stop_silence_generator(chan, silgen);
00699    }
00700 
00701    /*!\note
00702     * Instead of asking how much time passed (end - start), calculate the number
00703     * of seconds of audio which actually went into the file.  This fixes a
00704     * problem where audio is stopped up on the network and never gets to us.
00705     *
00706     * Note that we still want to use the number of seconds passed for the max
00707     * message, otherwise we could get a situation where this stream is never
00708     * closed (which would create a resource leak).
00709     */
00710    *duration = ast_tellstream(others[0]) / 8000;
00711 
00712    if (!prepend) {
00713       for (x = 0; x < fmtcnt; x++) {
00714          if (!others[x])
00715             break;
00716          /*!\note
00717           * If we ended with silence, trim all but the first 200ms of silence
00718           * off the recording.  However, if we ended with '#', we don't want
00719           * to trim ANY part of the recording.
00720           */
00721          if (res > 0 && totalsilence)
00722             ast_stream_rewind(others[x], totalsilence - 200);
00723          ast_truncstream(others[x]);
00724          ast_closestream(others[x]);
00725       }
00726    }
00727 
00728    if (prepend && outmsg) {
00729       struct ast_filestream *realfiles[MAX_OTHER_FORMATS];
00730       struct ast_frame *fr;
00731 
00732       for (x = 0; x < fmtcnt; x++) {
00733          snprintf(comment, sizeof(comment), "Opening the real file %s.%s\n", recordfile, sfmt[x]);
00734          realfiles[x] = ast_readfile(recordfile, sfmt[x], comment, O_RDONLY, 0, 0);
00735          if (!others[x] || !realfiles[x])
00736             break;
00737          /*!\note Same logic as above. */
00738          if (totalsilence)
00739             ast_stream_rewind(others[x], totalsilence - 200);
00740          ast_truncstream(others[x]);
00741          /* add the original file too */
00742          while ((fr = ast_readframe(realfiles[x]))) {
00743             ast_writestream(others[x], fr);
00744             ast_frfree(fr);
00745          }
00746          ast_closestream(others[x]);
00747          ast_closestream(realfiles[x]);
00748          ast_filerename(prependfile, recordfile, sfmt[x]);
00749          if (option_verbose > 3)
00750             ast_verbose(VERBOSE_PREFIX_4 "Recording Format: sfmts=%s, prependfile %s, recordfile %s\n", sfmt[x], prependfile, recordfile);
00751          ast_filedelete(prependfile, sfmt[x]);
00752       }
00753    }
00754    if (rfmt && ast_set_read_format(chan, rfmt)) {
00755       ast_log(LOG_WARNING, "Unable to restore format %s to channel '%s'\n", ast_getformatname(rfmt), chan->name);
00756    }
00757    if (outmsg == 2) {
00758       ast_stream_and_wait(chan, "auth-thankyou", chan->language, "");
00759    }
00760    if (sildet)
00761       ast_dsp_free(sildet);
00762    return res;
00763 }

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

Present a dialtone and collect a certain length extension.

Returns:
Returns 1 on valid extension entered, -1 on hangup, or 0 on invalid extension.
Note:
Note that if 'collect' holds digits already, new digits will be appended, so be sure it's initialized properly

Definition at line 65 of file app.c.

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

Referenced by builtin_atxfer(), and builtin_blindtransfer().

00066 {
00067    struct tone_zone_sound *ts;
00068    int res=0, x=0;
00069 
00070    if (maxlen > size)
00071       maxlen = size;
00072    
00073    if (!timeout && chan->pbx)
00074       timeout = chan->pbx->dtimeout;
00075    else if (!timeout)
00076       timeout = 5;
00077    
00078    ts = ast_get_indication_tone(chan->zone,"dial");
00079    if (ts && ts->data[0])
00080       res = ast_playtones_start(chan, 0, ts->data, 0);
00081    else 
00082       ast_log(LOG_NOTICE,"Huh....? no dial for indications?\n");
00083    
00084    for (x = strlen(collect); x < maxlen; ) {
00085       res = ast_waitfordigit(chan, timeout);
00086       if (!ast_ignore_pattern(context, collect))
00087          ast_playtones_stop(chan);
00088       if (res < 1)
00089          break;
00090       if (res == '#')
00091          break;
00092       collect[x++] = res;
00093       if (!ast_matchmore_extension(chan, context, collect, 1, chan->cid.cid_num))
00094          break;
00095    }
00096    if (res >= 0)
00097       res = ast_exists_extension(chan, context, collect, 1, chan->cid.cid_num) ? 1 : 0;
00098    return res;
00099 }

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

Plays a stream and gets DTMF data from a channel.

Parameters:
c 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 107 of file app.c.

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

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

00108 {
00109    int res,to,fto;
00110    /* XXX Merge with full version? XXX */
00111    if (maxlen)
00112       s[0] = '\0';
00113    if (prompt) {
00114       res = ast_streamfile(c, prompt, c->language);
00115       if (res < 0)
00116          return res;
00117    }
00118    fto = c->pbx ? c->pbx->rtimeout * 1000 : 6000;
00119    to = c->pbx ? c->pbx->dtimeout * 1000 : 2000;
00120 
00121    if (timeout > 0) 
00122       fto = to = timeout;
00123    if (timeout < 0) 
00124       fto = to = 1000000000;
00125    res = ast_readstring(c, s, maxlen, to, fto, "#");
00126    return res;
00127 }

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

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

Definition at line 130 of file app.c.

References ast_readstring_full(), and ast_streamfile().

Referenced by handle_getdata().

00131 {
00132    int res, to, fto;
00133    if (prompt) {
00134       res = ast_streamfile(c, prompt, c->language);
00135       if (res < 0)
00136          return res;
00137    }
00138    fto = 6000;
00139    to = 2000;
00140    if (timeout > 0) 
00141       fto = to = timeout;
00142    if (timeout < 0) 
00143       fto = to = 1000000000;
00144    res = ast_readstring_full(c, s, maxlen, to, fto, "#", audiofd, ctrlfd);
00145    return res;
00146 }

int ast_app_group_discard ( struct ast_channel chan  ) 

Discard all group counting for a channel

Definition at line 914 of file app.c.

References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_group_info::chan, and free.

Referenced by ast_channel_free().

00915 {
00916    struct ast_group_info *gi = NULL;
00917    
00918    AST_LIST_LOCK(&groups);
00919    AST_LIST_TRAVERSE_SAFE_BEGIN(&groups, gi, list) {
00920       if (gi->chan == chan) {
00921          AST_LIST_REMOVE_CURRENT(&groups, list);
00922          free(gi);
00923       }
00924    }
00925         AST_LIST_TRAVERSE_SAFE_END
00926    AST_LIST_UNLOCK(&groups);
00927    
00928    return 0;
00929 }

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

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

Referenced by group_count_function_read().

00858 {
00859    struct ast_group_info *gi = NULL;
00860    int count = 0;
00861 
00862    if (ast_strlen_zero(group))
00863       return 0;
00864    
00865    AST_LIST_LOCK(&groups);
00866    AST_LIST_TRAVERSE(&groups, gi, list) {
00867       if (!strcasecmp(gi->group, group) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
00868          count++;
00869    }
00870    AST_LIST_UNLOCK(&groups);
00871 
00872    return count;
00873 }

struct ast_group_info* ast_app_group_list_head ( void   )  [read]

Get the head of the group count list

Definition at line 936 of file app.c.

References AST_LIST_FIRST.

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

00937 {
00938    return AST_LIST_FIRST(&groups);
00939 }

int ast_app_group_list_lock ( void   ) 

Lock the group count list

Definition at line 931 of file app.c.

References AST_LIST_LOCK.

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

00932 {
00933    return AST_LIST_LOCK(&groups);
00934 }

int ast_app_group_list_unlock ( void   ) 

Unlock the group count list

Definition at line 941 of file app.c.

References AST_LIST_UNLOCK.

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

00942 {
00943    return AST_LIST_UNLOCK(&groups);
00944 }

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

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

Referenced by group_match_count_function_read().

00876 {
00877    struct ast_group_info *gi = NULL;
00878    regex_t regexbuf;
00879    int count = 0;
00880 
00881    if (ast_strlen_zero(groupmatch))
00882       return 0;
00883 
00884    /* if regex compilation fails, return zero matches */
00885    if (regcomp(&regexbuf, groupmatch, REG_EXTENDED | REG_NOSUB))
00886       return 0;
00887 
00888    AST_LIST_LOCK(&groups);
00889    AST_LIST_TRAVERSE(&groups, gi, list) {
00890       if (!regexec(&regexbuf, gi->group, 0, NULL, 0) && (ast_strlen_zero(category) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category))))
00891          count++;
00892    }
00893    AST_LIST_UNLOCK(&groups);
00894 
00895    regfree(&regexbuf);
00896 
00897    return count;
00898 }

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

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

Referenced by group_function_write().

00813 {
00814    int res = 0;
00815    char group[80] = "", category[80] = "";
00816    struct ast_group_info *gi = NULL;
00817    size_t len = 0;
00818    
00819    if (ast_app_group_split_group(data, group, sizeof(group), category, sizeof(category)))
00820       return -1;
00821    
00822    /* Calculate memory we will need if this is new */
00823    len = sizeof(*gi) + strlen(group) + 1;
00824    if (!ast_strlen_zero(category))
00825       len += strlen(category) + 1;
00826    
00827    AST_LIST_LOCK(&groups);
00828    AST_LIST_TRAVERSE_SAFE_BEGIN(&groups, gi, list) {
00829       if ((gi->chan == chan) && ((ast_strlen_zero(category) && ast_strlen_zero(gi->category)) || (!ast_strlen_zero(gi->category) && !strcasecmp(gi->category, category)))) {
00830          AST_LIST_REMOVE_CURRENT(&groups, list);
00831          free(gi);
00832          break;
00833       }
00834    }
00835    AST_LIST_TRAVERSE_SAFE_END
00836 
00837    if (ast_strlen_zero(group)) {
00838       /* Enable unsetting the group */
00839    } else if ((gi = calloc(1, len))) {
00840       gi->chan = chan;
00841       gi->group = (char *) gi + sizeof(*gi);
00842       strcpy(gi->group, group);
00843       if (!ast_strlen_zero(category)) {
00844          gi->category = (char *) gi + sizeof(*gi) + strlen(group) + 1;
00845          strcpy(gi->category, category);
00846       }
00847       AST_LIST_INSERT_TAIL(&groups, gi, list);
00848    } else {
00849       res = -1;
00850    }
00851    
00852    AST_LIST_UNLOCK(&groups);
00853    
00854    return res;
00855 }

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

References ast_strlen_zero().

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

00786 {
00787    int res=0;
00788    char tmp[256];
00789    char *grp=NULL, *cat=NULL;
00790 
00791    if (!ast_strlen_zero(data)) {
00792       ast_copy_string(tmp, data, sizeof(tmp));
00793       grp = tmp;
00794       cat = strchr(tmp, '@');
00795       if (cat) {
00796          *cat = '\0';
00797          cat++;
00798       }
00799    }
00800 
00801    if (!ast_strlen_zero(grp))
00802       ast_copy_string(group, grp, group_max);
00803    else
00804       *group = '\0';
00805 
00806    if (!ast_strlen_zero(cat))
00807       ast_copy_string(category, cat, category_max);
00808 
00809    return res;
00810 }

int ast_app_group_update ( struct ast_channel oldchan,
struct ast_channel newchan 
)

Update all group counting for a channel to a new one

Definition at line 900 of file app.c.

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

Referenced by ast_do_masquerade().

00901 {
00902    struct ast_group_info *gi = NULL;
00903 
00904    AST_LIST_LOCK(&groups);
00905    AST_LIST_TRAVERSE(&groups, gi, list) {
00906       if (gi->chan == old)
00907          gi->chan = new;
00908    }
00909    AST_LIST_UNLOCK(&groups);
00910 
00911    return 0;
00912 }

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

Determine if a given mailbox has any voicemail

Definition at line 168 of file app.c.

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

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

00169 {
00170    static int warned = 0;
00171    if (ast_has_voicemail_func)
00172       return ast_has_voicemail_func(mailbox, folder);
00173 
00174    if ((option_verbose > 2) && !warned) {
00175       ast_verbose(VERBOSE_PREFIX_3 "Message check requested for mailbox %s/folder %s but voicemail not loaded.\n", mailbox, folder ? folder : "INBOX");
00176       warned++;
00177    }
00178    return 0;
00179 }

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

Determine number of new/old messages in a mailbox

Definition at line 182 of file app.c.

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

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

00183 {
00184    static int warned = 0;
00185    if (newmsgs)
00186       *newmsgs = 0;
00187    if (oldmsgs)
00188       *oldmsgs = 0;
00189    if (ast_inboxcount_func)
00190       return ast_inboxcount_func(mailbox, newmsgs, oldmsgs);
00191 
00192    if (!warned && (option_verbose > 2)) {
00193       warned++;
00194       ast_verbose(VERBOSE_PREFIX_3 "Message count requested for mailbox %s but voicemail not loaded.\n", mailbox);
00195    }
00196 
00197    return 0;
00198 }

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

Determine number of messages in a given mailbox and folder

Definition at line 200 of file app.c.

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

Referenced by acf_vmcount_exec(), and hasvoicemail_exec().

00201 {
00202    static int warned = 0;
00203    if (ast_messagecount_func)
00204       return ast_messagecount_func(context, mailbox, folder);
00205 
00206    if (!warned && (option_verbose > 2)) {
00207       warned++;
00208       ast_verbose(VERBOSE_PREFIX_3 "Message count requested for mailbox %s@%s/%s but voicemail not loaded.\n", mailbox, context, folder);
00209    }
00210 
00211    return 0;
00212 }

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

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

Referenced by app_exec(), auth_exec(), cdr_read(), cdr_write(), chanspy_exec(), chanspychan_exec(), conf_exec(), extenspy_exec(), mixmonitor_exec(), page_exec(), pbx_builtin_background(), pbx_builtin_resetcdr(), pbx_builtin_waitexten(), read_exec(), vm_exec(), and vm_execmain().

01382 {
01383    char *s;
01384    int curarg;
01385    unsigned int argloc;
01386    char *arg;
01387    int res = 0;
01388 
01389    ast_clear_flag(flags, AST_FLAGS_ALL);
01390 
01391    if (!optstr)
01392       return 0;
01393 
01394    s = optstr;
01395    while (*s) {
01396       curarg = *s++ & 0x7f;   /* the array (in app.h) has 128 entries */
01397       argloc = options[curarg].arg_index;
01398       if (*s == '(') {
01399          /* Has argument */
01400          arg = ++s;
01401          if ((s = strchr(s, ')'))) {
01402             if (argloc)
01403                args[argloc - 1] = arg;
01404             *s++ = '\0';
01405          } else {
01406             ast_log(LOG_WARNING, "Missing closing parenthesis for argument '%c' in string '%s'\n", curarg, arg);
01407             res = -1;
01408             break;
01409          }
01410       } else if (argloc) {
01411          args[argloc - 1] = "";
01412       }
01413       ast_set_flag(flags, options[curarg].flag);
01414    }
01415 
01416    return res;
01417 }

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

Separate a string into arguments in an array.

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

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

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

Definition at line 946 of file app.c.

References quote().

Referenced by app_exec(), chanspy_exec(), chanspychan_exec(), common_exec(), controlplayback_exec(), extenspy_exec(), pbx_builtin_setvar(), speech_background(), and speech_load().

00947 {
00948    int argc;
00949    char *scan;
00950    int paren = 0, quote = 0;
00951 
00952    if (!buf || !array || !arraylen)
00953       return 0;
00954 
00955    memset(array, 0, arraylen * sizeof(*array));
00956 
00957    scan = buf;
00958 
00959    for (argc = 0; *scan && (argc < arraylen - 1); argc++) {
00960       array[argc] = scan;
00961       for (; *scan; scan++) {
00962          if (*scan == '(')
00963             paren++;
00964          else if (*scan == ')') {
00965             if (paren)
00966                paren--;
00967          } else if (*scan == '"' && delim != '"') {
00968             quote = quote ? 0 : 1;
00969             /* Remove quote character from argument */
00970             memmove(scan, scan + 1, strlen(scan));
00971             scan--;
00972          } else if (*scan == '\\') {
00973             /* Literal character, don't parse */
00974             memmove(scan, scan + 1, strlen(scan));
00975          } else if ((*scan == delim) && !paren && !quote) {
00976             *scan++ = '\0';
00977             break;
00978          }
00979       }
00980    }
00981 
00982    if (*scan)
00983       array[argc++] = scan;
00984 
00985    return argc;
00986 }

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

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

Definition at line 362 of file app.c.

References ast_channel::_state, ast_answer(), ast_log(), ast_seekstream(), AST_STATE_UP, ast_stopstream(), ast_streamfile(), ast_tellstream(), ast_waitfordigit(), ast_waitstream_fr(), LOG_DEBUG, option_debug, and ast_channel::stream.

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

00366 {
00367    char *breaks = NULL;
00368    char *end = NULL;
00369    int blen = 2;
00370    int res;
00371    long pause_restart_point = 0;
00372 
00373    if (stop)
00374       blen += strlen(stop);
00375    if (pause)
00376       blen += strlen(pause);
00377    if (restart)
00378       blen += strlen(restart);
00379 
00380    if (blen > 2) {
00381       breaks = alloca(blen + 1);
00382       breaks[0] = '\0';
00383       if (stop)
00384          strcat(breaks, stop);
00385       if (pause)
00386          strcat(breaks, pause);
00387       if (restart)
00388          strcat(breaks, restart);
00389    }
00390    if (chan->_state != AST_STATE_UP)
00391       res = ast_answer(chan);
00392 
00393    if (file) {
00394       if ((end = strchr(file,':'))) {
00395          if (!strcasecmp(end, ":end")) {
00396             *end = '\0';
00397             end++;
00398          }
00399       }
00400    }
00401 
00402    for (;;) {
00403       ast_stopstream(chan);
00404       res = ast_streamfile(chan, file, chan->language);
00405       if (!res) {
00406          if (pause_restart_point) {
00407             ast_seekstream(chan->stream, pause_restart_point, SEEK_SET);
00408             pause_restart_point = 0;
00409          }
00410          else if (end) {
00411             ast_seekstream(chan->stream, 0, SEEK_END);
00412             end = NULL;
00413          };
00414          res = ast_waitstream_fr(chan, breaks, fwd, rev, skipms);
00415       }
00416 
00417       if (res < 1)
00418          break;
00419 
00420       /* We go at next loop if we got the restart char */
00421       if (restart && strchr(restart, res)) {
00422          if (option_debug)
00423             ast_log(LOG_DEBUG, "we'll restart the stream here at next loop\n");
00424          pause_restart_point = 0;
00425          continue;
00426       }
00427 
00428       if (pause && strchr(pause, res)) {
00429          pause_restart_point = ast_tellstream(chan->stream);
00430          for (;;) {
00431             ast_stopstream(chan);
00432             res = ast_waitfordigit(chan, 1000);
00433             if (!res)
00434                continue;
00435             else if (res == -1 || strchr(pause, res) || (stop && strchr(stop, res)))
00436                break;
00437          }
00438          if (res == *pause) {
00439             res = 0;
00440             continue;
00441          }
00442       }
00443 
00444       if (res == -1)
00445          break;
00446 
00447       /* if we get one of our stop chars, return it to the calling function */
00448       if (stop && strchr(stop, res))
00449          break;
00450    }
00451 
00452    /* If we are returning a digit cast it as char */
00453    if (res > 0 || chan->stream)
00454       res = (char)res;
00455 
00456    ast_stopstream(chan);
00457 
00458    return res;
00459 }

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

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.

Definition at line 214 of file app.c.

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

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

00215 {
00216    const char *ptr;
00217    int res = 0;
00218 
00219    if (!between)
00220       between = 100;
00221 
00222    if (peer)
00223       res = ast_autoservice_start(peer);
00224 
00225    if (!res)
00226       res = ast_waitfor(chan, 100);
00227 
00228    /* ast_waitfor will return the number of remaining ms on success */
00229    if (res < 0)
00230       return res;
00231 
00232    for (ptr = digits; *ptr; ptr++) {
00233       if (*ptr == 'w') {
00234          /* 'w' -- wait half a second */
00235          if ((res = ast_safe_sleep(chan, 500)))
00236             break;
00237       } else if (strchr("0123456789*#abcdfABCDF", *ptr)) {
00238          /* Character represents valid DTMF */
00239          if (*ptr == 'f' || *ptr == 'F') {
00240             /* ignore return values if not supported by channel */
00241             ast_indicate(chan, AST_CONTROL_FLASH);
00242          } else
00243             ast_senddigit(chan, *ptr);
00244          /* pause between digits */
00245          if ((res = ast_safe_sleep(chan, between)))
00246             break;
00247       } else
00248          ast_log(LOG_WARNING, "Illegal DTMF character '%c' in string. (0-9*#aAbBcCdD allowed)\n",*ptr);
00249    }
00250 
00251    if (peer) {
00252       /* Stop autoservice on the peer channel, but don't overwrite any error condition 
00253          that has occurred previously while acting on the primary channel */
00254       if (ast_autoservice_stop(peer) && !res)
00255          res = -1;
00256    }
00257 
00258    return res;
00259 }

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

Definition at line 152 of file app.c.

References ast_has_voicemail_func, ast_inboxcount_func, and ast_messagecount_func.

Referenced by load_module().

00155 {
00156    ast_has_voicemail_func = has_voicemail_func;
00157    ast_inboxcount_func = inboxcount_func;
00158    ast_messagecount_func = messagecount_func;
00159 }

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

References ast_ivr_menu_run_internal().

Referenced by skel_exec().

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

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

Definition at line 1256 of file app.c.

References AST_DIGIT_ANY, ast_log(), AST_MAX_EXTENSION, exten, ivr_dispatch(), LOG_DEBUG, LOG_WARNING, maxretries, ast_ivr_option::option, option_debug, 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().

01257 {
01258    /* Execute an IVR menu structure */
01259    int res=0;
01260    int pos = 0;
01261    int retries = 0;
01262    char exten[AST_MAX_EXTENSION] = "s";
01263    if (option_exists(menu, "s") < 0) {
01264       strcpy(exten, "g");
01265       if (option_exists(menu, "g") < 0) {
01266          ast_log(LOG_WARNING, "No 's' nor 'g' extension in menu '%s'!\n", menu->title);
01267          return -1;
01268       }
01269    }
01270    while(!res) {
01271       while(menu->options[pos].option) {
01272          if (!strcasecmp(menu->options[pos].option, exten)) {
01273             res = ivr_dispatch(chan, menu->options + pos, exten, cbdata);
01274             if (option_debug)
01275                ast_log(LOG_DEBUG, "IVR Dispatch of '%s' (pos %d) yields %d\n", exten, pos, res);
01276             if (res < 0)
01277                break;
01278             else if (res & RES_UPONE)
01279                return 0;
01280             else if (res & RES_EXIT)
01281                return res;
01282             else if (res & RES_REPEAT) {
01283                int maxretries = res & 0xffff;
01284                if ((res & RES_RESTART) == RES_RESTART) {
01285                   retries = 0;
01286                } else
01287                   retries++;
01288                if (!maxretries)
01289                   maxretries = 3;
01290                if ((maxretries > 0) && (retries >= maxretries)) {
01291                   if (option_debug)
01292                      ast_log(LOG_DEBUG, "Max retries %d exceeded\n", maxretries);
01293                   return -2;
01294                } else {
01295                   if (option_exists(menu, "g") > -1) 
01296                      strcpy(exten, "g");
01297                   else if (option_exists(menu, "s") > -1)
01298                      strcpy(exten, "s");
01299                }
01300                pos = 0;
01301                continue;
01302             } else if (res && strchr(AST_DIGIT_ANY, res)) {
01303                if (option_debug)
01304                   ast_log(LOG_DEBUG, "Got start of extension, %c\n", res);
01305                exten[1] = '\0';
01306                exten[0] = res;
01307                if ((res = read_newoption(chan, menu, exten, sizeof(exten))))
01308                   break;
01309                if (option_exists(menu, exten) < 0) {
01310                   if (option_exists(menu, "i")) {
01311                      if (option_debug)
01312                         ast_log(LOG_DEBUG, "Invalid extension entered, going to 'i'!\n");
01313                      strcpy(exten, "i");
01314                      pos = 0;
01315                      continue;
01316                   } else {
01317                      if (option_debug)
01318                         ast_log(LOG_DEBUG, "Aborting on invalid entry, with no 'i' option!\n");
01319                      res = -2;
01320                      break;
01321                   }
01322                } else {
01323                   if (option_debug)
01324                      ast_log(LOG_DEBUG, "New existing extension: %s\n", exten);
01325                   pos = 0;
01326                   continue;
01327                }
01328             }
01329          }
01330          pos++;
01331       }
01332       if (option_debug)
01333          ast_log(LOG_DEBUG, "Stopping option '%s', res is %d\n", exten, res);
01334       pos = 0;
01335       if (!strcasecmp(exten, "s"))
01336          strcpy(exten, "g");
01337       else
01338          break;
01339    }
01340    return res;
01341 }

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

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

00334 {
00335    struct linear_state *lin;
00336    char tmpf[256];
00337    int res = -1;
00338    int autoclose = 0;
00339    if (fd < 0) {
00340       if (ast_strlen_zero(filename))
00341          return -1;
00342       autoclose = 1;
00343       if (filename[0] == '/') 
00344          ast_copy_string(tmpf, filename, sizeof(tmpf));
00345       else
00346          snprintf(tmpf, sizeof(tmpf), "%s/%s/%s", (char *)ast_config_AST_DATA_DIR, "sounds", filename);
00347       fd = open(tmpf, O_RDONLY);
00348       if (fd < 0){
00349          ast_log(LOG_WARNING, "Unable to open file '%s': %s\n", tmpf, strerror(errno));
00350          return -1;
00351       }
00352    }
00353    if ((lin = ast_calloc(1, sizeof(*lin)))) {
00354       lin->fd = fd;
00355       lin->allowoverride = allowoverride;
00356       lin->autoclose = autoclose;
00357       res = ast_activate_generator(chan, &linearstream, lin);
00358    }
00359    return res;
00360 }

static AST_LIST_HEAD_STATIC ( groups  ,
ast_group_info   
) [static]

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

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

Referenced by vm_lock_path().

00989 {
00990    char *s;
00991    char *fs;
00992    int res;
00993    int fd;
00994    int lp = strlen(path);
00995    time_t start;
00996 
00997    if (!(s = alloca(lp + 10)) || !(fs = alloca(lp + 20))) {
00998       ast_log(LOG_WARNING, "Out of memory!\n");
00999       return AST_LOCK_FAILURE;
01000    }
01001 
01002    snprintf(fs, strlen(path) + 19, "%s/.lock-%08lx", path, ast_random());
01003    fd = open(fs, O_WRONLY | O_CREAT | O_EXCL, 0600);
01004    if (fd < 0) {
01005       ast_log(LOG_ERROR, "Unable to create lock file '%s': %s\n", path, strerror(errno));
01006       return AST_LOCK_PATH_NOT_FOUND;
01007    }
01008    close(fd);
01009 
01010    snprintf(s, strlen(path) + 9, "%s/.lock", path);
01011    start = time(NULL);
01012    while (((res = link(fs, s)) < 0) && (errno == EEXIST) && (time(NULL) - start < 5))
01013       usleep(1);
01014 
01015    unlink(fs);
01016 
01017    if (res) {
01018       ast_log(LOG_WARNING, "Failed to lock path '%s': %s\n", path, strerror(errno));
01019       return AST_LOCK_TIMEOUT;
01020    } else {
01021       if (option_debug)
01022          ast_log(LOG_DEBUG, "Locked path '%s'\n", path);
01023       return AST_LOCK_SUCCESS;
01024    }
01025 }

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

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

Definition at line 778 of file app.c.

References __ast_play_and_record().

Referenced by vm_forwardoptions().

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

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

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

Definition at line 773 of file app.c.

References __ast_play_and_record().

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

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

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

References __ast_play_and_record(), and S_OR.

Referenced by play_record_review().

00769 {
00770    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));
00771 }

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

char* ast_read_textfile ( const char *  file  ) 

Read a file into asterisk

Definition at line 1350 of file app.c.

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

Referenced by readfile_exec().

01351 {
01352    int fd;
01353    char *output = NULL;
01354    struct stat filesize;
01355    int count = 0;
01356    int res;
01357    if (stat(filename, &filesize) == -1) {
01358       ast_log(LOG_WARNING, "Error can't stat %s\n", filename);
01359       return NULL;
01360    }
01361    count = filesize.st_size + 1;
01362    fd = open(filename, O_RDONLY);
01363    if (fd < 0) {
01364       ast_log(LOG_WARNING, "Cannot open file '%s' for reading: %s\n", filename, strerror(errno));
01365       return NULL;
01366    }
01367    if ((output = ast_malloc(count))) {
01368       res = read(fd, output, count - 1);
01369       if (res == count - 1) {
01370          output[res] = '\0';
01371       } else {
01372          ast_log(LOG_WARNING, "Short read of %s (%d of %d): %s\n", filename, res, count - 1, strerror(errno));
01373          free(output);
01374          output = NULL;
01375       }
01376    }
01377    close(fd);
01378    return output;
01379 }

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

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

Referenced by conf_run().

01050 {
01051    int silencethreshold = 128; 
01052    int maxsilence=0;
01053    int res = 0;
01054    int cmd = 0;
01055    int max_attempts = 3;
01056    int attempts = 0;
01057    int recorded = 0;
01058    int message_exists = 0;
01059    /* Note that urgent and private are for flagging messages as such in the future */
01060 
01061    /* barf if no pointer passed to store duration in */
01062    if (duration == NULL) {
01063       ast_log(LOG_WARNING, "Error ast_record_review called without duration pointer\n");
01064       return -1;
01065    }
01066 
01067    cmd = '3';   /* Want to start by recording */
01068 
01069    while ((cmd >= 0) && (cmd != 't')) {
01070       switch (cmd) {
01071       case '1':
01072          if (!message_exists) {
01073             /* In this case, 1 is to record a message */
01074             cmd = '3';
01075             break;
01076          } else {
01077             ast_stream_and_wait(chan, "vm-msgsaved", chan->language, "");
01078             cmd = 't';
01079             return res;
01080          }
01081       case '2':
01082          /* Review */
01083          ast_verbose(VERBOSE_PREFIX_3 "Reviewing the recording\n");
01084          cmd = ast_stream_and_wait(chan, recordfile, chan->language, AST_DIGIT_ANY);
01085          break;
01086       case '3':
01087          message_exists = 0;
01088          /* Record */
01089          if (recorded == 1)
01090             ast_verbose(VERBOSE_PREFIX_3 "Re-recording\n");
01091          else  
01092             ast_verbose(VERBOSE_PREFIX_3 "Recording\n");
01093          recorded = 1;
01094          cmd = ast_play_and_record(chan, playfile, recordfile, maxtime, fmt, duration, silencethreshold, maxsilence, path);
01095          if (cmd == -1) {
01096          /* User has hung up, no options to give */
01097             return cmd;
01098          }
01099          if (cmd == '0') {
01100             break;
01101          } else if (cmd == '*') {
01102             break;
01103          } 
01104          else {
01105             /* If all is well, a message exists */
01106             message_exists = 1;
01107             cmd = 0;
01108          }
01109          break;
01110       case '4':
01111       case '5':
01112       case '6':
01113       case '7':
01114       case '8':
01115       case '9':
01116       case '*':
01117       case '#':
01118          cmd = ast_play_and_wait(chan, "vm-sorry");
01119          break;
01120       default:
01121          if (message_exists) {
01122             cmd = ast_play_and_wait(chan, "vm-review");
01123          }
01124          else {
01125             cmd = ast_play_and_wait(chan, "vm-torerecord");
01126             if (!cmd)
01127                cmd = ast_waitfordigit(chan, 600);
01128          }
01129          
01130          if (!cmd)
01131             cmd = ast_waitfordigit(chan, 6000);
01132          if (!cmd) {
01133             attempts++;
01134          }
01135          if (attempts > max_attempts) {
01136             cmd = 't';
01137          }
01138       }
01139    }
01140    if (cmd == 't')
01141       cmd = 0;
01142    return cmd;
01143 }

void ast_uninstall_vm_functions ( void   ) 

Definition at line 161 of file app.c.

References ast_has_voicemail_func, ast_inboxcount_func, and ast_messagecount_func.

Referenced by unload_module().

00162 {
00163    ast_has_voicemail_func = NULL;
00164    ast_inboxcount_func = NULL;
00165    ast_messagecount_func = NULL;
00166 }

int ast_unlock_path ( const char *  path  ) 

Unlock a path

Definition at line 1027 of file app.c.

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

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

01028 {
01029    char *s;
01030    int res;
01031 
01032    if (!(s = alloca(strlen(path) + 10))) {
01033       ast_log(LOG_WARNING, "Out of memory!\n");
01034       return -1;
01035    }
01036 
01037    snprintf(s, strlen(path) + 9, "%s/%s", path, ".lock");
01038 
01039    if ((res = unlink(s)))
01040       ast_log(LOG_ERROR, "Could not unlock path '%s': %s\n", path, strerror(errno));
01041    else {
01042       if (option_debug)
01043          ast_log(LOG_DEBUG, "Unlocked path '%s'\n", path);
01044    }
01045 
01046    return res;
01047 }

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

Definition at line 1152 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01153 {
01154    int res;
01155    int (*ivr_func)(struct ast_channel *, void *);
01156    char *c;
01157    char *n;
01158    
01159    switch(option->action) {
01160    case AST_ACTION_UPONE:
01161       return RES_UPONE;
01162    case AST_ACTION_EXIT:
01163       return RES_EXIT | (((unsigned long)(option->adata)) & 0xffff);
01164    case AST_ACTION_REPEAT:
01165       return RES_REPEAT | (((unsigned long)(option->adata)) & 0xffff);
01166    case AST_ACTION_RESTART:
01167       return RES_RESTART ;
01168    case AST_ACTION_NOOP:
01169       return 0;
01170    case AST_ACTION_BACKGROUND:
01171       res = ast_stream_and_wait(chan, (char *)option->adata, chan->language, AST_DIGIT_ANY);
01172       if (res < 0) {
01173          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01174          res = 0;
01175       }
01176       return res;
01177    case AST_ACTION_PLAYBACK:
01178       res = ast_stream_and_wait(chan, (char *)option->adata, chan->language, "");
01179       if (res < 0) {
01180          ast_log(LOG_NOTICE, "Unable to find file '%s'!\n", (char *)option->adata);
01181          res = 0;
01182       }
01183       return res;
01184    case AST_ACTION_MENU:
01185       res = ast_ivr_menu_run_internal(chan, (struct ast_ivr_menu *)option->adata, cbdata);
01186       /* Do not pass entry errors back up, treaat ast though ti was an "UPONE" */
01187       if (res == -2)
01188          res = 0;
01189       return res;
01190    case AST_ACTION_WAITOPTION:
01191       res = ast_waitfordigit(chan, 1000 * (chan->pbx ? chan->pbx->rtimeout : 10));
01192       if (!res)
01193          return 't';
01194       return res;
01195    case AST_ACTION_CALLBACK:
01196       ivr_func = option->adata;
01197       res = ivr_func(chan, cbdata);
01198       return res;
01199    case AST_ACTION_TRANSFER:
01200       res = ast_parseable_goto(chan, option->adata);
01201       return 0;
01202    case AST_ACTION_PLAYLIST:
01203    case AST_ACTION_BACKLIST:
01204       res = 0;
01205       c = ast_strdupa(option->adata);
01206       while ((n = strsep(&c, ";"))) {
01207          if ((res = ast_stream_and_wait(chan, n, chan->language,
01208                (option->action == AST_ACTION_BACKLIST) ? AST_DIGIT_ANY : "")))
01209             break;
01210       }
01211       ast_stopstream(chan);
01212       return res;
01213    default:
01214       ast_log(LOG_NOTICE, "Unknown dispatch function %d, ignoring!\n", option->action);
01215       return 0;
01216    };
01217    return -1;
01218 }

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

Definition at line 306 of file app.c.

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

00307 {
00308    struct linear_state *ls;
00309    /* In this case, params is already malloc'd */
00310    if (params) {
00311       ls = params;
00312       if (ls->allowoverride)
00313          ast_set_flag(chan, AST_FLAG_WRITE_INT);
00314       else
00315          ast_clear_flag(chan, AST_FLAG_WRITE_INT);
00316       ls->origwfmt = chan->writeformat;
00317       if (ast_set_write_format(chan, AST_FORMAT_SLINEAR)) {
00318          ast_log(LOG_WARNING, "Unable to set '%s' to linear format (write)\n", chan->name);
00319          free(ls);
00320          ls = params = NULL;
00321       }
00322    }
00323    return params;
00324 }

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

Definition at line 279 of file app.c.

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

00280 {
00281    struct ast_frame f;
00282    short buf[2048 + AST_FRIENDLY_OFFSET / 2];
00283    struct linear_state *ls = data;
00284    int res;
00285    len = samples * 2;
00286    if (len > sizeof(buf) - AST_FRIENDLY_OFFSET) {
00287       ast_log(LOG_WARNING, "Can't generate %d bytes of data!\n" ,len);
00288       len = sizeof(buf) - AST_FRIENDLY_OFFSET;
00289    }
00290    memset(&f, 0, sizeof(f));
00291    res = read(ls->fd, buf + AST_FRIENDLY_OFFSET/2, len);
00292    if (res > 0) {
00293       f.frametype = AST_FRAME_VOICE;
00294       f.subclass = AST_FORMAT_SLINEAR;
00295       f.data = buf + AST_FRIENDLY_OFFSET/2;
00296       f.datalen = res;
00297       f.samples = res / 2;
00298       f.offset = AST_FRIENDLY_OFFSET;
00299       ast_write(chan, &f);
00300       if (res == len)
00301          return 0;
00302    }
00303    return -1;
00304 }

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

Definition at line 268 of file app.c.

References ast_log(), ast_set_write_format(), linear_state::autoclose, linear_state::fd, free, LOG_WARNING, and linear_state::origwfmt.

00269 {
00270    struct linear_state *ls = params;
00271    if (ls->origwfmt && ast_set_write_format(chan, ls->origwfmt)) {
00272       ast_log(LOG_WARNING, "Unable to restore channel '%s' to format '%d'\n", chan->name, ls->origwfmt);
00273    }
00274    if (ls->autoclose)
00275       close(ls->fd);
00276    free(params);
00277 }

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

Definition at line 1220 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01221 {
01222    int x;
01223    for (x = 0; menu->options[x].option; x++)
01224       if (!strcasecmp(menu->options[x].option, option))
01225          return x;
01226    return -1;
01227 }

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

Definition at line 1229 of file app.c.

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

Referenced by read_newoption().

01230 {
01231    int x;
01232    for (x = 0; menu->options[x].option; x++)
01233       if ((!strncasecmp(menu->options[x].option, option, strlen(option))) && 
01234             (menu->options[x].option[strlen(option)]))
01235          return x;
01236    return -1;
01237 }

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

Definition at line 1239 of file app.c.

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

Referenced by ast_ivr_menu_run_internal().

01240 {
01241    int res=0;
01242    int ms;
01243    while (option_matchmore(menu, exten)) {
01244       ms = chan->pbx ? chan->pbx->dtimeout : 5000;
01245       if (strlen(exten) >= maxexten - 1) 
01246          break;
01247       res = ast_waitfordigit(chan, ms);
01248       if (res < 1)
01249          break;
01250       exten[strlen(exten) + 1] = '\0';
01251       exten[strlen(exten)] = res;
01252    }
01253    return res > 0 ? 0 : res;
01254 }


Variable Documentation

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

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

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

char default_acceptdtmf[] = "#" [static]

Definition at line 765 of file app.c.

char default_canceldtmf[] = "" [static]

Definition at line 766 of file app.c.

int global_maxsilence = 0 [static]

Definition at line 473 of file app.c.

int global_silence_threshold = 128 [static]

Definition at line 472 of file app.c.

struct ast_generator linearstream [static]

Definition at line 326 of file app.c.


Generated on Sat Apr 12 07:12:28 2008 for Asterisk - the Open Source PBX by  doxygen 1.5.5