/* * Asterisk -- An open source telephony toolkit. * * Copyright (C) 1999 - 2006, Digium, Inc. * * Mark Spencer * * See http://www.asterisk.org for more information about * the Asterisk project. Please do not directly contact * any of the maintainers of this project for assistance; * the project provides a web site, mailing lists and IRC * channels for your use. * * This program is free software, distributed under the terms of * the GNU General Public License Version 2. See the LICENSE file * at the top of the source tree. */ /*! \file * * \brief AGI - the Asterisk Gateway Interface * * \author Mark Spencer * * \todo Convert the rest of the AGI commands over to XML documentation */ #include "asterisk.h" ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include #include #include #include #include #include #include "asterisk/paths.h" /* use many ast_config_AST_*_DIR */ #include "asterisk/network.h" #include "asterisk/file.h" #include "asterisk/channel.h" #include "asterisk/pbx.h" #include "asterisk/module.h" #include "asterisk/astdb.h" #include "asterisk/callerid.h" #include "asterisk/cli.h" #include "asterisk/image.h" #include "asterisk/say.h" #include "asterisk/app.h" #include "asterisk/dsp.h" #include "asterisk/musiconhold.h" #include "asterisk/utils.h" #include "asterisk/lock.h" #include "asterisk/strings.h" #include "asterisk/manager.h" #include "asterisk/ast_version.h" #include "asterisk/speech.h" #include "asterisk/manager.h" #include "asterisk/features.h" #include "asterisk/term.h" #include "asterisk/xmldoc.h" #define AST_API_MODULE #include "asterisk/agi.h" /*** DOCUMENTATION Answer channel Answers channel if not already in answer state. Returns -1 on channel failure, or 0 if successful. hangup Interrupts Async AGI Interrupts expected flow of Async AGI commands and returns control to previous source (typically, the PBX dialplan). hangup Returns status of the connected channel. Returns the status of the specified channelname. If no channel name is given then returns the status of the current channel. Return values: Channel is down and available. Channel is down, but reserved. Channel is off hook. Digits (or equivalent) have been dialed. Line is ringing. Remote end is ringing. Line is up. Line is busy. Removes database key/value Deletes an entry in the Asterisk database for a given family and key. Returns 1 if successful, 0 otherwise. Removes database keytree/value Deletes a family or specific keytree within a family in the Asterisk database. Returns 1 if successful, 0 otherwise. Gets database value Retrieves an entry in the Asterisk database for a given family and key. Returns 0 if key is not set. Returns 1 if key is set and returns the variable in parenthesis. Example return code: 200 result=1 (testvariable) Adds/updates database value Adds or updates an entry in the Asterisk database for a given family, key, and value. Returns 1 if successful, 0 otherwise. Executes a given Application Executes application with given options. Returns whatever the application returns, or -2 on failure to find application. Prompts for DTMF on a channel Stream the given file, and receive DTMF data. Returns the digits received from the channel at the other end. Evaluates a channel expression Returns 0 if variablename is not set or channel does not exist. Returns 1 if variablename is set and returns the variable in parenthesis. Understands complex variable names and builtin variables, unlike GET VARIABLE. Example return code: 200 result=1 (testvariable) Stream file, prompt for DTMF, with timeout. Behaves similar to STREAM FILE but used with a timeout option. stream file Gets a channel variable. Returns 0 if variablename is not set. Returns 1 if variablename is set and returns the variable in parentheses. Example return code: 200 result=1 (testvariable) Hangup the current channel. Hangs up the specified channel. If no channel name is given, hangs up the current channel Does nothing. Does nothing. Enable/Disable Music on hold generator Enables/Disables the music on hold generator. If class is not specified, then the default music on hold class will be used. Always returns 0. ***/ #define MAX_ARGS 128 #define MAX_CMD_LEN 80 #define AGI_NANDFS_RETRY 3 #define AGI_BUF_LEN 2048 static char *app = "AGI"; static char *eapp = "EAGI"; static char *deadapp = "DeadAGI"; static char *synopsis = "Executes an AGI compliant application"; static char *esynopsis = "Executes an EAGI compliant application"; static char *deadsynopsis = "Executes AGI on a hungup channel"; static char *descrip = " [E|Dead]AGI(command,args): Executes an Asterisk Gateway Interface compliant\n" "program on a channel. AGI allows Asterisk to launch external programs written\n" "in any language to control a telephony channel, play audio, read DTMF digits,\n" "etc. by communicating with the AGI protocol on stdin and stdout.\n" " As of 1.6.0, this channel will not stop dialplan execution on hangup inside\n" "of this application. Dialplan execution will continue normally, even upon\n" "hangup until the AGI application signals a desire to stop (either by exiting\n" "or, in the case of a net script, by closing the connection).\n" " A locally executed AGI script will receive SIGHUP on hangup from the channel\n" "except when using DeadAGI. A fast AGI server will correspondingly receive a\n" "HANGUP in OOB data. Both of these signals may be disabled by setting the\n" "AGISIGHUP channel variable to \"no\" before executing the AGI application.\n" " Using 'EAGI' provides enhanced AGI, with incoming audio available out of band\n" "on file descriptor 3.\n\n" " Use the CLI command 'agi show commnands' to list available agi commands.\n" " This application sets the following channel variable upon completion:\n" " AGISTATUS The status of the attempt to the run the AGI script\n" " text string, one of SUCCESS | FAILURE | NOTFOUND | HANGUP\n"; static int agidebug = 0; #define TONE_BLOCK_SIZE 200 /* Max time to connect to an AGI remote host */ #define MAX_AGI_CONNECT 2000 #define AGI_PORT 4573 enum agi_result { AGI_RESULT_FAILURE = -1, AGI_RESULT_SUCCESS, AGI_RESULT_SUCCESS_FAST, AGI_RESULT_SUCCESS_ASYNC, AGI_RESULT_NOTFOUND, AGI_RESULT_HANGUP, }; static agi_command *find_command(char *cmds[], int exact); AST_THREADSTORAGE(agi_buf); #define AGI_BUF_INITSIZE 256 int ast_agi_send(int fd, struct ast_channel *chan, char *fmt, ...) { int res = 0; va_list ap; struct ast_str *buf; if (!(buf = ast_str_thread_get(&agi_buf, AGI_BUF_INITSIZE))) return -1; va_start(ap, fmt); res = ast_str_set_va(&buf, 0, fmt, ap); va_end(ap); if (res == -1) { ast_log(LOG_ERROR, "Out of memory\n"); return -1; } if (agidebug) { if (chan) { ast_verbose("<%s>AGI Tx >> %s", chan->name, ast_str_buffer(buf)); } else { ast_verbose("AGI Tx >> %s", ast_str_buffer(buf)); } } return ast_carefulwrite(fd, ast_str_buffer(buf), ast_str_strlen(buf), 100); } /* linked list of AGI commands ready to be executed by Async AGI */ struct agi_cmd { char *cmd_buffer; char *cmd_id; AST_LIST_ENTRY(agi_cmd) entry; }; static void free_agi_cmd(struct agi_cmd *cmd) { ast_free(cmd->cmd_buffer); ast_free(cmd->cmd_id); ast_free(cmd); } /* AGI datastore destructor */ static void agi_destroy_commands_cb(void *data) { struct agi_cmd *cmd; AST_LIST_HEAD(, agi_cmd) *chan_cmds = data; AST_LIST_LOCK(chan_cmds); while ( (cmd = AST_LIST_REMOVE_HEAD(chan_cmds, entry)) ) { free_agi_cmd(cmd); } AST_LIST_UNLOCK(chan_cmds); AST_LIST_HEAD_DESTROY(chan_cmds); ast_free(chan_cmds); } /* channel datastore to keep the queue of AGI commands in the channel */ static const struct ast_datastore_info agi_commands_datastore_info = { .type = "AsyncAGI", .destroy = agi_destroy_commands_cb }; static const char mandescr_asyncagi[] = "Description: Add an AGI command to the execute queue of the channel in Async AGI\n" "Variables:\n" " *Channel: Channel that is currently in Async AGI\n" " *Command: Application to execute\n" " CommandID: comand id. This will be sent back in CommandID header of AsyncAGI exec event notification\n" "\n"; static struct agi_cmd *get_agi_cmd(struct ast_channel *chan) { struct ast_datastore *store; struct agi_cmd *cmd; AST_LIST_HEAD(, agi_cmd) *agi_commands; ast_channel_lock(chan); store = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL); ast_channel_unlock(chan); if (!store) { ast_log(LOG_ERROR, "Hu? datastore disappeared at Async AGI on Channel %s!\n", chan->name); return NULL; } agi_commands = store->data; AST_LIST_LOCK(agi_commands); cmd = AST_LIST_REMOVE_HEAD(agi_commands, entry); AST_LIST_UNLOCK(agi_commands); return cmd; } /* channel is locked when calling this one either from the CLI or manager thread */ static int add_agi_cmd(struct ast_channel *chan, const char *cmd_buff, const char *cmd_id) { struct ast_datastore *store; struct agi_cmd *cmd; AST_LIST_HEAD(, agi_cmd) *agi_commands; store = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL); if (!store) { ast_log(LOG_WARNING, "Channel %s is not at Async AGI.\n", chan->name); return -1; } agi_commands = store->data; cmd = ast_calloc(1, sizeof(*cmd)); if (!cmd) { return -1; } cmd->cmd_buffer = ast_strdup(cmd_buff); if (!cmd->cmd_buffer) { ast_free(cmd); return -1; } cmd->cmd_id = ast_strdup(cmd_id); if (!cmd->cmd_id) { ast_free(cmd->cmd_buffer); ast_free(cmd); return -1; } AST_LIST_LOCK(agi_commands); AST_LIST_INSERT_TAIL(agi_commands, cmd, entry); AST_LIST_UNLOCK(agi_commands); return 0; } static int add_to_agi(struct ast_channel *chan) { struct ast_datastore *datastore; AST_LIST_HEAD(, agi_cmd) *agi_cmds_list; /* check if already on AGI */ ast_channel_lock(chan); datastore = ast_channel_datastore_find(chan, &agi_commands_datastore_info, NULL); ast_channel_unlock(chan); if (datastore) { /* we already have an AGI datastore, let's just return success */ return 0; } /* the channel has never been on Async AGI, let's allocate it's datastore */ datastore = ast_datastore_alloc(&agi_commands_datastore_info, "AGI"); if (!datastore) { return -1; } agi_cmds_list = ast_calloc(1, sizeof(*agi_cmds_list)); if (!agi_cmds_list) { ast_log(LOG_ERROR, "Unable to allocate Async AGI commands list.\n"); ast_datastore_free(datastore); return -1; } datastore->data = agi_cmds_list; AST_LIST_HEAD_INIT(agi_cmds_list); ast_channel_lock(chan); ast_channel_datastore_add(chan, datastore); ast_channel_unlock(chan); return 0; } /*! * \brief CLI command to add applications to execute in Async AGI * \param e * \param cmd * \param a * * \retval CLI_SUCCESS on success * \retval NULL when init or tab completion is used */ static char *handle_cli_agi_add_cmd(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) { struct ast_channel *chan; switch (cmd) { case CLI_INIT: e->command = "agi exec"; e->usage = "Usage: agi exec [id]\n" " Add AGI command to the execute queue of the specified channel in Async AGI\n"; return NULL; case CLI_GENERATE: if (a->pos == 2) return ast_complete_channels(a->line, a->word, a->pos, a->n, 2); return NULL; } if (a->argc < 4) return CLI_SHOWUSAGE; chan = ast_get_channel_by_name_locked(a->argv[2]); if (!chan) { ast_log(LOG_WARNING, "Channel %s does not exists or cannot lock it\n", a->argv[2]); return CLI_FAILURE; } if (add_agi_cmd(chan, a->argv[3], (a->argc > 4 ? a->argv[4] : ""))) { ast_log(LOG_WARNING, "failed to add AGI command to queue of channel %s\n", chan->name); ast_channel_unlock(chan); return CLI_FAILURE; } ast_log(LOG_DEBUG, "Added AGI command to channel %s queue\n", chan->name); ast_channel_unlock(chan); return CLI_SUCCESS; } /*! * \brief Add a new command to execute by the Async AGI application * \param s * \param m * * It will append the application to the specified channel's queue * if the channel is not inside Async AGI application it will return an error * \retval 0 on success or incorrect use * \retval 1 on failure to add the command ( most likely because the channel * is not in Async AGI loop ) */ static int action_add_agi_cmd(struct mansession *s, const struct message *m) { const char *channel = astman_get_header(m, "Channel"); const char *cmdbuff = astman_get_header(m, "Command"); const char *cmdid = astman_get_header(m, "CommandID"); struct ast_channel *chan; char buf[256]; if (ast_strlen_zero(channel) || ast_strlen_zero(cmdbuff)) { astman_send_error(s, m, "Both, Channel and Command are *required*"); return 0; } chan = ast_get_channel_by_name_locked(channel); if (!chan) { snprintf(buf, sizeof(buf), "Channel %s does not exists or cannot get its lock", channel); astman_send_error(s, m, buf); return 0; } if (add_agi_cmd(chan, cmdbuff, cmdid)) { snprintf(buf, sizeof(buf), "Failed to add AGI command to channel %s queue", chan->name); astman_send_error(s, m, buf); ast_channel_unlock(chan); return 0; } astman_send_ack(s, m, "Added AGI command to queue"); ast_channel_unlock(chan); return 0; } static int agi_handle_command(struct ast_channel *chan, AGI *agi, char *buf, int dead); static void setup_env(struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[]); static enum agi_result launch_asyncagi(struct ast_channel *chan, char *argv[], int *efd) { /* This buffer sizes might cause truncation if the AGI command writes more data than AGI_BUF_SIZE as result. But let's be serious, is there an AGI command that writes a response larger than 1024 bytes?, I don't think so, most of them are just result=blah stuff. However probably if GET VARIABLE is called and the variable has large amount of data, that could be a problem. We could make this buffers dynamic, but let's leave that as a second step. AMI_BUF_SIZE is twice AGI_BUF_SIZE just for the sake of choosing a safe number. Some characters of AGI buf will be url encoded to be sent to manager clients. An URL encoded character will take 3 bytes, but again, to cause truncation more than about 70% of the AGI buffer should be URL encoded for that to happen. Not likely at all. On the other hand. I wonder if read() could eventually return less data than the amount already available in the pipe? If so, how to deal with that? So far, my tests on Linux have not had any problems. */ #define AGI_BUF_SIZE 1024 #define AMI_BUF_SIZE 2048 struct ast_frame *f; struct agi_cmd *cmd; int res, fds[2]; int timeout = 100; char agi_buffer[AGI_BUF_SIZE + 1]; char ami_buffer[AMI_BUF_SIZE]; enum agi_result returnstatus = AGI_RESULT_SUCCESS_ASYNC; AGI async_agi; if (efd) { ast_log(LOG_WARNING, "Async AGI does not support Enhanced AGI yet\n"); return AGI_RESULT_FAILURE; } /* add AsyncAGI datastore to the channel */ if (add_to_agi(chan)) { ast_log(LOG_ERROR, "failed to start Async AGI on channel %s\n", chan->name); return AGI_RESULT_FAILURE; } /* this pipe allows us to create a "fake" AGI struct to use the AGI commands */ res = pipe(fds); if (res) { ast_log(LOG_ERROR, "failed to create Async AGI pipe\n"); /* intentionally do not remove datastore, added with add_to_agi(), from channel. It will be removed when the channel is hung up anyways */ return AGI_RESULT_FAILURE; } /* handlers will get the pipe write fd and we read the AGI responses from the pipe read fd */ async_agi.fd = fds[1]; async_agi.ctrl = fds[1]; async_agi.audio = -1; /* no audio support */ async_agi.fast = 0; /* notify possible manager users of a new channel ready to receive commands */ setup_env(chan, "async", fds[1], 0, 0, NULL); /* read the environment */ res = read(fds[0], agi_buffer, AGI_BUF_SIZE); if (!res) { ast_log(LOG_ERROR, "failed to read from Async AGI pipe on channel %s\n", chan->name); returnstatus = AGI_RESULT_FAILURE; goto quit; } agi_buffer[res] = '\0'; /* encode it and send it thru the manager so whoever is going to take care of AGI commands on this channel can decide which AGI commands to execute based on the setup info */ ast_uri_encode(agi_buffer, ami_buffer, AMI_BUF_SIZE, 1); manager_event(EVENT_FLAG_AGI, "AsyncAGI", "SubEvent: Start\r\nChannel: %s\r\nEnv: %s\r\n", chan->name, ami_buffer); while (1) { /* bail out if we need to hangup */ if (ast_check_hangup(chan)) { ast_log(LOG_DEBUG, "ast_check_hangup returned true on chan %s\n", chan->name); break; } /* retrieve a command (commands are added via the manager or the cli threads) */ cmd = get_agi_cmd(chan); if (cmd) { /* OK, we have a command, let's call the command handler. */ res = agi_handle_command(chan, &async_agi, cmd->cmd_buffer, 0); if (res < 0) { free_agi_cmd(cmd); break; } /* the command handler must have written to our fake AGI struct fd (the pipe), let's read the response */ res = read(fds[0], agi_buffer, AGI_BUF_SIZE); if (!res) { returnstatus = AGI_RESULT_FAILURE; ast_log(LOG_ERROR, "failed to read from AsyncAGI pipe on channel %s\n", chan->name); free_agi_cmd(cmd); break; } /* we have a response, let's send the response thru the manager. Include the CommandID if it was specified when the command was added */ agi_buffer[res] = '\0'; ast_uri_encode(agi_buffer, ami_buffer, AMI_BUF_SIZE, 1); if (ast_strlen_zero(cmd->cmd_id)) manager_event(EVENT_FLAG_AGI, "AsyncAGI", "SubEvent: Exec\r\nChannel: %s\r\nResult: %s\r\n", chan->name, ami_buffer); else manager_event(EVENT_FLAG_AGI, "AsyncAGI", "SubEvent: Exec\r\nChannel: %s\r\nCommandID: %s\r\nResult: %s\r\n", chan->name, cmd->cmd_id, ami_buffer); free_agi_cmd(cmd); } else { /* no command so far, wait a bit for a frame to read */ res = ast_waitfor(chan, timeout); if (res < 0) { ast_log(LOG_DEBUG, "ast_waitfor returned <= 0 on chan %s\n", chan->name); break; } if (res == 0) continue; f = ast_read(chan); if (!f) { ast_log(LOG_DEBUG, "No frame read on channel %s, going out ...\n", chan->name); returnstatus = AGI_RESULT_HANGUP; break; } /* is there any other frame we should care about besides AST_CONTROL_HANGUP? */ if (f->frametype == AST_FRAME_CONTROL && f->subclass == AST_CONTROL_HANGUP) { ast_log(LOG_DEBUG, "Got HANGUP frame on channel %s, going out ...\n", chan->name); ast_frfree(f); break; } ast_frfree(f); } } if (async_agi.speech) { ast_speech_destroy(async_agi.speech); } quit: /* notify manager users this channel cannot be controlled anymore by Async AGI */ manager_event(EVENT_FLAG_AGI, "AsyncAGI", "SubEvent: End\r\nChannel: %s\r\n", chan->name); /* close the pipe */ close(fds[0]); close(fds[1]); /* intentionally don't get rid of the datastore. So commands can be still in the queue in case AsyncAGI gets called again. Datastore destructor will be called on channel destroy anyway */ return returnstatus; #undef AGI_BUF_SIZE #undef AMI_BUF_SIZE } /* launch_netscript: The fastagi handler. FastAGI defaults to port 4573 */ static enum agi_result launch_netscript(char *agiurl, char *argv[], int *fds, int *efd, int *opid) { int s, flags, res, port = AGI_PORT; struct pollfd pfds[1]; char *host, *c, *script = ""; struct sockaddr_in addr_in; struct hostent *hp; struct ast_hostent ahp; /* agiusl is "agi://host.domain[:port][/script/name]" */ host = ast_strdupa(agiurl + 6); /* Remove agi:// */ /* Strip off any script name */ if ((c = strchr(host, '/'))) { *c = '\0'; c++; script = c; } if ((c = strchr(host, ':'))) { *c = '\0'; c++; port = atoi(c); } if (efd) { ast_log(LOG_WARNING, "AGI URI's don't support Enhanced AGI yet\n"); return -1; } if (!(hp = ast_gethostbyname(host, &ahp))) { ast_log(LOG_WARNING, "Unable to locate host '%s'\n", host); return -1; } if ((s = socket(AF_INET, SOCK_STREAM, 0)) < 0) { ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno)); return -1; } if ((flags = fcntl(s, F_GETFL)) < 0) { ast_log(LOG_WARNING, "Fcntl(F_GETFL) failed: %s\n", strerror(errno)); close(s); return -1; } if (fcntl(s, F_SETFL, flags | O_NONBLOCK) < 0) { ast_log(LOG_WARNING, "Fnctl(F_SETFL) failed: %s\n", strerror(errno)); close(s); return -1; } memset(&addr_in, 0, sizeof(addr_in)); addr_in.sin_family = AF_INET; addr_in.sin_port = htons(port); memcpy(&addr_in.sin_addr, hp->h_addr, sizeof(addr_in.sin_addr)); if (connect(s, (struct sockaddr *)&addr_in, sizeof(addr_in)) && (errno != EINPROGRESS)) { ast_log(LOG_WARNING, "Connect failed with unexpected error: %s\n", strerror(errno)); close(s); return AGI_RESULT_FAILURE; } pfds[0].fd = s; pfds[0].events = POLLOUT; while ((res = ast_poll(pfds, 1, MAX_AGI_CONNECT)) != 1) { if (errno != EINTR) { if (!res) { ast_log(LOG_WARNING, "FastAGI connection to '%s' timed out after MAX_AGI_CONNECT (%d) milliseconds.\n", agiurl, MAX_AGI_CONNECT); } else ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno)); close(s); return AGI_RESULT_FAILURE; } } if (ast_agi_send(s, NULL, "agi_network: yes\n") < 0) { if (errno != EINTR) { ast_log(LOG_WARNING, "Connect to '%s' failed: %s\n", agiurl, strerror(errno)); close(s); return AGI_RESULT_FAILURE; } } /* If we have a script parameter, relay it to the fastagi server */ /* Script parameters take the form of: AGI(agi://my.example.com/?extension=${EXTEN}) */ if (!ast_strlen_zero(script)) ast_agi_send(s, NULL, "agi_network_script: %s\n", script); ast_debug(4, "Wow, connected!\n"); fds[0] = s; fds[1] = s; *opid = -1; return AGI_RESULT_SUCCESS_FAST; } static enum agi_result launch_script(struct ast_channel *chan, char *script, char *argv[], int *fds, int *efd, int *opid) { char tmp[256]; int pid, toast[2], fromast[2], audio[2], res; struct stat st; if (!strncasecmp(script, "agi://", 6)) return launch_netscript(script, argv, fds, efd, opid); if (!strncasecmp(script, "agi:async", sizeof("agi:async")-1)) return launch_asyncagi(chan, argv, efd); if (script[0] != '/') { snprintf(tmp, sizeof(tmp), "%s/%s", ast_config_AST_AGI_DIR, script); script = tmp; } /* Before even trying let's see if the file actually exists */ if (stat(script, &st)) { ast_log(LOG_WARNING, "Failed to execute '%s': File does not exist.\n", script); return AGI_RESULT_NOTFOUND; } if (pipe(toast)) { ast_log(LOG_WARNING, "Unable to create toast pipe: %s\n",strerror(errno)); return AGI_RESULT_FAILURE; } if (pipe(fromast)) { ast_log(LOG_WARNING, "unable to create fromast pipe: %s\n", strerror(errno)); close(toast[0]); close(toast[1]); return AGI_RESULT_FAILURE; } if (efd) { if (pipe(audio)) { ast_log(LOG_WARNING, "unable to create audio pipe: %s\n", strerror(errno)); close(fromast[0]); close(fromast[1]); close(toast[0]); close(toast[1]); return AGI_RESULT_FAILURE; } res = fcntl(audio[1], F_GETFL); if (res > -1) res = fcntl(audio[1], F_SETFL, res | O_NONBLOCK); if (res < 0) { ast_log(LOG_WARNING, "unable to set audio pipe parameters: %s\n", strerror(errno)); close(fromast[0]); close(fromast[1]); close(toast[0]); close(toast[1]); close(audio[0]); close(audio[1]); return AGI_RESULT_FAILURE; } } if ((pid = ast_safe_fork(1)) < 0) { ast_log(LOG_WARNING, "Failed to fork(): %s\n", strerror(errno)); return AGI_RESULT_FAILURE; } if (!pid) { /* Pass paths to AGI via environmental variables */ setenv("AST_CONFIG_DIR", ast_config_AST_CONFIG_DIR, 1); setenv("AST_CONFIG_FILE", ast_config_AST_CONFIG_FILE, 1); setenv("AST_MODULE_DIR", ast_config_AST_MODULE_DIR, 1); setenv("AST_SPOOL_DIR", ast_config_AST_SPOOL_DIR, 1); setenv("AST_MONITOR_DIR", ast_config_AST_MONITOR_DIR, 1); setenv("AST_VAR_DIR", ast_config_AST_VAR_DIR, 1); setenv("AST_DATA_DIR", ast_config_AST_DATA_DIR, 1); setenv("AST_LOG_DIR", ast_config_AST_LOG_DIR, 1); setenv("AST_AGI_DIR", ast_config_AST_AGI_DIR, 1); setenv("AST_KEY_DIR", ast_config_AST_KEY_DIR, 1); setenv("AST_RUN_DIR", ast_config_AST_RUN_DIR, 1); /* Don't run AGI scripts with realtime priority -- it causes audio stutter */ ast_set_priority(0); /* Redirect stdin and out, provide enhanced audio channel if desired */ dup2(fromast[0], STDIN_FILENO); dup2(toast[1], STDOUT_FILENO); if (efd) dup2(audio[0], STDERR_FILENO + 1); else close(STDERR_FILENO + 1); /* Close everything but stdin/out/error */ ast_close_fds_above_n(STDERR_FILENO + 1); /* Execute script */ /* XXX argv should be deprecated in favor of passing agi_argX paramaters */ execv(script, argv); /* Can't use ast_log since FD's are closed */ ast_child_verbose(1, "Failed to execute '%s': %s", script, strerror(errno)); /* Special case to set status of AGI to failure */ fprintf(stdout, "failure\n"); fflush(stdout); _exit(1); } ast_verb(3, "Launched AGI Script %s\n", script); fds[0] = toast[0]; fds[1] = fromast[1]; if (efd) *efd = audio[1]; /* close what we're not using in the parent */ close(toast[1]); close(fromast[0]); if (efd) close(audio[0]); *opid = pid; return AGI_RESULT_SUCCESS; } static void setup_env(struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[]) { int count; /* Print initial environment, with agi_request always being the first thing */ ast_agi_send(fd, chan, "agi_request: %s\n", request); ast_agi_send(fd, chan, "agi_channel: %s\n", chan->name); ast_agi_send(fd, chan, "agi_language: %s\n", chan->language); ast_agi_send(fd, chan, "agi_type: %s\n", chan->tech->type); ast_agi_send(fd, chan, "agi_uniqueid: %s\n", chan->uniqueid); ast_agi_send(fd, chan, "agi_version: %s\n", ast_get_version()); /* ANI/DNIS */ ast_agi_send(fd, chan, "agi_callerid: %s\n", S_OR(chan->cid.cid_num, "unknown")); ast_agi_send(fd, chan, "agi_calleridname: %s\n", S_OR(chan->cid.cid_name, "unknown")); ast_agi_send(fd, chan, "agi_callingpres: %d\n", chan->cid.cid_pres); ast_agi_send(fd, chan, "agi_callingani2: %d\n", chan->cid.cid_ani2); ast_agi_send(fd, chan, "agi_callington: %d\n", chan->cid.cid_ton); ast_agi_send(fd, chan, "agi_callingtns: %d\n", chan->cid.cid_tns); ast_agi_send(fd, chan, "agi_dnid: %s\n", S_OR(chan->cid.cid_dnid, "unknown")); ast_agi_send(fd, chan, "agi_rdnis: %s\n", S_OR(chan->cid.cid_rdnis, "unknown")); /* Context information */ ast_agi_send(fd, chan, "agi_context: %s\n", chan->context); ast_agi_send(fd, chan, "agi_extension: %s\n", chan->exten); ast_agi_send(fd, chan, "agi_priority: %d\n", chan->priority); ast_agi_send(fd, chan, "agi_enhanced: %s\n", enhanced ? "1.0" : "0.0"); /* User information */ ast_agi_send(fd, chan, "agi_accountcode: %s\n", chan->accountcode ? chan->accountcode : ""); ast_agi_send(fd, chan, "agi_threadid: %ld\n", (long)pthread_self()); /* Send any parameters to the fastagi server that have been passed via the agi application */ /* Agi application paramaters take the form of: AGI(/path/to/example/script|${EXTEN}) */ for(count = 1; count < argc; count++) ast_agi_send(fd, chan, "agi_arg_%d: %s\n", count, argv[count]); /* End with empty return */ ast_agi_send(fd, chan, "\n"); } static int handle_answer(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res = 0; /* Answer the channel */ if (chan->_state != AST_STATE_UP) res = ast_answer(chan); ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_asyncagi_break(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_FAILURE; } static int handle_waitfordigit(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, to; if (argc != 4) return RESULT_SHOWUSAGE; if (sscanf(argv[3], "%30d", &to) != 1) return RESULT_SHOWUSAGE; res = ast_waitfordigit_full(chan, to, agi->audio, agi->ctrl); ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_sendtext(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res; if (argc != 3) return RESULT_SHOWUSAGE; /* At the moment, the parser (perhaps broken) returns with the last argument PLUS the newline at the end of the input buffer. This probably needs to be fixed, but I wont do that because other stuff may break as a result. The right way would probably be to strip off the trailing newline before parsing, then here, add a newline at the end of the string before sending it to ast_sendtext --DUDE */ res = ast_sendtext(chan, argv[2]); ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_recvchar(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res; if (argc != 3) return RESULT_SHOWUSAGE; res = ast_recvchar(chan,atoi(argv[2])); if (res == 0) { ast_agi_send(agi->fd, chan, "200 result=%d (timeout)\n", res); return RESULT_SUCCESS; } if (res > 0) { ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return RESULT_SUCCESS; } ast_agi_send(agi->fd, chan, "200 result=%d (hangup)\n", res); return RESULT_FAILURE; } static int handle_recvtext(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { char *buf; if (argc != 3) return RESULT_SHOWUSAGE; buf = ast_recvtext(chan, atoi(argv[2])); if (buf) { ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", buf); ast_free(buf); } else { ast_agi_send(agi->fd, chan, "200 result=-1\n"); } return RESULT_SUCCESS; } static int handle_tddmode(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, x; if (argc != 3) return RESULT_SHOWUSAGE; if (!strncasecmp(argv[2],"on",2)) { x = 1; } else { x = 0; } if (!strncasecmp(argv[2],"mate",4)) { x = 2; } if (!strncasecmp(argv[2],"tdd",3)) { x = 1; } res = ast_channel_setoption(chan, AST_OPTION_TDD, &x, sizeof(char), 0); if (res != RESULT_SUCCESS) { ast_agi_send(agi->fd, chan, "200 result=0\n"); } else { ast_agi_send(agi->fd, chan, "200 result=1\n"); } return RESULT_SUCCESS; } static int handle_sendimage(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res; if (argc != 3) { return RESULT_SHOWUSAGE; } res = ast_send_image(chan, argv[2]); if (!ast_check_hangup(chan)) { res = 0; } ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_controlstreamfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res = 0, skipms = 3000; char *fwd = "#", *rev = "*", *suspend = NULL, *stop = NULL; /* Default values */ if (argc < 5 || argc > 9) { return RESULT_SHOWUSAGE; } if (!ast_strlen_zero(argv[4])) { stop = argv[4]; } if ((argc > 5) && (sscanf(argv[5], "%30d", &skipms) != 1)) { return RESULT_SHOWUSAGE; } if (argc > 6 && !ast_strlen_zero(argv[6])) { fwd = argv[6]; } if (argc > 7 && !ast_strlen_zero(argv[7])) { rev = argv[7]; } if (argc > 8 && !ast_strlen_zero(argv[8])) { suspend = argv[8]; } res = ast_control_streamfile(chan, argv[3], fwd, rev, stop, suspend, NULL, skipms, NULL); ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_streamfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, vres; struct ast_filestream *fs, *vfs; long sample_offset = 0, max_length; char *edigits = ""; if (argc < 4 || argc > 5) return RESULT_SHOWUSAGE; if (argv[3]) edigits = argv[3]; if ((argc > 4) && (sscanf(argv[4], "%30ld", &sample_offset) != 1)) return RESULT_SHOWUSAGE; if (!(fs = ast_openstream(chan, argv[2], chan->language))) { ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", 0, sample_offset); return RESULT_SUCCESS; } if ((vfs = ast_openvstream(chan, argv[2], chan->language))) ast_debug(1, "Ooh, found a video stream, too\n"); ast_verb(3, "Playing '%s' (escape_digits=%s) (sample_offset %ld)\n", argv[2], edigits, sample_offset); ast_seekstream(fs, 0, SEEK_END); max_length = ast_tellstream(fs); ast_seekstream(fs, sample_offset, SEEK_SET); res = ast_applystream(chan, fs); if (vfs) vres = ast_applystream(chan, vfs); ast_playstream(fs); if (vfs) ast_playstream(vfs); res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl); /* this is to check for if ast_waitstream closed the stream, we probably are at * the end of the stream, return that amount, else check for the amount */ sample_offset = (chan->stream) ? ast_tellstream(fs) : max_length; ast_stopstream(chan); if (res == 1) { /* Stop this command, don't print a result line, as there is a new command */ return RESULT_SUCCESS; } ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", res, sample_offset); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } /*! \brief get option - really similar to the handle_streamfile, but with a timeout */ static int handle_getoption(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, vres; struct ast_filestream *fs, *vfs; long sample_offset = 0, max_length; int timeout = 0; char *edigits = ""; if ( argc < 4 || argc > 5 ) return RESULT_SHOWUSAGE; if ( argv[3] ) edigits = argv[3]; if ( argc == 5 ) timeout = atoi(argv[4]); else if (chan->pbx->dtimeoutms) { /* by default dtimeout is set to 5sec */ timeout = chan->pbx->dtimeoutms; /* in msec */ } if (!(fs = ast_openstream(chan, argv[2], chan->language))) { ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", 0, sample_offset); ast_log(LOG_WARNING, "Unable to open %s\n", argv[2]); return RESULT_SUCCESS; } if ((vfs = ast_openvstream(chan, argv[2], chan->language))) ast_debug(1, "Ooh, found a video stream, too\n"); ast_verb(3, "Playing '%s' (escape_digits=%s) (timeout %d)\n", argv[2], edigits, timeout); ast_seekstream(fs, 0, SEEK_END); max_length = ast_tellstream(fs); ast_seekstream(fs, sample_offset, SEEK_SET); res = ast_applystream(chan, fs); if (vfs) vres = ast_applystream(chan, vfs); ast_playstream(fs); if (vfs) ast_playstream(vfs); res = ast_waitstream_full(chan, argv[3], agi->audio, agi->ctrl); /* this is to check for if ast_waitstream closed the stream, we probably are at * the end of the stream, return that amount, else check for the amount */ sample_offset = (chan->stream)?ast_tellstream(fs):max_length; ast_stopstream(chan); if (res == 1) { /* Stop this command, don't print a result line, as there is a new command */ return RESULT_SUCCESS; } /* If the user didnt press a key, wait for digitTimeout*/ if (res == 0 ) { res = ast_waitfordigit_full(chan, timeout, agi->audio, agi->ctrl); /* Make sure the new result is in the escape digits of the GET OPTION */ if ( !strchr(edigits,res) ) res=0; } ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", res, sample_offset); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } /*! \brief Say number in various language syntaxes */ /* While waiting, we're sending a NULL. */ static int handle_saynumber(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, num; if (argc < 4 || argc > 5) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30d", &num) != 1) return RESULT_SHOWUSAGE; res = ast_say_number_full(chan, num, argv[3], chan->language, argc > 4 ? argv[4] : NULL, agi->audio, agi->ctrl); if (res == 1) return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_saydigits(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, num; if (argc != 4) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30d", &num) != 1) return RESULT_SHOWUSAGE; res = ast_say_digit_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl); if (res == 1) /* New command */ return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_sayalpha(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res; if (argc != 4) return RESULT_SHOWUSAGE; res = ast_say_character_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl); if (res == 1) /* New command */ return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_saydate(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, num; if (argc != 4) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30d", &num) != 1) return RESULT_SHOWUSAGE; res = ast_say_date(chan, num, argv[3], chan->language); if (res == 1) return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_saytime(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, num; if (argc != 4) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30d", &num) != 1) return RESULT_SHOWUSAGE; res = ast_say_time(chan, num, argv[3], chan->language); if (res == 1) return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_saydatetime(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res = 0; time_t unixtime; char *format, *zone = NULL; if (argc < 4) return RESULT_SHOWUSAGE; if (argc > 4) { format = argv[4]; } else { /* XXX this doesn't belong here, but in the 'say' module */ if (!strcasecmp(chan->language, "de")) { format = "A dBY HMS"; } else { format = "ABdY 'digits/at' IMp"; } } if (argc > 5 && !ast_strlen_zero(argv[5])) zone = argv[5]; if (ast_get_time_t(argv[2], &unixtime, 0, NULL)) return RESULT_SHOWUSAGE; res = ast_say_date_with_format(chan, unixtime, argv[3], chan->language, format, zone); if (res == 1) return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_sayphonetic(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res; if (argc != 4) return RESULT_SHOWUSAGE; res = ast_say_phonetic_str_full(chan, argv[2], argv[3], chan->language, agi->audio, agi->ctrl); if (res == 1) /* New command */ return RESULT_SUCCESS; ast_agi_send(agi->fd, chan, "200 result=%d\n", res); return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE; } static int handle_getdata(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { int res, max, timeout; char data[1024]; if (argc < 3) return RESULT_SHOWUSAGE; if (argc >= 4) timeout = atoi(argv[3]); else timeout = 0; if (argc >= 5) max = atoi(argv[4]); else max = 1024; res = ast_app_getdata_full(chan, argv[2], data, max, timeout, agi->audio, agi->ctrl); if (res == 2) /* New command */ return RESULT_SUCCESS; else if (res == 1) ast_agi_send(agi->fd, chan, "200 result=%s (timeout)\n", data); else if (res < 0 ) ast_agi_send(agi->fd, chan, "200 result=-1\n"); else ast_agi_send(agi->fd, chan, "200 result=%s\n", data); return RESULT_SUCCESS; } static int handle_setcontext(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { if (argc != 3) return RESULT_SHOWUSAGE; ast_copy_string(chan->context, argv[2], sizeof(chan->context)); ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_setextension(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argc != 3) return RESULT_SHOWUSAGE; ast_copy_string(chan->exten, argv[2], sizeof(chan->exten)); ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_setpriority(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int pri; if (argc != 3) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30d", &pri) != 1) { if ((pri = ast_findlabel_extension(chan, chan->context, chan->exten, argv[2], chan->cid.cid_num)) < 1) return RESULT_SHOWUSAGE; } ast_explicit_goto(chan, NULL, NULL, pri); ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_recordfile(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { struct ast_filestream *fs; struct ast_frame *f; struct timeval start; long sample_offset = 0; int res = 0; int ms; struct ast_dsp *sildet=NULL; /* silence detector dsp */ int totalsilence = 0; int dspsilence = 0; int silence = 0; /* amount of silence to allow */ int gotsilence = 0; /* did we timeout for silence? */ char *silencestr = NULL; int rfmt = 0; /* XXX EAGI FIXME XXX */ if (argc < 6) return RESULT_SHOWUSAGE; if (sscanf(argv[5], "%30d", &ms) != 1) return RESULT_SHOWUSAGE; if (argc > 6) silencestr = strchr(argv[6],'s'); if ((argc > 7) && (!silencestr)) silencestr = strchr(argv[7],'s'); if ((argc > 8) && (!silencestr)) silencestr = strchr(argv[8],'s'); if (silencestr) { if (strlen(silencestr) > 2) { if ((silencestr[0] == 's') && (silencestr[1] == '=')) { silencestr++; silencestr++; if (silencestr) silence = atoi(silencestr); if (silence > 0) silence *= 1000; } } } if (silence > 0) { rfmt = chan->readformat; res = ast_set_read_format(chan, AST_FORMAT_SLINEAR); if (res < 0) { ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n"); return -1; } sildet = ast_dsp_new(); if (!sildet) { ast_log(LOG_WARNING, "Unable to create silence detector :(\n"); return -1; } ast_dsp_set_threshold(sildet, ast_dsp_get_threshold_from_settings(THRESHOLD_SILENCE)); } /* backward compatibility, if no offset given, arg[6] would have been * caught below and taken to be a beep, else if it is a digit then it is a * offset */ if ((argc >6) && (sscanf(argv[6], "%30ld", &sample_offset) != 1) && (!strchr(argv[6], '='))) res = ast_streamfile(chan, "beep", chan->language); if ((argc > 7) && (!strchr(argv[7], '='))) res = ast_streamfile(chan, "beep", chan->language); if (!res) res = ast_waitstream(chan, argv[4]); if (res) { ast_agi_send(agi->fd, chan, "200 result=%d (randomerror) endpos=%ld\n", res, sample_offset); } else { fs = ast_writefile(argv[2], argv[3], NULL, O_CREAT | O_WRONLY | (sample_offset ? O_APPEND : 0), 0, AST_FILE_MODE); if (!fs) { res = -1; ast_agi_send(agi->fd, chan, "200 result=%d (writefile)\n", res); if (sildet) ast_dsp_free(sildet); return RESULT_FAILURE; } /* Request a video update */ ast_indicate(chan, AST_CONTROL_VIDUPDATE); chan->stream = fs; ast_applystream(chan,fs); /* really should have checks */ ast_seekstream(fs, sample_offset, SEEK_SET); ast_truncstream(fs); start = ast_tvnow(); while ((ms < 0) || ast_tvdiff_ms(ast_tvnow(), start) < ms) { res = ast_waitfor(chan, ms - ast_tvdiff_ms(ast_tvnow(), start)); if (res < 0) { ast_closestream(fs); ast_agi_send(agi->fd, chan, "200 result=%d (waitfor) endpos=%ld\n", res,sample_offset); if (sildet) ast_dsp_free(sildet); return RESULT_FAILURE; } f = ast_read(chan); if (!f) { ast_agi_send(agi->fd, chan, "200 result=%d (hangup) endpos=%ld\n", -1, sample_offset); ast_closestream(fs); if (sildet) ast_dsp_free(sildet); return RESULT_FAILURE; } switch(f->frametype) { case AST_FRAME_DTMF: if (strchr(argv[4], f->subclass)) { /* This is an interrupting chracter, so rewind to chop off any small amount of DTMF that may have been recorded */ ast_stream_rewind(fs, 200); ast_truncstream(fs); sample_offset = ast_tellstream(fs); ast_agi_send(agi->fd, chan, "200 result=%d (dtmf) endpos=%ld\n", f->subclass, sample_offset); ast_closestream(fs); ast_frfree(f); if (sildet) ast_dsp_free(sildet); return RESULT_SUCCESS; } break; case AST_FRAME_VOICE: ast_writestream(fs, f); /* this is a safe place to check progress since we know that fs * is valid after a write, and it will then have our current * location */ sample_offset = ast_tellstream(fs); if (silence > 0) { dspsilence = 0; ast_dsp_silence(sildet, f, &dspsilence); if (dspsilence) { totalsilence = dspsilence; } else { totalsilence = 0; } if (totalsilence > silence) { /* Ended happily with silence */ gotsilence = 1; break; } } break; case AST_FRAME_VIDEO: ast_writestream(fs, f); default: /* Ignore all other frames */ break; } ast_frfree(f); if (gotsilence) break; } if (gotsilence) { ast_stream_rewind(fs, silence-1000); ast_truncstream(fs); sample_offset = ast_tellstream(fs); } ast_agi_send(agi->fd, chan, "200 result=%d (timeout) endpos=%ld\n", res, sample_offset); ast_closestream(fs); } if (silence > 0) { res = ast_set_read_format(chan, rfmt); if (res) ast_log(LOG_WARNING, "Unable to restore read format on '%s'\n", chan->name); ast_dsp_free(sildet); } return RESULT_SUCCESS; } static int handle_autohangup(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { double timeout; struct timeval whentohangup = { 0, 0 }; if (argc != 3) return RESULT_SHOWUSAGE; if (sscanf(argv[2], "%30lf", &timeout) != 1) return RESULT_SHOWUSAGE; if (timeout < 0) timeout = 0; if (timeout) { whentohangup.tv_sec = timeout; whentohangup.tv_usec = (timeout - whentohangup.tv_sec) * 1000000.0; } ast_channel_setwhentohangup_tv(chan, whentohangup); ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_hangup(struct ast_channel *chan, AGI *agi, int argc, char **argv) { struct ast_channel *c; if (argc == 1) { /* no argument: hangup the current channel */ ast_softhangup(chan,AST_SOFTHANGUP_EXPLICIT); ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } else if (argc == 2) { /* one argument: look for info on the specified channel */ c = ast_get_channel_by_name_locked(argv[1]); if (c) { /* we have a matching channel */ ast_softhangup(c,AST_SOFTHANGUP_EXPLICIT); ast_agi_send(agi->fd, chan, "200 result=1\n"); ast_channel_unlock(c); return RESULT_SUCCESS; } /* if we get this far no channel name matched the argument given */ ast_agi_send(agi->fd, chan, "200 result=-1\n"); return RESULT_SUCCESS; } else { return RESULT_SHOWUSAGE; } } static int handle_exec(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int res; struct ast_app *app_to_exec; if (argc < 2) return RESULT_SHOWUSAGE; ast_verb(3, "AGI Script Executing Application: (%s) Options: (%s)\n", argv[1], argv[2]); if ((app_to_exec = pbx_findapp(argv[1]))) { if(!strcasecmp(argv[1], PARK_APP_NAME)) { ast_masq_park_call(chan, NULL, 0, NULL); } if (ast_compat_res_agi && !ast_strlen_zero(argv[2])) { char *compat = alloca(strlen(argv[2]) * 2 + 1), *cptr, *vptr; for (cptr = compat, vptr = argv[2]; *vptr; vptr++) { if (*vptr == ',') { *cptr++ = '\\'; *cptr++ = ','; } else if (*vptr == '|') { *cptr++ = ','; } else { *cptr++ = *vptr; } } *cptr = '\0'; res = pbx_exec(chan, app_to_exec, compat); } else { res = pbx_exec(chan, app_to_exec, argv[2]); } } else { ast_log(LOG_WARNING, "Could not find application (%s)\n", argv[1]); res = -2; } ast_agi_send(agi->fd, chan, "200 result=%d\n", res); /* Even though this is wrong, users are depending upon this result. */ return res; } static int handle_setcallerid(struct ast_channel *chan, AGI *agi, int argc, char **argv) { char tmp[256]=""; char *l = NULL, *n = NULL; if (argv[2]) { ast_copy_string(tmp, argv[2], sizeof(tmp)); ast_callerid_parse(tmp, &n, &l); if (l) ast_shrink_phone_number(l); else l = ""; if (!n) n = ""; ast_set_callerid(chan, l, n, NULL); } ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_channelstatus(struct ast_channel *chan, AGI *agi, int argc, char **argv) { struct ast_channel *c; if (argc == 2) { /* no argument: supply info on the current channel */ ast_agi_send(agi->fd, chan, "200 result=%d\n", chan->_state); return RESULT_SUCCESS; } else if (argc == 3) { /* one argument: look for info on the specified channel */ c = ast_get_channel_by_name_locked(argv[2]); if (c) { ast_agi_send(agi->fd, chan, "200 result=%d\n", c->_state); ast_channel_unlock(c); return RESULT_SUCCESS; } /* if we get this far no channel name matched the argument given */ ast_agi_send(agi->fd, chan, "200 result=-1\n"); return RESULT_SUCCESS; } else { return RESULT_SHOWUSAGE; } } static int handle_setvariable(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argv[3]) pbx_builtin_setvar_helper(chan, argv[2], argv[3]); ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_getvariable(struct ast_channel *chan, AGI *agi, int argc, char **argv) { char *ret; char tempstr[1024]; if (argc != 3) return RESULT_SHOWUSAGE; /* check if we want to execute an ast_custom_function */ if (!ast_strlen_zero(argv[2]) && (argv[2][strlen(argv[2]) - 1] == ')')) { ret = ast_func_read(chan, argv[2], tempstr, sizeof(tempstr)) ? NULL : tempstr; } else { pbx_retrieve_variable(chan, argv[2], &ret, tempstr, sizeof(tempstr), NULL); } if (ret) ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ret); else ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_getvariablefull(struct ast_channel *chan, AGI *agi, int argc, char **argv) { char tmp[4096]; struct ast_channel *chan2=NULL; if ((argc != 4) && (argc != 5)) return RESULT_SHOWUSAGE; if (argc == 5) { chan2 = ast_get_channel_by_name_locked(argv[4]); } else { chan2 = chan; } if (chan2) { pbx_substitute_variables_helper(chan2, argv[3], tmp, sizeof(tmp) - 1); ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", tmp); } else { ast_agi_send(agi->fd, chan, "200 result=0\n"); } if (chan2 && (chan2 != chan)) ast_channel_unlock(chan2); return RESULT_SUCCESS; } static int handle_verbose(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int level = 0; if (argc < 2) return RESULT_SHOWUSAGE; if (argv[2]) sscanf(argv[2], "%30d", &level); ast_verb(level, "%s: %s\n", chan->data, argv[1]); ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_dbget(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int res; struct ast_str *buf; if (argc != 4) return RESULT_SHOWUSAGE; if (!(buf = ast_str_create(16))) { ast_agi_send(agi->fd, chan, "200 result=-1\n"); return RESULT_SUCCESS; } do { res = ast_db_get(argv[2], argv[3], ast_str_buffer(buf), ast_str_size(buf)); ast_str_update(buf); if (ast_str_strlen(buf) < ast_str_size(buf) - 1) { break; } if (ast_str_make_space(&buf, ast_str_size(buf) * 2)) { break; } } while (1); if (res) ast_agi_send(agi->fd, chan, "200 result=0\n"); else ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ast_str_buffer(buf)); ast_free(buf); return RESULT_SUCCESS; } static int handle_dbput(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int res; if (argc != 5) return RESULT_SHOWUSAGE; res = ast_db_put(argv[2], argv[3], argv[4]); ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1'); return RESULT_SUCCESS; } static int handle_dbdel(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int res; if (argc != 4) return RESULT_SHOWUSAGE; res = ast_db_del(argv[2], argv[3]); ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1'); return RESULT_SUCCESS; } static int handle_dbdeltree(struct ast_channel *chan, AGI *agi, int argc, char **argv) { int res; if ((argc < 3) || (argc > 4)) return RESULT_SHOWUSAGE; if (argc == 4) res = ast_db_deltree(argv[2], argv[3]); else res = ast_db_deltree(argv[2], NULL); ast_agi_send(agi->fd, chan, "200 result=%c\n", res ? '0' : '1'); return RESULT_SUCCESS; } static char *handle_cli_agi_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) { switch (cmd) { case CLI_INIT: e->command = "agi set debug [on|off]"; e->usage = "Usage: agi set debug [on|off]\n" " Enables/disables dumping of AGI transactions for\n" " debugging purposes.\n"; return NULL; case CLI_GENERATE: return NULL; } if (a->argc != e->args) return CLI_SHOWUSAGE; if (strncasecmp(a->argv[3], "off", 3) == 0) { agidebug = 0; } else if (strncasecmp(a->argv[3], "on", 2) == 0) { agidebug = 1; } else { return CLI_SHOWUSAGE; } ast_cli(a->fd, "AGI Debugging %sabled\n", agidebug ? "En" : "Dis"); return CLI_SUCCESS; } static int handle_noop(struct ast_channel *chan, AGI *agi, int arg, char *argv[]) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_setmusic(struct ast_channel *chan, AGI *agi, int argc, char *argv[]) { if (!strncasecmp(argv[2], "on", 2)) ast_moh_start(chan, argc > 3 ? argv[3] : NULL, NULL); else if (!strncasecmp(argv[2], "off", 3)) ast_moh_stop(chan); ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_speechcreate(struct ast_channel *chan, AGI *agi, int argc, char **argv) { /* If a structure already exists, return an error */ if (agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } if ((agi->speech = ast_speech_new(argv[2], AST_FORMAT_SLINEAR))) ast_agi_send(agi->fd, chan, "200 result=1\n"); else ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } static int handle_speechset(struct ast_channel *chan, AGI *agi, int argc, char **argv) { /* Check for minimum arguments */ if (argc != 3) return RESULT_SHOWUSAGE; /* Check to make sure speech structure exists */ if (!agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } ast_speech_change(agi->speech, argv[2], argv[3]); ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_speechdestroy(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (agi->speech) { ast_speech_destroy(agi->speech); agi->speech = NULL; ast_agi_send(agi->fd, chan, "200 result=1\n"); } else { ast_agi_send(agi->fd, chan, "200 result=0\n"); } return RESULT_SUCCESS; } static int handle_speechloadgrammar(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argc != 5) return RESULT_SHOWUSAGE; if (!agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } if (ast_speech_grammar_load(agi->speech, argv[3], argv[4])) ast_agi_send(agi->fd, chan, "200 result=0\n"); else ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_speechunloadgrammar(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argc != 4) return RESULT_SHOWUSAGE; if (!agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } if (ast_speech_grammar_unload(agi->speech, argv[3])) ast_agi_send(agi->fd, chan, "200 result=0\n"); else ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_speechactivategrammar(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argc != 4) return RESULT_SHOWUSAGE; if (!agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } if (ast_speech_grammar_activate(agi->speech, argv[3])) ast_agi_send(agi->fd, chan, "200 result=0\n"); else ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int handle_speechdeactivategrammar(struct ast_channel *chan, AGI *agi, int argc, char **argv) { if (argc != 4) return RESULT_SHOWUSAGE; if (!agi->speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } if (ast_speech_grammar_deactivate(agi->speech, argv[3])) ast_agi_send(agi->fd, chan, "200 result=0\n"); else ast_agi_send(agi->fd, chan, "200 result=1\n"); return RESULT_SUCCESS; } static int speech_streamfile(struct ast_channel *chan, const char *filename, const char *preflang, int offset) { struct ast_filestream *fs = NULL; if (!(fs = ast_openstream(chan, filename, preflang))) return -1; if (offset) ast_seekstream(fs, offset, SEEK_SET); if (ast_applystream(chan, fs)) return -1; if (ast_playstream(fs)) return -1; return 0; } static int handle_speechrecognize(struct ast_channel *chan, AGI *agi, int argc, char **argv) { struct ast_speech *speech = agi->speech; char *prompt, dtmf = 0, tmp[4096] = "", *buf = tmp; int timeout = 0, offset = 0, old_read_format = 0, res = 0, i = 0; long current_offset = 0; const char *reason = NULL; struct ast_frame *fr = NULL; struct ast_speech_result *result = NULL; size_t left = sizeof(tmp); time_t start = 0, current; if (argc < 4) return RESULT_SHOWUSAGE; if (!speech) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } prompt = argv[2]; timeout = atoi(argv[3]); /* If offset is specified then convert from text to integer */ if (argc == 5) offset = atoi(argv[4]); /* We want frames coming in signed linear */ old_read_format = chan->readformat; if (ast_set_read_format(chan, AST_FORMAT_SLINEAR)) { ast_agi_send(agi->fd, chan, "200 result=0\n"); return RESULT_SUCCESS; } /* Setup speech structure */ if (speech->state == AST_SPEECH_STATE_NOT_READY || speech->state == AST_SPEECH_STATE_DONE) { ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY); ast_speech_start(speech); } /* Start playing prompt */ speech_streamfile(chan, prompt, chan->language, offset); /* Go into loop reading in frames, passing to speech thingy, checking for hangup, all that jazz */ while (ast_strlen_zero(reason)) { /* Run scheduled items */ ast_sched_runq(chan->sched); /* See maximum time of waiting */ if ((res = ast_sched_wait(chan->sched)) < 0) res = 1000; /* Wait for frame */ if (ast_waitfor(chan, res) > 0) { if (!(fr = ast_read(chan))) { reason = "hangup"; break; } } /* Perform timeout check */ if ((timeout > 0) && (start > 0)) { time(¤t); if ((current - start) >= timeout) { reason = "timeout"; if (fr) ast_frfree(fr); break; } } /* Check the speech structure for any changes */ ast_mutex_lock(&speech->lock); /* See if we need to quiet the audio stream playback */ if (ast_test_flag(speech, AST_SPEECH_QUIET) && chan->stream) { current_offset = ast_tellstream(chan->stream); ast_stopstream(chan); ast_clear_flag(speech, AST_SPEECH_QUIET); } /* Check each state */ switch (speech->state) { case AST_SPEECH_STATE_READY: /* If the stream is done, start timeout calculation */ if ((timeout > 0) && ((!chan->stream) || (chan->streamid == -1 && chan->timingfunc == NULL))) { ast_stopstream(chan); time(&start); } /* Write audio frame data into speech engine if possible */ if (fr && fr->frametype == AST_FRAME_VOICE) ast_speech_write(speech, fr->data.ptr, fr->datalen); break; case AST_SPEECH_STATE_WAIT: /* Cue waiting sound if not already playing */ if ((!chan->stream) || (chan->streamid == -1 && chan->timingfunc == NULL)) { ast_stopstream(chan); /* If a processing sound exists, or is not none - play it */ if (!ast_strlen_zero(speech->processing_sound) && strcasecmp(speech->processing_sound, "none")) speech_streamfile(chan, speech->processing_sound, chan->language, 0); } break; case AST_SPEECH_STATE_DONE: /* Get the results */ speech->results = ast_speech_results_get(speech); /* Change state to not ready */ ast_speech_change_state(speech, AST_SPEECH_STATE_NOT_READY); reason = "speech"; break; default: break; } ast_mutex_unlock(&speech->lock); /* Check frame for DTMF or hangup */ if (fr) { if (fr->frametype == AST_FRAME_DTMF) { reason = "dtmf"; dtmf = fr->subclass; } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass == AST_CONTROL_HANGUP) { reason = "hangup"; } ast_frfree(fr); } } if (!strcasecmp(reason, "speech")) { /* Build string containing speech results */ for (result = speech->results; result; result = AST_LIST_NEXT(result, list)) { /* Build result string */ ast_build_string(&buf, &left, "%sscore%d=%d text%d=\"%s\" grammar%d=%s", (i > 0 ? " " : ""), i, result->score, i, result->text, i, result->grammar); /* Increment result count */ i++; } /* Print out */ ast_agi_send(agi->fd, chan, "200 result=1 (speech) endpos=%ld results=%d %s\n", current_offset, i, tmp); } else if (!strcasecmp(reason, "dtmf")) { ast_agi_send(agi->fd, chan, "200 result=1 (digit) digit=%c endpos=%ld\n", dtmf, current_offset); } else if (!strcasecmp(reason, "hangup") || !strcasecmp(reason, "timeout")) { ast_agi_send(agi->fd, chan, "200 result=1 (%s) endpos=%ld\n", reason, current_offset); } else { ast_agi_send(agi->fd, chan, "200 result=0 endpos=%ld\n", current_offset); } return RESULT_SUCCESS; } static char usage_verbose[] = " Usage: VERBOSE \n" " Sends to the console via verbose message system.\n" " is the the verbose level (1-4)\n" " Always returns 1.\n"; static char usage_setvariable[] = " Usage: SET VARIABLE \n"; static char usage_setcallerid[] = " Usage: SET CALLERID \n" " Changes the callerid of the current channel.\n"; static char usage_waitfordigit[] = " Usage: WAIT FOR DIGIT \n" " Waits up to 'timeout' milliseconds for channel to receive a DTMF digit.\n" " Returns -1 on channel failure, 0 if no digit is received in the timeout, or\n" " the numerical value of the ascii of the digit if one is received. Use -1\n" " for the timeout value if you desire the call to block indefinitely.\n"; static char usage_sendtext[] = " Usage: SEND TEXT \"\"\n" " Sends the given text on a channel. Most channels do not support the\n" " transmission of text. Returns 0 if text is sent, or if the channel does not\n" " support text transmission. Returns -1 only on error/hangup. Text\n" " consisting of greater than one word should be placed in quotes since the\n" " command only accepts a single argument.\n"; static char usage_recvchar[] = " Usage: RECEIVE CHAR \n" " Receives a character of text on a channel. Specify timeout to be the\n" " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n" " do not support the reception of text. Returns the decimal value of the character\n" " if one is received, or 0 if the channel does not support text reception. Returns\n" " -1 only on error/hangup.\n"; static char usage_recvtext[] = " Usage: RECEIVE TEXT \n" " Receives a string of text on a channel. Specify timeout to be the\n" " maximum time to wait for input in milliseconds, or 0 for infinite. Most channels\n" " do not support the reception of text. Returns -1 for failure or 1 for success, and the string in parentheses.\n"; static char usage_tddmode[] = " Usage: TDD MODE \n" " Enable/Disable TDD transmission/reception on a channel. Returns 1 if\n" " successful, or 0 if channel is not TDD-capable.\n"; static char usage_sendimage[] = " Usage: SEND IMAGE \n" " Sends the given image on a channel. Most channels do not support the\n" " transmission of images. Returns 0 if image is sent, or if the channel does not\n" " support image transmission. Returns -1 only on error/hangup. Image names\n" " should not include extensions.\n"; static char usage_streamfile[] = " Usage: STREAM FILE [sample offset]\n" " Send the given file, allowing playback to be interrupted by the given\n" " digits, if any. Use double quotes for the digits if you wish none to be\n" " permitted. If sample offset is provided then the audio will seek to sample\n" " offset before play starts. Returns 0 if playback completes without a digit\n" " being pressed, or the ASCII numerical value of the digit if one was pressed,\n" " or -1 on error or if the channel was disconnected. Remember, the file\n" " extension must not be included in the filename.\n"; static char usage_controlstreamfile[] = " Usage: CONTROL STREAM FILE [skipms] [ffchar] [rewchr] [pausechr]\n" " Send the given file, allowing playback to be controled by the given\n" " digits, if any. Use double quotes for the digits if you wish none to be\n" " permitted. Returns 0 if playback completes without a digit\n" " being pressed, or the ASCII numerical value of the digit if one was pressed,\n" " or -1 on error or if the channel was disconnected. Remember, the file\n" " extension must not be included in the filename.\n\n" " Note: ffchar and rewchar default to * and # respectively.\n"; static char usage_saynumber[] = " Usage: SAY NUMBER [gender]\n" " Say a given number, returning early if any of the given DTMF digits\n" " are received on the channel. Returns 0 if playback completes without a digit\n" " being pressed, or the ASCII numerical value of the digit if one was pressed or\n" " -1 on error/hangup.\n"; static char usage_saydigits[] = " Usage: SAY DIGITS \n" " Say a given digit string, returning early if any of the given DTMF digits\n" " are received on the channel. Returns 0 if playback completes without a digit\n" " being pressed, or the ASCII numerical value of the digit if one was pressed or\n" " -1 on error/hangup.\n"; static char usage_sayalpha[] = " Usage: SAY ALPHA \n" " Say a given character string, returning early if any of the given DTMF digits\n" " are received on the channel. Returns 0 if playback completes without a digit\n" " being pressed, or the ASCII numerical value of the digit if one was pressed or\n" " -1 on error/hangup.\n"; static char usage_saydate[] = " Usage: SAY DATE \n" " Say a given date, returning early if any of the given DTMF digits are\n" " received on the channel. is number of seconds elapsed since 00:00:00\n" " on January 1, 1970, Coordinated Universal Time (UTC). Returns 0 if playback\n" " completes without a digit being pressed, or the ASCII numerical value of the\n" " digit if one was pressed or -1 on error/hangup.\n"; static char usage_saytime[] = " Usage: SAY TIME