res_agi.c File Reference

AGI - the Asterisk Gateway Interface. More...

#include "asterisk.h"
#include <math.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <pthread.h>
#include "asterisk/paths.h"
#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/term.h"
#include "asterisk/xmldoc.h"
#include "asterisk/srv.h"
#include "asterisk/test.h"
#include "asterisk/netsock2.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/format_cache.h"
#include "asterisk/agi.h"

Include dependency graph for res_agi.c:

Go to the source code of this file.

Data Structures
struct	agi_cmd
struct	agi_commands

Macros
#define	AGI_BUF_INITSIZE   256
#define	AGI_BUF_LEN   8192
#define	AGI_BUF_SIZE   1024
#define	AGI_NANDFS_RETRY   3
#define	AGI_PORT   4573
#define	AMI_BUF_SIZE   2048
#define	AST_API_MODULE
#define	ASYNC_AGI_BREAK   3
#define	MAX_AGI_CONNECT   2000
#define	MAX_ARGS   128
#define	MAX_CMD_LEN   80
#define	SRV_PREFIX   "_agi._tcp."
#define	TONE_BLOCK_SIZE   200

Enumerations
enum	agi_result {   AGI_RESULT_FAILURE = -1 , AGI_RESULT_SUCCESS , AGI_RESULT_SUCCESS_FAST , AGI_RESULT_SUCCESS_ASYNC ,   AGI_RESULT_NOTFOUND , AGI_RESULT_HANGUP }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static int	action_add_agi_cmd (struct mansession *s, const struct message *m)
	Add a new command to execute by the Async AGI application.
static int	add_agi_cmd (struct ast_channel *chan, const char *cmd_buff, const char *cmd_id)
static int	add_to_agi (struct ast_channel *chan)
static struct ast_manager_event_blob *	agi_async_end_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	agi_async_exec_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	agi_async_start_to_ami (struct stasis_message *message)
static struct ast_manager_event_blob *	agi_channel_to_ami (const char *type, struct stasis_message *message)
static void	agi_destroy_commands_cb (void *data)
static int	agi_exec (struct ast_channel *chan, const char *data)
static struct ast_manager_event_blob *	agi_exec_end_to_ami (struct stasis_message *message)
static int	agi_exec_full (struct ast_channel *chan, const char *data, int enhanced, int dead)
static struct ast_manager_event_blob *	agi_exec_start_to_ami (struct stasis_message *message)
static enum agi_result	agi_handle_command (struct ast_channel *chan, AGI *agi, char *buf, int dead)
int AST_OPTIONAL_API_NAME()	ast_agi_register (struct ast_module *mod, agi_command *cmd)
	Registers an AGI command.
int AST_OPTIONAL_API_NAME()	ast_agi_register_multiple (struct ast_module *mod, struct agi_command *cmd, unsigned int len)
	Registers a group of AGI commands, provided as an array of struct agi_command entries.
int AST_OPTIONAL_API_NAME()	ast_agi_send (int fd, struct ast_channel *chan, char *fmt,...)
	Sends a string of text to an application connected via AGI.
int AST_OPTIONAL_API_NAME()	ast_agi_unregister (agi_command *cmd)
	Unregisters an AGI command.
int AST_OPTIONAL_API_NAME()	ast_agi_unregister_multiple (struct agi_command *cmd, unsigned int len)
	Unregisters a group of AGI commands, provided as an array of struct agi_command entries.
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (agi_buf, NULL, ast_free_ptr, static)
static enum agi_result	async_agi_read_frame (struct ast_channel *chan)
static int	eagi_exec (struct ast_channel *chan, const char *data)
static agi_command *	find_command (const char *const cmds[], int exact)
static void	free_agi_cmd (struct agi_cmd *cmd)
static int	get_agi_cmd (struct ast_channel *chan, struct agi_cmd **cmd)
	Retrieve the list head to the requested channel's AGI datastore.
static int	handle_answer (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_asyncagi_break (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_autohangup (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_channelstatus (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static char *	handle_cli_agi_add_cmd (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command to add applications to execute in Async AGI.
static char *	handle_cli_agi_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_agi_dump_html (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static char *	handle_cli_agi_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
static int	handle_connection (const char *agiurl, const struct ast_sockaddr addr, const int netsockfd)
static int	handle_controlstreamfile (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_dbdel (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_dbdeltree (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_dbget (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_dbput (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_exec (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_getdata (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_getoption (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
	get option - really similar to the handle_streamfile, but with a timeout
static int	handle_getvariable (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_getvariablefull (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_hangup (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_noop (struct ast_channel *chan, AGI *agi, int arg, const char *const argv[])
static int	handle_recordfile (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_recvchar (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_recvtext (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_sayalpha (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_saydate (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_saydatetime (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_saydigits (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_saynumber (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
	Say number in various language syntaxes.
static int	handle_sayphonetic (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_saytime (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_sendimage (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_sendtext (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setcallerid (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setcontext (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setextension (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setmusic (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setpriority (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_setvariable (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechactivategrammar (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechcreate (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechdeactivategrammar (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechdestroy (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechloadgrammar (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechrecognize (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechset (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_speechunloadgrammar (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_streamfile (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_tddmode (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_verbose (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static int	handle_waitfordigit (struct ast_channel *chan, AGI *agi, int argc, const char *const argv[])
static char *	help_workhorse (int fd, const char *const match[])
static enum agi_result	launch_asyncagi (struct ast_channel *chan, int argc, char *argv[], int *efd)
static enum agi_result	launch_ha_netscript (char *agiurl, char *argv[], int *fds)
static enum agi_result	launch_netscript (char *agiurl, char *argv[], int *fds)
static enum agi_result	launch_script (struct ast_channel *chan, char *script, int argc, char *argv[], int *fds, int *efd, int *opid, int *safe_fork_called)
static int	load_module (void)
static int	parse_args (char *s, int *max, const char *argv[])
static void	publish_async_exec_end (struct ast_channel *chan, int command_id, const char *command, int result_code, const char *result)
static enum agi_result	run_agi (struct ast_channel *chan, char *request, AGI *agi, int pid, int *status, int dead, int argc, char *argv[])
static void	setup_env (struct ast_channel *chan, char *request, int fd, int enhanced, int argc, char *argv[])
static int	speech_streamfile (struct ast_channel *chan, const char *filename, const char *preflang, int offset)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (agi_async_end_type,.to_ami=agi_async_end_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (agi_async_exec_type,.to_ami=agi_async_exec_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (agi_async_start_type,.to_ami=agi_async_start_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (agi_exec_end_type,.to_ami=agi_exec_end_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (agi_exec_start_type,.to_ami=agi_exec_start_to_ami,)
static int	unload_module (void)
static void	write_html_escaped (FILE *htmlfile, char *str)
	Convert string to use HTML escaped characters.
static int	write_htmldump (const char *filename)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Asterisk Gateway Interface (AGI)" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_speech", }
static struct agi_commands	agi_commands = AST_RWLIST_HEAD_INIT_VALUE
static const struct ast_datastore_info	agi_commands_datastore_info
static int	agidebug = 0
static char *	app = "AGI"
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_agi []
static struct agi_command	commands []
	AGI commands list.
static char *	eapp = "EAGI"

Detailed Description

AGI - the Asterisk Gateway Interface.

Author

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

Definition in file res_agi.c.

Macro Definition Documentation

AGI_BUF_INITSIZE

#define AGI_BUF_INITSIZE   256

Definition at line 1610 of file res_agi.c.

AGI_BUF_LEN

#define AGI_BUF_LEN   8192

Definition at line 1519 of file res_agi.c.

AGI_BUF_SIZE

#define AGI_BUF_SIZE   1024

AGI_NANDFS_RETRY

#define AGI_NANDFS_RETRY   3

Definition at line 1518 of file res_agi.c.

AGI_PORT

#define AGI_PORT   4573

Definition at line 1533 of file res_agi.c.

AMI_BUF_SIZE

#define AMI_BUF_SIZE   2048

AST_API_MODULE

#define AST_API_MODULE

Definition at line 71 of file res_agi.c.

ASYNC_AGI_BREAK

#define ASYNC_AGI_BREAK   3

Special return code for "asyncagi break" command.

Definition at line 1536 of file res_agi.c.

MAX_AGI_CONNECT

#define MAX_AGI_CONNECT   2000

Definition at line 1531 of file res_agi.c.

MAX_ARGS

#define MAX_ARGS   128

Definition at line 1516 of file res_agi.c.

MAX_CMD_LEN

#define MAX_CMD_LEN   80

Definition at line 1517 of file res_agi.c.

SRV_PREFIX

#define SRV_PREFIX   "_agi._tcp."

Definition at line 1520 of file res_agi.c.

TONE_BLOCK_SIZE

#define TONE_BLOCK_SIZE   200

Definition at line 1528 of file res_agi.c.

Enumeration Type Documentation

agi_result

enum agi_result

Enumerator
AGI_RESULT_FAILURE
AGI_RESULT_SUCCESS
AGI_RESULT_SUCCESS_FAST
AGI_RESULT_SUCCESS_ASYNC
AGI_RESULT_NOTFOUND
AGI_RESULT_HANGUP

Definition at line 1538 of file res_agi.c.

                {
    AGI_RESULT_FAILURE = -1,
    AGI_RESULT_SUCCESS,
    AGI_RESULT_SUCCESS_FAST,
    AGI_RESULT_SUCCESS_ASYNC,
    AGI_RESULT_NOTFOUND,
    AGI_RESULT_HANGUP,
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 4881 of file res_agi.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 4881 of file res_agi.c.

action_add_agi_cmd()

static int action_add_agi_cmd ( struct mansession *  s, const struct message *  m  )

static

Add a new command to execute by the Async AGI application.

Parameters

s
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

Return values

0	on success or incorrect use
1	on failure to add the command ( most likely because the channel is not in Async AGI loop )

Definition at line 1835 of file res_agi.c.

{
    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;
    }
 
    if (!(chan = ast_channel_get_by_name(channel))) {
        snprintf(buf, sizeof(buf), "Channel %s does not exist.", channel);
        astman_send_error(s, m, buf);
        return 0;
    }
 
    ast_channel_lock(chan);
 
    if (add_agi_cmd(chan, cmdbuff, cmdid)) {
        snprintf(buf, sizeof(buf), "Failed to add AGI command to channel %s queue", ast_channel_name(chan));
        astman_send_error(s, m, buf);
        ast_channel_unlock(chan);
        chan = ast_channel_unref(chan);
        return 0;
    }
 
    ast_channel_unlock(chan);
    chan = ast_channel_unref(chan);
 
    astman_send_ack(s, m, "Added AGI command to queue");
 
    return 0;
}

References add_agi_cmd(), ast_channel_get_by_name(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_strlen_zero(), astman_get_header(), astman_send_ack(), astman_send_error(), and buf.

Referenced by load_module().

add_agi_cmd()

static int add_agi_cmd ( struct ast_channel *  chan, const char *  cmd_buff, const char *  cmd_id  )

static

Definition at line 1706 of file res_agi.c.

{
    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 setup for Async AGI.\n", ast_channel_name(chan));
        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;
}

References agi_commands_datastore_info, ast_calloc, ast_channel_datastore_find(), ast_channel_name(), ast_free, AST_LIST_HEAD, AST_LIST_INSERT_TAIL, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log, ast_strdup, agi_cmd::cmd_buffer, agi_cmd::cmd_id, ast_datastore::data, agi_cmd::entry, LOG_WARNING, and NULL.

Referenced by action_add_agi_cmd(), and handle_cli_agi_add_cmd().

add_to_agi()

static int add_to_agi ( struct ast_channel *  chan )

static

Definition at line 1739 of file res_agi.c.

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

References agi_commands_datastore_info, ast_calloc, ast_channel_datastore_add(), ast_channel_datastore_find(), ast_channel_lock, ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), AST_LIST_HEAD, AST_LIST_HEAD_INIT, ast_log, ast_datastore::data, LOG_ERROR, and NULL.

Referenced by launch_asyncagi().

agi_async_end_to_ami()

static struct ast_manager_event_blob * agi_async_end_to_ami ( struct stasis_message *  message )

static

Definition at line 1586 of file res_agi.c.

{
    return agi_channel_to_ami("AsyncAGIEnd", message);
}

References agi_channel_to_ami().

agi_async_exec_to_ami()

static struct ast_manager_event_blob * agi_async_exec_to_ami ( struct stasis_message *  message )

static

Definition at line 1581 of file res_agi.c.

{
    return agi_channel_to_ami("AsyncAGIExec", message);
}

References agi_channel_to_ami().

agi_async_start_to_ami()

static struct ast_manager_event_blob * agi_async_start_to_ami ( struct stasis_message *  message )

static

Definition at line 1576 of file res_agi.c.

{
    return agi_channel_to_ami("AsyncAGIStart", message);
}

References agi_channel_to_ami().

agi_channel_to_ami()

static struct ast_manager_event_blob * agi_channel_to_ami ( const char *  type, struct stasis_message *  message  )

static

Definition at line 1547 of file res_agi.c.

{
    struct ast_channel_blob *obj = stasis_message_data(message);
    RAII_VAR(struct ast_str *, channel_string, NULL, ast_free);
    RAII_VAR(struct ast_str *, event_string, NULL, ast_free);
 
    channel_string = ast_manager_build_channel_state_string(obj->snapshot);
    event_string = ast_manager_str_from_json_object(obj->blob, NULL);
    if (!channel_string || !event_string) {
        return NULL;
    }
 
    return ast_manager_event_blob_create(EVENT_FLAG_AGI, type,
        "%s"
        "%s",
        ast_str_buffer(channel_string),
        ast_str_buffer(event_string));
}

References ast_free, ast_manager_build_channel_state_string(), ast_manager_event_blob_create(), ast_manager_str_from_json_object(), ast_str_buffer(), ast_channel_blob::blob, EVENT_FLAG_AGI, NULL, RAII_VAR, ast_channel_blob::snapshot, stasis_message_data(), and type.

Referenced by agi_async_end_to_ami(), agi_async_exec_to_ami(), agi_async_start_to_ami(), agi_exec_end_to_ami(), and agi_exec_start_to_ami().

agi_destroy_commands_cb()

static void agi_destroy_commands_cb ( void *  data )

static

Definition at line 1656 of file res_agi.c.

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

References ast_free, AST_LIST_HEAD, AST_LIST_HEAD_DESTROY, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, agi_cmd::entry, and free_agi_cmd().

agi_exec()

static int agi_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 4735 of file res_agi.c.

{
    if (!ast_check_hangup(chan))
        return agi_exec_full(chan, data, 0, 0);
    else
        return agi_exec_full(chan, data, 0, 1);
}

References agi_exec_full(), and ast_check_hangup().

Referenced by load_module().

agi_exec_end_to_ami()

static struct ast_manager_event_blob * agi_exec_end_to_ami ( struct stasis_message *  message )

static

Definition at line 1571 of file res_agi.c.

{
    return agi_channel_to_ami("AGIExecEnd", message);
}

References agi_channel_to_ami().

agi_exec_full()

static int agi_exec_full ( struct ast_channel *  chan, const char *  data, int  enhanced, int  dead  )

static

Definition at line 4665 of file res_agi.c.

{
    enum agi_result res;
    char *buf;
    int fds[2], efd = -1, pid = -1;
    int safe_fork_called = 0;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(arg)[MAX_ARGS];
    );
    AGI agi;
 
    if (ast_strlen_zero(data)) {
        ast_log(LOG_WARNING, "AGI requires an argument (script)\n");
        return -1;
    }
    if (dead)
        ast_debug(3, "Hungup channel detected, running agi in dead mode.\n");
    memset(&agi, 0, sizeof(agi));
    buf = ast_strdupa(data);
    AST_STANDARD_APP_ARGS(args, buf);
    args.arg[args.argc] = NULL;
#if 0
     /* Answer if need be */
    if (chan->_state != AST_STATE_UP) {
        if (ast_answer(chan))
            return -1;
    }
#endif
    res = launch_script(chan, args.arg[0], args.argc, args.arg, fds, enhanced ? &efd : NULL, &pid, &safe_fork_called);
    /* Async AGI do not require run_agi(), so just proceed if normal AGI
       or Fast AGI are setup with success. */
    if (res == AGI_RESULT_SUCCESS || res == AGI_RESULT_SUCCESS_FAST) {
        int status = 0;
        agi.fd = fds[1];
        agi.ctrl = fds[0];
        agi.audio = efd;
        agi.fast = (res == AGI_RESULT_SUCCESS_FAST) ? 1 : 0;
        res = run_agi(chan, args.arg[0], &agi, pid, &status, dead, args.argc, args.arg);
        /* If the fork'd process returns non-zero, set AGISTATUS to FAILURE */
        if ((res == AGI_RESULT_SUCCESS || res == AGI_RESULT_SUCCESS_FAST) && status)
            res = AGI_RESULT_FAILURE;
        if (fds[1] != fds[0])
            close(fds[1]);
        if (efd > -1)
            close(efd);
    }
    if (safe_fork_called) {
        ast_safe_fork_cleanup();
    }
 
    switch (res) {
    case AGI_RESULT_SUCCESS:
    case AGI_RESULT_SUCCESS_FAST:
    case AGI_RESULT_SUCCESS_ASYNC:
        pbx_builtin_setvar_helper(chan, "AGISTATUS", "SUCCESS");
        break;
    case AGI_RESULT_FAILURE:
        pbx_builtin_setvar_helper(chan, "AGISTATUS", "FAILURE");
        break;
    case AGI_RESULT_NOTFOUND:
        pbx_builtin_setvar_helper(chan, "AGISTATUS", "NOTFOUND");
        break;
    case AGI_RESULT_HANGUP:
        pbx_builtin_setvar_helper(chan, "AGISTATUS", "HANGUP");
        return -1;
    }
 
    return 0;
}

References AGI_RESULT_FAILURE, AGI_RESULT_HANGUP, AGI_RESULT_NOTFOUND, AGI_RESULT_SUCCESS, AGI_RESULT_SUCCESS_ASYNC, AGI_RESULT_SUCCESS_FAST, args, ast_answer(), AST_APP_ARG, ast_debug, AST_DECLARE_APP_ARGS, ast_log, ast_safe_fork_cleanup(), AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_strlen_zero(), buf, agi_command::dead, launch_script(), LOG_WARNING, MAX_ARGS, NULL, pbx_builtin_setvar_helper(), run_agi(), and status.

Referenced by agi_exec(), eagi_exec(), and handle_exec().

agi_exec_start_to_ami()

static struct ast_manager_event_blob * agi_exec_start_to_ami ( struct stasis_message *  message )

static

Definition at line 1566 of file res_agi.c.

{
    return agi_channel_to_ami("AGIExecStart", message);
}

References agi_channel_to_ami().

agi_handle_command()

static enum agi_result agi_handle_command ( struct ast_channel *  chan, AGI *  agi, char *  buf, int  dead  )

static

Definition at line 4198 of file res_agi.c.

{
    const char *argv[MAX_ARGS] = {0};
    int argc = MAX_ARGS;
    int res;
    agi_command *c;
    char *ami_cmd = ast_strdupa(buf);
    const char *ami_res;
    int command_id = ast_random();
    int resultcode = 0;
    RAII_VAR(struct ast_json *, startblob, NULL, ast_json_unref);
 
    startblob = ast_json_pack("{s: i, s: s}",
                 "CommandId", command_id,
                 "Command", ami_cmd);
    ast_channel_publish_cached_blob(chan, agi_exec_start_type(), startblob);
 
    parse_args(buf, &argc, argv);
    c = find_command(argv, 0);
    if (!c || !ast_module_running_ref(c->mod)) {
        ami_res = "Invalid or unknown command";
        resultcode = 510;
 
        ast_agi_send(agi->fd, chan, "%d %s\n", resultcode, ami_res);
 
        publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
        return AGI_RESULT_SUCCESS;
    }
 
    if (!dead || (dead && c->dead)) {
        res = c->handler(chan, agi, argc, argv);
        switch (res) {
        case RESULT_SHOWUSAGE:
            ami_res = "Usage";
            resultcode = 520;
 
            publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
            if (ast_strlen_zero(c->usage)) {
                ast_agi_send(agi->fd, chan, "520 Invalid command syntax.  Proper usage not available.\n");
            } else {
                ast_agi_send(agi->fd, chan, "520-Invalid command syntax.  Proper usage follows:\n");
                ast_agi_send(agi->fd, chan, "%s\n", c->usage);
                ast_agi_send(agi->fd, chan, "520 End of proper usage.\n");
            }
 
            break;
        case RESULT_FAILURE:
            ami_res = "Failure";
            resultcode = -1;
 
            publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
            /* The RESULT_FAILURE code is usually because the channel hungup. */
            return AGI_RESULT_FAILURE;
        case ASYNC_AGI_BREAK:
            ami_res = "Success";
            resultcode = 200;
 
            publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
            return AGI_RESULT_SUCCESS_ASYNC;
        case RESULT_SUCCESS:
            ami_res = "Success";
            resultcode = 200;
 
            publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
            break;
        default:
            ami_res = "Unknown Result";
            resultcode = 200;
 
            publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
 
            break;
        }
    } else {
        ami_res = "Command Not Permitted on a dead channel or intercept routine";
        resultcode = 511;
 
        ast_agi_send(agi->fd, chan, "%d %s\n", resultcode, ami_res);
 
        publish_async_exec_end(chan, command_id, ami_cmd, resultcode, ami_res);
    }
    ast_module_unref(c->mod);
 
    return AGI_RESULT_SUCCESS;
}

References AGI_RESULT_FAILURE, AGI_RESULT_SUCCESS, AGI_RESULT_SUCCESS_ASYNC, ast_agi_send(), ast_channel_publish_cached_blob(), ast_json_pack(), ast_json_unref(), ast_module_running_ref, ast_module_unref, ast_random(), ast_strdupa, ast_strlen_zero(), ASYNC_AGI_BREAK, buf, c, agi_command::dead, agi_state::fd, find_command(), MAX_ARGS, NULL, parse_args(), publish_async_exec_end(), RAII_VAR, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

Referenced by launch_asyncagi(), and run_agi().

ast_agi_register()

int AST_OPTIONAL_API_NAME() ast_agi_register	(	struct ast_module *	mod,
		agi_command *	cmd
	)

Registers an AGI command.

Parameters

mod	Pointer to the module_info structure for the module that is registering the command
cmd	Pointer to the descriptor for the command

Return values

1	on success
0	the command is already registered
AST_OPTIONAL_API_UNAVAILABLE	the module is not loaded.

Definition at line 3954 of file res_agi.c.

{
    char fullcmd[MAX_CMD_LEN];
 
    ast_join(fullcmd, sizeof(fullcmd), cmd->cmda);
 
    if (!find_command(cmd->cmda, 1)) {
        *((enum ast_doc_src *) &cmd->docsrc) = AST_STATIC_DOC;
        if (ast_strlen_zero(cmd->summary) && ast_strlen_zero(cmd->usage)) {
#ifdef AST_XML_DOCS
            *((char **) &cmd->summary) = ast_xmldoc_build_synopsis("agi", fullcmd, NULL);
            *((char **) &cmd->since) = ast_xmldoc_build_since("agi", fullcmd, NULL);
            *((char **) &cmd->usage) = ast_xmldoc_build_description("agi", fullcmd, NULL);
            *((char **) &cmd->syntax) = ast_xmldoc_build_syntax("agi", fullcmd, NULL);
            *((char **) &cmd->arguments) = ast_xmldoc_build_arguments("agi", fullcmd, NULL);
            *((char **) &cmd->seealso) = ast_xmldoc_build_seealso("agi", fullcmd, NULL);
            *((enum ast_doc_src *) &cmd->docsrc) = AST_XML_DOC;
#endif
#ifndef HAVE_NULLSAFE_PRINTF
            if (!cmd->summary) {
                *((char **) &cmd->summary) = ast_strdup("");
            }
            if (!cmd->usage) {
                *((char **) &cmd->usage) = ast_strdup("");
            }
            if (!cmd->syntax) {
                *((char **) &cmd->syntax) = ast_strdup("");
            }
            if (!cmd->seealso) {
                *((char **) &cmd->seealso) = ast_strdup("");
            }
#endif
        }
 
        cmd->mod = mod;
        AST_RWLIST_WRLOCK(&agi_commands);
        AST_LIST_INSERT_TAIL(&agi_commands, cmd, list);
        AST_RWLIST_UNLOCK(&agi_commands);
        ast_verb(5, "AGI Command '%s' registered\n",fullcmd);
        return 1;
    } else {
        ast_log(LOG_WARNING, "Command already registered!\n");
        return 0;
    }
}

References ast_join, AST_LIST_INSERT_TAIL, ast_log, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, AST_STATIC_DOC, ast_strdup, ast_strlen_zero(), ast_verb, AST_XML_DOC, ast_xmldoc_build_arguments(), ast_xmldoc_build_description(), ast_xmldoc_build_seealso(), ast_xmldoc_build_since(), ast_xmldoc_build_synopsis(), ast_xmldoc_build_syntax(), find_command(), LOG_WARNING, MAX_CMD_LEN, and NULL.

Referenced by ast_agi_register_multiple(), AST_TEST_DEFINE(), and load_module().

ast_agi_register_multiple()

int AST_OPTIONAL_API_NAME() ast_agi_register_multiple	(	struct ast_module *	mod,
		struct agi_command *	cmd,
		unsigned int	len
	)

Registers a group of AGI commands, provided as an array of struct agi_command entries.

Parameters

mod	Pointer to the module_info structure for the module that is registering the commands
cmd	Pointer to the first entry in the array of command descriptors
len	Length of the array (use the ARRAY_LEN macro to determine this easily)

Returns

0 on success, -1 on failure, AST_OPTIONAL_API_UNAVAILABLE if res_agi is not loaded

Note

If any command fails to register, all commands previously registered during the operation will be unregistered. In other words, this function registers all the provided commands, or none of them.

Definition at line 4040 of file res_agi.c.

{
    unsigned int i, x = 0;
 
    for (i = 0; i < len; i++) {
        if (ast_agi_register(mod, cmd + i) == 1) {
            x++;
            continue;
        }
 
        /* registration failed, unregister everything
           that had been registered up to that point
        */
        for (; x > 0; x--) {
            /* we are intentionally ignoring the
               result of ast_agi_unregister() here,
               but it should be safe to do so since
               we just registered these commands and
               the only possible way for unregistration
               to fail is if the command is not
               registered
            */
            (void) ast_agi_unregister(cmd + x - 1);
        }
        return -1;
    }
 
    return 0;
}

References ast_agi_register(), ast_agi_unregister(), len(), and agi_command::mod.

Referenced by load_module().

ast_agi_send()

int AST_OPTIONAL_API_NAME() ast_agi_send	(	int	fd,
		struct ast_channel *	chan,
		char *	fmt,
			...
	)

Sends a string of text to an application connected via AGI.

Parameters

fd	The file descriptor for the AGI session (from struct agi_state)
chan	Pointer to an associated Asterisk channel, if any
fmt	printf-style format string

Returns

0 for success, -1 for failure, AST_OPTIONAL_API_UNAVAILABLE if res_agi is not loaded

Definition at line 1612 of file res_agi.c.

{
    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", ast_channel_name(chan), 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);
}

References AGI_BUF_INITSIZE, agidebug, ast_carefulwrite(), ast_channel_name(), ast_log, ast_str_buffer(), ast_str_set_va(), ast_str_strlen(), ast_str_thread_get(), ast_verbose, buf, and LOG_ERROR.

Referenced by agi_handle_command(), handle_answer(), handle_asyncagi_break(), handle_autohangup(), handle_channelstatus(), handle_controlstreamfile(), handle_dbdel(), handle_dbdeltree(), handle_dbget(), handle_dbput(), handle_exec(), handle_getdata(), handle_getoption(), handle_getvariable(), handle_getvariablefull(), handle_gosub(), handle_hangup(), handle_noop(), handle_noop(), handle_recordfile(), handle_recvchar(), handle_recvtext(), handle_sayalpha(), handle_saydate(), handle_saydatetime(), handle_saydigits(), handle_saynumber(), handle_sayphonetic(), handle_saytime(), handle_sendimage(), handle_sendtext(), handle_setcallerid(), handle_setcontext(), handle_setextension(), handle_setmusic(), handle_setpriority(), handle_setvariable(), handle_speechactivategrammar(), handle_speechcreate(), handle_speechdeactivategrammar(), handle_speechdestroy(), handle_speechloadgrammar(), handle_speechrecognize(), handle_speechset(), handle_speechunloadgrammar(), handle_streamfile(), handle_tddmode(), handle_verbose(), handle_waitfordigit(), launch_netscript(), run_agi(), and setup_env().

ast_agi_unregister()

int AST_OPTIONAL_API_NAME() ast_agi_unregister

(

agi_command *

cmd

)

Unregisters an AGI command.

Parameters

cmd	Pointer to the descriptor for the command

Returns

1 on success, 0 if the command was not already registered

Definition at line 4000 of file res_agi.c.

{
    struct agi_command *e;
    int unregistered = 0;
    char fullcmd[MAX_CMD_LEN];
 
    ast_join(fullcmd, sizeof(fullcmd), cmd->cmda);
 
    AST_RWLIST_WRLOCK(&agi_commands);
    AST_RWLIST_TRAVERSE_SAFE_BEGIN(&agi_commands, e, list) {
        if (cmd == e) {
            AST_RWLIST_REMOVE_CURRENT(list);
#ifdef AST_XML_DOCS
            if (e->docsrc == AST_XML_DOC) {
                ast_free((char *) e->summary);
                ast_free((char *) e->since);
                ast_free((char *) e->usage);
                ast_free((char *) e->syntax);
                ast_free((char *) e->arguments);
                ast_free((char *) e->seealso);
                *((char **) &e->summary) = NULL;
                *((char **) &e->since) = NULL;
                *((char **) &e->usage) = NULL;
                *((char **) &e->syntax) = NULL;
                *((char **) &e->arguments) = NULL;
                *((char **) &e->seealso) = NULL;
            }
#endif
            unregistered=1;
            break;
        }
    }
    AST_RWLIST_TRAVERSE_SAFE_END;
    AST_RWLIST_UNLOCK(&agi_commands);
    if (unregistered) {
        ast_verb(5, "AGI Command '%s' unregistered\n",fullcmd);
    }
    return unregistered;
}

References agi_command::arguments, ast_free, ast_join, AST_RWLIST_REMOVE_CURRENT, AST_RWLIST_TRAVERSE_SAFE_BEGIN, AST_RWLIST_TRAVERSE_SAFE_END, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, AST_XML_DOC, agi_command::docsrc, agi_command::list, MAX_CMD_LEN, NULL, agi_command::seealso, agi_command::since, agi_command::summary, agi_command::syntax, and agi_command::usage.

Referenced by ast_agi_register_multiple(), ast_agi_unregister_multiple(), AST_TEST_DEFINE(), and unload_module().

ast_agi_unregister_multiple()

int AST_OPTIONAL_API_NAME() ast_agi_unregister_multiple	(	struct agi_command *	cmd,
		unsigned int	len
	)

Unregisters a group of AGI commands, provided as an array of struct agi_command entries.

Parameters

cmd	Pointer to the first entry in the array of command descriptors
len	Length of the array (use the ARRAY_LEN macro to determine this easily)

Returns

0 on success, -1 on failure, AST_OPTIONAL_API_UNAVAILABLE if res_agi is not loaded

Note

If any command fails to unregister, this function will continue to unregister the remaining commands in the array; it will not reregister the already-unregistered commands.

Definition at line 4070 of file res_agi.c.

{
    unsigned int i;
    int res = 0;
 
    for (i = 0; i < len; i++) {
        /* remember whether any of the unregistration
           attempts failed... there is no recourse if
           any of them do
        */
        res |= ast_agi_unregister(cmd + i);
    }
 
    return res;
}

References ast_agi_unregister(), and len().

Referenced by unload_module().

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 4881 of file res_agi.c.

AST_THREADSTORAGE_CUSTOM_SCOPE()

AST_THREADSTORAGE_CUSTOM_SCOPE	(	agi_buf	,
		NULL	,
		ast_free_ptr	,
		static
	)

async_agi_read_frame()

static enum agi_result async_agi_read_frame ( struct ast_channel *  chan )

static

Definition at line 1885 of file res_agi.c.

{
    struct ast_frame *f;
 
    f = ast_read(chan);
    if (!f) {
        ast_debug(3, "No frame read on channel %s, going out ...\n", ast_channel_name(chan));
        return AGI_RESULT_HANGUP;
    }
    if (f->frametype == AST_FRAME_CONTROL) {
        /*
         * Is there any other frame we should care about besides
         * AST_CONTROL_HANGUP?
         */
        switch (f->subclass.integer) {
        case AST_CONTROL_HANGUP:
            ast_debug(3, "Got HANGUP frame on channel %s, going out ...\n", ast_channel_name(chan));
            ast_frfree(f);
            return AGI_RESULT_HANGUP;
        default:
            break;
        }
    }
    ast_frfree(f);
 
    return AGI_RESULT_SUCCESS;
}

References AGI_RESULT_HANGUP, AGI_RESULT_SUCCESS, ast_channel_name(), AST_CONTROL_HANGUP, ast_debug, AST_FRAME_CONTROL, ast_frfree, ast_read(), ast_frame::frametype, ast_frame_subclass::integer, and ast_frame::subclass.

Referenced by launch_asyncagi().

eagi_exec()

static int eagi_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 4743 of file res_agi.c.

{
    int res;
    struct ast_format *readformat;
    struct ast_format *requested_format = NULL;
    const char *requested_format_name;
 
    if (ast_check_hangup(chan)) {
        ast_log(LOG_ERROR, "EAGI cannot be run on a dead/hungup channel, please use AGI.\n");
        return 0;
    }
 
    requested_format_name = pbx_builtin_getvar_helper(chan, "EAGI_AUDIO_FORMAT");
    if (requested_format_name) {
        requested_format = ast_format_cache_get(requested_format_name);
        if (requested_format) {
            ast_verb(3, "<%s> Setting EAGI audio pipe format to %s\n",
                     ast_channel_name(chan), ast_format_get_name(requested_format));
        } else {
            ast_log(LOG_ERROR, "Could not find requested format: %s\n", requested_format_name);
        }
    }
 
    readformat = ao2_bump(ast_channel_readformat(chan));
    if (ast_set_read_format(chan, requested_format ?: ast_format_slin)) {
        ast_log(LOG_WARNING, "Unable to set channel '%s' to linear mode\n", ast_channel_name(chan));
        ao2_cleanup(requested_format);
        ao2_cleanup(readformat);
        return -1;
    }
    res = agi_exec_full(chan, data, 1, 0);
    if (!res) {
        if (ast_set_read_format(chan, readformat)) {
            ast_log(LOG_WARNING, "Unable to restore channel '%s' to format %s\n", ast_channel_name(chan),
                ast_format_get_name(readformat));
        }
    }
    ao2_cleanup(requested_format);
    ao2_cleanup(readformat);
    return res;
}

References agi_exec_full(), ao2_bump, ao2_cleanup, ast_channel_name(), ast_channel_readformat(), ast_check_hangup(), ast_format_cache_get, ast_format_get_name(), ast_format_slin, ast_log, ast_set_read_format(), ast_verb, LOG_ERROR, LOG_WARNING, NULL, and pbx_builtin_getvar_helper().

Referenced by load_module().

find_command()

static agi_command * find_command ( const char *const  cmds[], int  exact  )

static

Definition at line 4086 of file res_agi.c.

{
    int y, match;
    struct agi_command *e;
 
    AST_RWLIST_RDLOCK(&agi_commands);
    AST_RWLIST_TRAVERSE(&agi_commands, e, list) {
        if (!e->cmda[0])
            break;
        /* start optimistic */
        match = 1;
        for (y = 0; match && cmds[y]; y++) {
            /* If there are no more words in the command (and we're looking for
               an exact match) or there is a difference between the two words,
               then this is not a match */
            if (!e->cmda[y] && !exact)
                break;
            /* don't segfault if the next part of a command doesn't exist */
            if (!e->cmda[y]) {
                AST_RWLIST_UNLOCK(&agi_commands);
                return NULL;
            }
            if (strcasecmp(e->cmda[y], cmds[y]))
                match = 0;
        }
        /* If more words are needed to complete the command then this is not
           a candidate (unless we're looking for a really inexact answer  */
        if ((exact > -1) && e->cmda[y])
            match = 0;
        if (match) {
            AST_RWLIST_UNLOCK(&agi_commands);
            return e;
        }
    }
    AST_RWLIST_UNLOCK(&agi_commands);
    return NULL;
}

References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, agi_command::cmda, agi_command::list, match(), and NULL.

Referenced by agi_handle_command(), ast_agi_register(), and handle_cli_agi_show().

free_agi_cmd()

static void free_agi_cmd ( struct agi_cmd *  cmd )

static

Definition at line 1648 of file res_agi.c.

{
    ast_free(cmd->cmd_buffer);
    ast_free(cmd->cmd_id);
    ast_free(cmd);
}

References ast_free, agi_cmd::cmd_buffer, and agi_cmd::cmd_id.

Referenced by agi_destroy_commands_cb(), and launch_asyncagi().

get_agi_cmd()

static int get_agi_cmd ( struct ast_channel *  chan, struct agi_cmd **  cmd  )

static

Retrieve the list head to the requested channel's AGI datastore.

Parameters

chan	Channel datastore is requested for
cmd	Pointer to the struct pointer which will reference the head of the agi command list.

Return values

0	if the datastore was valid and the list head was retrieved appropriately (even if it's NULL and the list is empty)
-1	if the datastore could not be retrieved causing an error

Definition at line 1684 of file res_agi.c.

{
    struct ast_datastore *store;
    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, "Huh? Async AGI datastore disappeared on Channel %s!\n",
            ast_channel_name(chan));
        *cmd = NULL;
        return -1;
    }
    agi_commands = store->data;
    AST_LIST_LOCK(agi_commands);
    *cmd = AST_LIST_REMOVE_HEAD(agi_commands, entry);
    AST_LIST_UNLOCK(agi_commands);
    return 0;
}

References agi_commands_datastore_info, ast_channel_datastore_find(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, AST_LIST_HEAD, AST_LIST_LOCK, AST_LIST_REMOVE_HEAD, AST_LIST_UNLOCK, ast_log, ast_datastore::data, ast_datastore::entry, LOG_ERROR, and NULL.

Referenced by launch_asyncagi().

handle_answer()

static int handle_answer ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2495 of file res_agi.c.

{
    int res = 0;
 
    /* Answer the channel */
    if (ast_channel_state(chan) != 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;
}

References ast_agi_send(), ast_answer(), AST_STATE_UP, agi_state::fd, RESULT_FAILURE, and RESULT_SUCCESS.

handle_asyncagi_break()

static int handle_asyncagi_break ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2507 of file res_agi.c.

{
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return ASYNC_AGI_BREAK;
}

References ast_agi_send(), ASYNC_AGI_BREAK, and agi_state::fd.

handle_autohangup()

static int handle_autohangup ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3230 of file res_agi.c.

{
    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_lock(chan);
    ast_channel_setwhentohangup_tv(chan, whentohangup);
    ast_channel_unlock(chan);
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_lock, ast_channel_setwhentohangup_tv(), ast_channel_unlock, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_channelstatus()

static int handle_channelstatus ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3347 of file res_agi.c.

{
    if (argc == 2) {
        /* no argument: supply info on the current channel */
        ast_agi_send(agi->fd, chan, "200 result=%u\n", ast_channel_state(chan));
        return RESULT_SUCCESS;
    } else if (argc == 3) {
        struct ast_channel_snapshot *snapshot;
 
        /* one argument: look for info on the specified channel */
        snapshot = ast_channel_snapshot_get_latest_by_name(argv[2]);
        if (snapshot) {
            ast_agi_send(agi->fd, chan, "200 result=%u\n", snapshot->state);
            ao2_ref(snapshot, -1);
            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;
    }
}

References ao2_ref, ast_agi_send(), ast_channel_snapshot_get_latest_by_name(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and ast_channel_snapshot::state.

handle_cli_agi_add_cmd()

static char * handle_cli_agi_add_cmd ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

CLI command to add applications to execute in Async AGI.

Parameters

e
cmd
a

Return values

CLI_SUCCESS	on success
NULL	when init or tab completion is used

Definition at line 1783 of file res_agi.c.

{
    struct ast_channel *chan;
    switch (cmd) {
    case CLI_INIT:
        e->command = "agi exec";
        e->usage = "Usage: agi exec <channel name> <app and arguments> [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;
    }
 
    if (!(chan = ast_channel_get_by_name(a->argv[2]))) {
        ast_cli(a->fd, "Channel %s does not exist.\n", a->argv[2]);
        return CLI_FAILURE;
    }
 
    ast_channel_lock(chan);
 
    if (add_agi_cmd(chan, a->argv[3], (a->argc > 4 ? a->argv[4] : ""))) {
        ast_cli(a->fd, "Failed to add AGI command to queue of channel %s\n", ast_channel_name(chan));
        ast_channel_unlock(chan);
        chan = ast_channel_unref(chan);
        return CLI_FAILURE;
    }
 
    ast_debug(1, "Added AGI command to channel %s queue\n", ast_channel_name(chan));
 
    ast_channel_unlock(chan);
    chan = ast_channel_unref(chan);
 
    return CLI_SUCCESS;
}

References a, add_agi_cmd(), ast_channel_get_by_name(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_channel_unref, ast_cli(), ast_complete_channels(), ast_debug, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_cli_agi_debug()

static char * handle_cli_agi_debug ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 3530 of file res_agi.c.

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

References a, agidebug, ast_cli_entry::args, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

handle_cli_agi_dump_html()

static char * handle_cli_agi_dump_html ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 4641 of file res_agi.c.

{
    switch (cmd) {
    case CLI_INIT:
        e->command = "agi dump html";
        e->usage =
            "Usage: agi dump html <filename>\n"
            "       Dumps the AGI command list in HTML format to the given\n"
            "       file.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc != e->args + 1)
        return CLI_SHOWUSAGE;
 
    if (write_htmldump(a->argv[e->args]) < 0) {
        ast_cli(a->fd, "Could not create file '%s'\n", a->argv[e->args]);
        return CLI_SHOWUSAGE;
    }
    ast_cli(a->fd, "AGI HTML commands dumped to: %s\n", a->argv[e->args]);
    return CLI_SUCCESS;
}

References a, ast_cli_entry::args, ast_cli(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, ast_cli_entry::usage, and write_htmldump().

handle_cli_agi_show()

static char * handle_cli_agi_show ( struct ast_cli_entry *  e, int  cmd, struct ast_cli_args *  a  )

static

Definition at line 4461 of file res_agi.c.

{
    struct agi_command *command;
    char fullcmd[MAX_CMD_LEN];
    int error = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "agi show commands [topic]";
        e->usage =
            "Usage: agi show commands [topic] <topic>\n"
            "       When called with a topic as an argument, displays usage\n"
            "       information on the given command.  If called without a\n"
            "       topic, it provides a list of AGI commands.\n";
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc < e->args - 1 || (a->argc >= e->args && strcasecmp(a->argv[e->args - 1], "topic")))
        return CLI_SHOWUSAGE;
    if (a->argc > e->args - 1) {
        command = find_command(a->argv + e->args, 1);
        if (command) {
            char *synopsis = NULL, *since = NULL, *description = NULL, *syntax = NULL, *arguments = NULL, *seealso = NULL;
 
            ast_join(fullcmd, sizeof(fullcmd), a->argv + e->args);
 
#ifdef AST_XML_DOCS
            if (command->docsrc == AST_XML_DOC) {
                synopsis = ast_xmldoc_printable(S_OR(command->summary, "Not available"), 1);
                since = ast_xmldoc_printable(S_OR(command->since, "Not available"), 1);
                description = ast_xmldoc_printable(S_OR(command->usage, "Not available"), 1);
                syntax = ast_xmldoc_printable(S_OR(command->syntax, "Not available"), 1);
                arguments = ast_xmldoc_printable(S_OR(command->arguments, "Not available"), 1);
                seealso = ast_xmldoc_printable(S_OR(command->seealso, "Not available"), 1);
            } else
#endif
            {
                synopsis = ast_strdup(S_OR(command->summary, "Not Available"));
                since = ast_strdup(S_OR(command->since, "Not Available"));
                description = ast_strdup(S_OR(command->usage, "Not Available"));
                syntax = ast_strdup(S_OR(command->syntax, "Not Available"));
                arguments = ast_strdup(S_OR(command->arguments, "Not Available"));
                seealso = ast_strdup(S_OR(command->seealso, "Not Available"));
            }
 
            if (!synopsis || !since || !description || !syntax || !arguments || !seealso) {
                error = 1;
                goto return_cleanup;
            }
 
            ast_cli(a->fd, "\n"
                "%s  -= Info about AGI '%s' =- %s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n"
                COLORIZE_FMT "\n"
                "%s\n\n",
                ast_term_color(COLOR_MAGENTA, 0), fullcmd, ast_term_reset(),
                COLORIZE(COLOR_MAGENTA, 0, "[Synopsis]"), synopsis,
                COLORIZE(COLOR_MAGENTA, 0, "[Since]"), since,
                COLORIZE(COLOR_MAGENTA, 0, "[Description]"), description,
                COLORIZE(COLOR_MAGENTA, 0, "[Syntax]"), syntax,
                COLORIZE(COLOR_MAGENTA, 0, "[Arguments]"), arguments,
                COLORIZE(COLOR_MAGENTA, 0, "[Runs Dead]"), command->dead ? "Yes" : "No",
                COLORIZE(COLOR_MAGENTA, 0, "[See Also]"), seealso
                );
 
return_cleanup:
            ast_free(synopsis);
            ast_free(since);
            ast_free(description);
            ast_free(syntax);
            ast_free(arguments);
            ast_free(seealso);
        } else {
            if (find_command(a->argv + e->args, -1)) {
                return help_workhorse(a->fd, a->argv + e->args);
            } else {
                ast_join(fullcmd, sizeof(fullcmd), a->argv + e->args);
                ast_cli(a->fd, "No such command '%s'.\n", fullcmd);
            }
        }
    } else {
        return help_workhorse(a->fd, NULL);
    }
    return (error ? CLI_FAILURE : CLI_SUCCESS);
}

References a, ast_cli_entry::args, agi_command::arguments, ast_cli(), ast_free, ast_join, ast_strdup, ast_term_color(), ast_term_reset(), AST_XML_DOC, ast_xmldoc_printable(), CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, COLOR_MAGENTA, COLORIZE, COLORIZE_FMT, ast_cli_entry::command, agi_command::dead, agi_command::docsrc, error(), find_command(), help_workhorse(), MAX_CMD_LEN, NULL, S_OR, agi_command::seealso, agi_command::since, agi_command::summary, synopsis, agi_command::syntax, agi_command::usage, and ast_cli_entry::usage.

handle_connection()

static int handle_connection ( const char *  agiurl, const struct ast_sockaddr  addr, const int  netsockfd  )

static

Definition at line 2138 of file res_agi.c.

{
    struct pollfd pfds[1];
    int res, conresult;
    socklen_t reslen;
 
    reslen = sizeof(conresult);
 
    pfds[0].fd = netsockfd;
    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));
            }
 
            return 1;
        }
    }
 
    if (getsockopt(pfds[0].fd, SOL_SOCKET, SO_ERROR, &conresult, &reslen) < 0) {
        ast_log(LOG_WARNING, "Connection to %s failed with error: %s\n",
            ast_sockaddr_stringify(&addr), strerror(errno));
        return 1;
    }
 
    if (conresult) {
        ast_log(LOG_WARNING, "Connecting to '%s' failed for url '%s': %s\n",
            ast_sockaddr_stringify(&addr), agiurl, strerror(conresult));
        return 1;
    }
 
    return 0;
}

References ast_log, ast_poll, ast_sockaddr_stringify(), errno, LOG_WARNING, and MAX_AGI_CONNECT.

Referenced by launch_netscript().

handle_controlstreamfile()

static int handle_controlstreamfile ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2626 of file res_agi.c.

{
    int res = 0, skipms = 3000;
    const char *fwd = "#", *rev = "*", *suspend = NULL, *stop = NULL;   /* Default values */
    char stopkeybuf[2];
    long offsetms = 0;
    char offsetbuf[20];
 
    if (argc < 5 || argc > 10) {
        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];
    }
 
    if (argc > 9 && (sscanf(argv[9], "%30ld", &offsetms) != 1)) {
        return RESULT_SHOWUSAGE;
    }
 
    res = ast_control_streamfile(chan, argv[3], fwd, rev, stop, suspend, NULL, skipms, &offsetms);
 
    /* If we stopped on one of our stop keys, return 0  */
    if (res > 0 && stop && strchr(stop, res)) {
        pbx_builtin_setvar_helper(chan, "CPLAYBACKSTATUS", "USERSTOPPED");
        snprintf(stopkeybuf, sizeof(stopkeybuf), "%c", res);
        pbx_builtin_setvar_helper(chan, "CPLAYBACKSTOPKEY", stopkeybuf);
    } else if (res > 0 && res == AST_CONTROL_STREAM_STOP) {
        pbx_builtin_setvar_helper(chan, "CPLAYBACKSTATUS", "REMOTESTOPPED");
        res = 0;
    } else {
        if (res < 0) {
            pbx_builtin_setvar_helper(chan, "CPLAYBACKSTATUS", "ERROR");
        } else {
            pbx_builtin_setvar_helper(chan, "CPLAYBACKSTATUS", "SUCCESS");
        }
    }
 
    snprintf(offsetbuf, sizeof(offsetbuf), "%ld", offsetms);
    pbx_builtin_setvar_helper(chan, "CPLAYBACKOFFSET", offsetbuf);
 
    ast_agi_send(agi->fd, chan, "200 result=%d endpos=%ld\n", res, offsetms);
 
    return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ast_agi_send(), AST_CONTROL_STREAM_STOP, ast_control_streamfile(), ast_strlen_zero(), agi_state::fd, NULL, pbx_builtin_setvar_helper(), RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, skipms, stop, and suspend().

handle_dbdel()

static int handle_dbdel ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3502 of file res_agi.c.

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

References ast_agi_send(), ast_db_del(), agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_dbdeltree()

static int handle_dbdeltree ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3513 of file res_agi.c.

{
    int num_deleted;
 
    if ((argc < 3) || (argc > 4)) {
        return RESULT_SHOWUSAGE;
    }
    if (argc == 4) {
        num_deleted = ast_db_deltree(argv[2], argv[3]);
    } else {
        num_deleted = ast_db_deltree(argv[2], NULL);
    }
 
    ast_agi_send(agi->fd, chan, "200 result=%c\n", num_deleted > 0 ? '0' : '1');
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_db_deltree(), agi_state::fd, NULL, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_dbget()

static int handle_dbget ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3458 of file res_agi.c.

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

References ast_agi_send(), ast_db_get(), ast_free, ast_str_buffer(), ast_str_create, ast_str_make_space, ast_str_size(), ast_str_strlen(), ast_str_update(), buf, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_dbput()

static int handle_dbput ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3491 of file res_agi.c.

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

References ast_agi_send(), ast_db_put(), agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_exec()

static int handle_exec ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3280 of file res_agi.c.

{
    int res, workaround;
    struct ast_app *app_to_exec;
    const char *agi_exec_full_str;
    int agi_exec_full;
    struct ast_str *data_with_var = NULL;
 
    if (argc < 2)
        return RESULT_SHOWUSAGE;
 
    ast_verb(3, "AGI Script Executing Application: (%s) Options: (%s)\n", argv[1], argc >= 3 ? argv[2] : "");
 
    if ((app_to_exec = pbx_findapp(argv[1]))) {
        ast_channel_lock(chan);
        if (!(workaround = ast_test_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_WORKAROUNDS))) {
            ast_set_flag(ast_channel_flags(chan), AST_FLAG_DISABLE_WORKAROUNDS);
        }
        agi_exec_full_str = pbx_builtin_getvar_helper(chan, "AGIEXECFULL");
        agi_exec_full = ast_true(agi_exec_full_str);
        ast_channel_unlock(chan);
 
        if (agi_exec_full) {
            if ((data_with_var = ast_str_create(16))) {
                ast_str_substitute_variables(&data_with_var, 0, chan, argv[2]);
                res = pbx_exec(chan, app_to_exec, argc == 2 ? "" : ast_str_buffer(data_with_var));
                ast_free(data_with_var);
            } else {
                res = -2;
            }
        } else {
            res = pbx_exec(chan, app_to_exec, argc == 2 ? "" : argv[2]);
        }
        if (!workaround) {
            ast_channel_clear_flag(chan, AST_FLAG_DISABLE_WORKAROUNDS);
        }
    } 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;
}

References agi_exec_full(), ast_agi_send(), ast_channel_clear_flag(), ast_channel_flags(), ast_channel_lock, ast_channel_unlock, AST_FLAG_DISABLE_WORKAROUNDS, ast_free, ast_log, ast_set_flag, ast_str_buffer(), ast_str_create, ast_str_substitute_variables(), ast_test_flag, ast_true(), ast_verb, agi_state::fd, LOG_WARNING, NULL, pbx_builtin_getvar_helper(), pbx_exec(), pbx_findapp(), and RESULT_SHOWUSAGE.

handle_getdata()

static int handle_getdata ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2965 of file res_agi.c.

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

References ast_agi_send(), ast_app_getdata_full(), agi_state::audio, agi_state::ctrl, agi_state::fd, max, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_getoption()

static int handle_getoption ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

get option - really similar to the handle_streamfile, but with a timeout

Definition at line 2747 of file res_agi.c.

{
    int res;
    struct ast_filestream *fs, *vfs;
    long sample_offset = 0, max_length;
    int timeout = 0;
    const 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 (ast_channel_pbx(chan)->dtimeoutms) {
        /* by default dtimeout is set to 5sec */
        timeout = ast_channel_pbx(chan)->dtimeoutms; /* in msec */
    }
 
    if (!(fs = ast_openstream(chan, argv[2], ast_channel_language(chan)))) {
        ast_agi_send(agi->fd, chan, "200 result=-1 endpos=%ld\n", sample_offset);
        ast_log(LOG_WARNING, "Unable to open %s\n", argv[2]);
        return RESULT_FAILURE;
    }
 
    if ((vfs = ast_openvstream(chan, argv[2], ast_channel_language(chan))))
        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)
        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 = (ast_channel_stream(chan))?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, NULL, 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;
}

References ast_agi_send(), ast_applystream(), ast_channel_language(), ast_channel_pbx(), ast_channel_stream(), ast_debug, ast_log, ast_openstream(), ast_openvstream(), ast_playstream(), ast_seekstream(), ast_stopstream(), ast_tellstream(), ast_verb, ast_waitfordigit_full(), ast_waitstream_full(), agi_state::audio, agi_state::ctrl, ast_pbx::dtimeoutms, agi_state::fd, LOG_WARNING, NULL, RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, and ast_filestream::vfs.

handle_getvariable()

static int handle_getvariable ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3384 of file res_agi.c.

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

References ast_agi_send(), ast_func_read(), ast_strlen_zero(), agi_state::fd, NULL, pbx_retrieve_variable(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_getvariablefull()

static int handle_getvariablefull ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3407 of file res_agi.c.

{
    struct ast_channel *chan2 = NULL;
 
    if (argc != 4 && argc != 5) {
        return RESULT_SHOWUSAGE;
    }
 
    if (argc == 5) {
        chan2 = ast_channel_get_by_name(argv[4]);
    } else {
        chan2 = ast_channel_ref(chan);
    }
 
    if (chan2) {
        struct ast_str *str = ast_str_create(16);
        if (!str) {
            ast_agi_send(agi->fd, chan, "200 result=0\n");
            return RESULT_SUCCESS;
        }
        ast_str_substitute_variables(&str, 0, chan2, argv[3]);
        ast_agi_send(agi->fd, chan, "200 result=1 (%s)\n", ast_str_buffer(str));
        ast_free(str);
    } else {
        ast_agi_send(agi->fd, chan, "200 result=0\n");
    }
 
    if (chan2) {
        chan2 = ast_channel_unref(chan2);
    }
 
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_get_by_name(), ast_channel_ref, ast_channel_unref, ast_free, ast_str_buffer(), ast_str_create, ast_str_substitute_variables(), agi_state::fd, NULL, RESULT_SHOWUSAGE, RESULT_SUCCESS, and str.

handle_hangup()

static int handle_hangup ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3252 of file res_agi.c.

{
    struct ast_channel *c;
 
    if (argc == 1) {
        /* no argument: hangup the current channel */
        ast_set_hangupsource(chan, "dialplan/agi", 0);
        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 */
        if ((c = ast_channel_get_by_name(argv[1]))) {
            /* we have a matching channel */
            ast_set_hangupsource(c, "dialplan/agi", 0);
            ast_softhangup(c, AST_SOFTHANGUP_EXPLICIT);
            c = ast_channel_unref(c);
            ast_agi_send(agi->fd, chan, "200 result=1\n");
            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;
    }
}

References ast_agi_send(), ast_channel_get_by_name(), ast_channel_unref, ast_set_hangupsource(), ast_softhangup(), AST_SOFTHANGUP_EXPLICIT, c, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_noop()

static int handle_noop ( struct ast_channel *  chan, AGI *  agi, int  arg, const char *const  argv[]  )

static

Definition at line 3559 of file res_agi.c.

{
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return RESULT_SUCCESS;
}

References ast_agi_send(), agi_state::fd, and RESULT_SUCCESS.

handle_recordfile()

static int handle_recordfile ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3030 of file res_agi.c.

{
    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;
    RAII_VAR(struct ast_format *, rfmt, NULL, ao2_cleanup);
    struct ast_silence_generator *silgen = NULL;
 
    /* 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 = ao2_bump(ast_channel_readformat(chan));
        res = ast_set_read_format(chan, ast_format_slin);
        if (res < 0) {
            ast_log(LOG_WARNING, "Unable to set to linear mode, giving up\n");
            ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
            return RESULT_FAILURE;
        }
        sildet = ast_dsp_new();
        if (!sildet) {
            ast_log(LOG_WARNING, "Unable to create silence detector :(\n");
            ast_agi_send(agi->fd, chan, "200 result=-1\n");
            return RESULT_FAILURE;
        }
        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.
     *
     * In other words, if the argument does not look like the offset_samples
     * argument (a number) and it doesn't look like the silence argument (starts
     * with "s=") then it must be the beep argument. The beep argument has no
     * required value, the presence of anything in the argument slot we are
     * inspecting is an indication that the user wants a beep played.
     */
    if ((argc > 6 && sscanf(argv[6], "%30ld", &sample_offset) != 1 && !ast_begins_with(argv[6], "s="))
       || (argc > 7 && !ast_begins_with(argv[7], "s="))) {
        res = ast_streamfile(chan, "beep", ast_channel_language(chan));
    }
 
    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);
 
        ast_channel_stream_set(chan, fs);
        ast_applystream(chan,fs);
        /* really should have checks */
        ast_seekstream(fs, sample_offset, SEEK_SET);
        ast_truncstream(fs);
 
        if (ast_opt_transmit_silence) {
            silgen = ast_channel_start_silence_generator(chan);
        }
 
        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);
                if (silgen)
                    ast_channel_stop_silence_generator(chan, silgen);
                return RESULT_FAILURE;
            }
            f = ast_read(chan);
            if (!f) {
                ast_closestream(fs);
                ast_agi_send(agi->fd, chan, "200 result=%d (hangup) endpos=%ld\n", -1, sample_offset);
                if (sildet)
                    ast_dsp_free(sildet);
                if (silgen)
                    ast_channel_stop_silence_generator(chan, silgen);
                return RESULT_FAILURE;
            }
            switch(f->frametype) {
            case AST_FRAME_DTMF:
                if (strchr(argv[4], f->subclass.integer)) {
                    /* This is an interrupting character, 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_closestream(fs);
                    ast_agi_send(agi->fd, chan, "200 result=%d (dtmf) endpos=%ld\n", f->subclass.integer, sample_offset);
                    ast_frfree(f);
                    if (sildet)
                        ast_dsp_free(sildet);
                    if (silgen)
                        ast_channel_stop_silence_generator(chan, silgen);
                    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_closestream(fs);
        ast_agi_send(agi->fd, chan, "200 result=%d (timeout) endpos=%ld\n", res, sample_offset);
    }
 
    if (silence > 0) {
        res = ast_set_read_format(chan, rfmt);
        if (res)
            ast_log(LOG_WARNING, "Unable to restore read format on '%s'\n", ast_channel_name(chan));
        ast_dsp_free(sildet);
    }
 
    if (silgen) {
        ast_channel_stop_silence_generator(chan, silgen);
    }
 
    return RESULT_SUCCESS;
}

References ao2_bump, ao2_cleanup, ast_agi_send(), ast_applystream(), ast_begins_with(), ast_channel_language(), ast_channel_name(), ast_channel_readformat(), ast_channel_start_silence_generator(), ast_channel_stop_silence_generator(), ast_channel_stream_set(), ast_closestream(), AST_CONTROL_VIDUPDATE, ast_dsp_free(), ast_dsp_get_threshold_from_settings(), ast_dsp_new(), ast_dsp_set_threshold(), ast_dsp_silence(), AST_FILE_MODE, ast_format_slin, AST_FRAME_DTMF, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_frfree, ast_indicate(), ast_log, ast_opt_transmit_silence, ast_read(), ast_seekstream(), ast_set_read_format(), ast_stream_rewind(), ast_streamfile(), ast_tellstream(), ast_truncstream(), ast_tvdiff_ms(), ast_tvnow(), ast_waitfor(), ast_waitstream(), ast_writefile(), ast_writestream(), agi_state::fd, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, NULL, RAII_VAR, RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, ast_frame::subclass, THRESHOLD_SILENCE, and ast_dsp::totalsilence.

handle_recvchar()

static int handle_recvchar ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2545 of file res_agi.c.

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

References ast_agi_send(), ast_recvchar(), agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_recvtext()

static int handle_recvtext ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2565 of file res_agi.c.

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

References ast_agi_send(), ast_free, ast_recvtext(), buf, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_sayalpha()

static int handle_sayalpha ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2847 of file res_agi.c.

{
    int res;
    int sensitivity = AST_SAY_CASE_NONE;
 
    if (argc < 4 || argc > 5) {
        return RESULT_SHOWUSAGE;
    }
 
    if (argc > 4) {
        switch (argv[4][0]) {
        case 'a':
        case 'A':
            sensitivity = AST_SAY_CASE_ALL;
            break;
        case 'l':
        case 'L':
            sensitivity = AST_SAY_CASE_LOWER;
            break;
        case 'n':
        case 'N':
            sensitivity = AST_SAY_CASE_NONE;
            break;
        case 'u':
        case 'U':
            sensitivity = AST_SAY_CASE_UPPER;
            break;
        case '\0':
            break;
        default:
            return RESULT_SHOWUSAGE;
        }
    }
    res = ast_say_character_str_full(chan, argv[2], argv[3], ast_channel_language(chan), sensitivity, 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;
}

References ast_agi_send(), ast_channel_language(), AST_SAY_CASE_ALL, AST_SAY_CASE_LOWER, AST_SAY_CASE_NONE, AST_SAY_CASE_UPPER, ast_say_character_str_full, agi_state::audio, agi_state::ctrl, agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_saydate()

static int handle_saydate ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2887 of file res_agi.c.

{
    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], ast_channel_language(chan));
    if (res == 1)
        return RESULT_SUCCESS;
    ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
    return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ast_agi_send(), ast_channel_language(), ast_say_date, agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_saydatetime()

static int handle_saydatetime ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2917 of file res_agi.c.

{
    int res = 0;
    time_t unixtime;
    const 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(ast_channel_language(chan), "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], ast_channel_language(chan), 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;
}

References ast_agi_send(), ast_channel_language(), ast_get_time_t(), ast_say_date_with_format, ast_strlen_zero(), agi_state::fd, NULL, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_saydigits()

static int handle_saydigits ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2831 of file res_agi.c.

{
    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], ast_channel_language(chan), 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;
}

References ast_agi_send(), ast_channel_language(), ast_say_digit_str_full, agi_state::audio, agi_state::ctrl, agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_saynumber()

static int handle_saynumber ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Say number in various language syntaxes.

Definition at line 2816 of file res_agi.c.

{
    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], ast_channel_language(chan), 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;
}

References ast_agi_send(), ast_channel_language(), ast_say_number_full, agi_state::audio, agi_state::ctrl, agi_state::fd, NULL, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_sayphonetic()

static int handle_sayphonetic ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2951 of file res_agi.c.

{
    int res;
 
    if (argc != 4)
        return RESULT_SHOWUSAGE;
 
    res = ast_say_phonetic_str_full(chan, argv[2], argv[3], ast_channel_language(chan), 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;
}

References ast_agi_send(), ast_channel_language(), ast_say_phonetic_str_full, agi_state::audio, agi_state::ctrl, agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_saytime()

static int handle_saytime ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2902 of file res_agi.c.

{
    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], ast_channel_language(chan));
    if (res == 1)
        return RESULT_SUCCESS;
    ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
    return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ast_agi_send(), ast_channel_language(), ast_say_time, agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_sendimage()

static int handle_sendimage ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2610 of file res_agi.c.

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

References ast_agi_send(), ast_check_hangup(), ast_send_image(), agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_sendtext()

static int handle_sendtext ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2526 of file res_agi.c.

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

References ast_agi_send(), ast_sendtext(), agi_state::fd, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_setcallerid()

static int handle_setcallerid ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3326 of file res_agi.c.

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

References ast_agi_send(), ast_callerid_parse(), ast_copy_string(), ast_set_callerid(), ast_shrink_phone_number(), agi_state::fd, NULL, and RESULT_SUCCESS.

handle_setcontext()

static int handle_setcontext ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2992 of file res_agi.c.

{
 
    if (argc != 3)
        return RESULT_SHOWUSAGE;
    ast_channel_context_set(chan, argv[2]);
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_context_set(), agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_setextension()

static int handle_setextension ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3002 of file res_agi.c.

{
    if (argc != 3)
        return RESULT_SHOWUSAGE;
    ast_channel_exten_set(chan, argv[2]);
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_exten_set(), agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_setmusic()

static int handle_setmusic ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3565 of file res_agi.c.

{
    if (argc < 3) {
        return RESULT_SHOWUSAGE;
    }
    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;
}

References ast_agi_send(), ast_moh_start(), ast_moh_stop(), agi_state::fd, NULL, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_setpriority()

static int handle_setpriority ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3011 of file res_agi.c.

{
    int pri;
 
    if (argc != 3)
        return RESULT_SHOWUSAGE;
 
    if (sscanf(argv[2], "%30d", &pri) != 1) {
        pri = ast_findlabel_extension(chan, ast_channel_context(chan), ast_channel_exten(chan), argv[2],
            S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, NULL));
        if (pri < 1)
            return RESULT_SHOWUSAGE;
    }
 
    ast_explicit_goto(chan, NULL, NULL, pri);
    ast_agi_send(agi->fd, chan, "200 result=0\n");
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_caller(), ast_channel_context(), ast_channel_exten(), ast_explicit_goto(), ast_findlabel_extension(), agi_state::fd, NULL, RESULT_SHOWUSAGE, RESULT_SUCCESS, and S_COR.

handle_setvariable()

static int handle_setvariable ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3371 of file res_agi.c.

{
    if (argc != 4) {
        return RESULT_SHOWUSAGE;
    }
 
    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;
}

References ast_agi_send(), agi_state::fd, pbx_builtin_setvar_helper(), RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_speechactivategrammar()

static int handle_speechactivategrammar ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3669 of file res_agi.c.

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

References ast_agi_send(), ast_speech_grammar_activate(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and agi_state::speech.

handle_speechcreate()

static int handle_speechcreate ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3578 of file res_agi.c.

{
    struct ast_format_cap *cap;
 
    /* 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 (!(cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
        return RESULT_FAILURE;
    }
    ast_format_cap_append(cap, ast_format_slin, 0);
    if ((agi->speech = ast_speech_new(argv[2], cap))) {
        ast_agi_send(agi->fd, chan, "200 result=1\n");
    } else {
        ast_agi_send(agi->fd, chan, "200 result=0\n");
    }
    ao2_ref(cap, -1);
 
    return RESULT_SUCCESS;
}

References ao2_ref, ast_agi_send(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_speech_new(), agi_state::fd, RESULT_FAILURE, RESULT_SUCCESS, and agi_state::speech.

handle_speechdeactivategrammar()

static int handle_speechdeactivategrammar ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3687 of file res_agi.c.

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

References ast_agi_send(), ast_speech_grammar_deactivate(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and agi_state::speech.

handle_speechdestroy()

static int handle_speechdestroy ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3620 of file res_agi.c.

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

References ast_agi_send(), ast_speech_destroy(), agi_state::fd, NULL, RESULT_SUCCESS, and agi_state::speech.

handle_speechloadgrammar()

static int handle_speechloadgrammar ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3633 of file res_agi.c.

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

References ast_agi_send(), ast_speech_grammar_load(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and agi_state::speech.

handle_speechrecognize()

static int handle_speechrecognize ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3724 of file res_agi.c.

{
    struct ast_speech *speech = agi->speech;
    const char *prompt;
    char dtmf = 0, tmp[4096] = "", *buf = tmp;
    int timeout = 0, offset = 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 */
    if (ast_set_read_format(chan, ast_format_slin)) {
        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, ast_channel_language(chan), 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(ast_channel_sched(chan));
 
        /* See maximum time of waiting */
        if ((res = ast_sched_wait(ast_channel_sched(chan))) < 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(&current);
            if ((current - start) >= timeout) {
                reason = "timeout";
                if (fr) {
                    ast_frfree(fr);
                    fr = NULL;
                }
                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) && ast_channel_stream(chan)) {
            current_offset = ast_tellstream(ast_channel_stream(chan));
            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) && start == 0 && ((!ast_channel_stream(chan)) || (ast_channel_streamid(chan) == -1 && ast_channel_timingfunc(chan) == 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 ((!ast_channel_stream(chan)) || (ast_channel_streamid(chan) == -1 && ast_channel_timingfunc(chan) == 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, ast_channel_language(chan), 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.integer;
            } else if (fr->frametype == AST_FRAME_CONTROL && fr->subclass.integer == AST_CONTROL_HANGUP) {
                reason = "hangup";
            }
            ast_frfree(fr);
            fr = NULL;
        }
    }
 
    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;
}

References ast_agi_send(), ast_build_string(), ast_channel_language(), ast_channel_sched(), ast_channel_stream(), ast_channel_streamid(), ast_channel_timingfunc(), ast_clear_flag, AST_CONTROL_HANGUP, ast_format_slin, AST_FRAME_CONTROL, AST_FRAME_DTMF, AST_FRAME_VOICE, ast_frfree, AST_LIST_NEXT, ast_mutex_lock, ast_mutex_unlock, ast_read(), ast_sched_runq(), ast_sched_wait(), ast_set_read_format(), ast_speech_change_state(), AST_SPEECH_QUIET, ast_speech_results_get(), ast_speech_start(), AST_SPEECH_STATE_DONE, AST_SPEECH_STATE_NOT_READY, AST_SPEECH_STATE_READY, AST_SPEECH_STATE_WAIT, ast_speech_write(), ast_stopstream(), ast_strlen_zero(), ast_tellstream(), ast_test_flag, ast_waitfor(), buf, current, ast_frame::data, ast_frame::datalen, agi_state::fd, ast_frame::frametype, ast_frame_subclass::integer, ast_speech::lock, NULL, ast_speech::processing_sound, prompt, ast_frame::ptr, result, RESULT_SHOWUSAGE, RESULT_SUCCESS, ast_speech::results, agi_state::speech, speech_streamfile(), ast_speech::state, and ast_frame::subclass.

handle_speechset()

static int handle_speechset ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3602 of file res_agi.c.

{
    /* Check for minimum arguments */
    if (argc != 4)
        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;
}

References ast_agi_send(), ast_speech_change(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and agi_state::speech.

handle_speechunloadgrammar()

static int handle_speechunloadgrammar ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3651 of file res_agi.c.

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

References ast_agi_send(), ast_speech_grammar_unload(), agi_state::fd, RESULT_SHOWUSAGE, RESULT_SUCCESS, and agi_state::speech.

handle_streamfile()

static int handle_streamfile ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2688 of file res_agi.c.

{
    int res;
    struct ast_filestream *fs, *vfs;
    long sample_offset = 0, max_length;
    const 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], ast_channel_language(chan)))) {
        ast_agi_send(agi->fd, chan, "200 result=-1 endpos=%ld\n", sample_offset);
        return RESULT_FAILURE;
    }
 
    if ((vfs = ast_openvstream(chan, argv[2], ast_channel_language(chan)))) {
        ast_debug(1, "Ooh, found a video stream, too\n");
    }
    ast_verb(3, "<%s> Playing '%s.%s' (escape_digits=%s) (sample_offset %ld) (language '%s')\n",
        ast_channel_name(chan), argv[2], ast_format_get_name(ast_channel_writeformat(chan)),
        edigits, sample_offset, S_OR(ast_channel_language(chan), "default"));
 
    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) {
        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 = (ast_channel_stream(chan)) ? 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);
    pbx_builtin_setvar_helper(chan, "PLAYBACKSTATUS", res ? "FAILED" : "SUCCESS");
 
    return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ast_agi_send(), ast_applystream(), ast_channel_language(), ast_channel_name(), ast_channel_stream(), ast_channel_writeformat(), ast_debug, ast_format_get_name(), ast_openstream(), ast_openvstream(), ast_playstream(), ast_seekstream(), ast_stopstream(), ast_tellstream(), ast_verb, ast_waitstream_full(), agi_state::audio, agi_state::ctrl, agi_state::fd, pbx_builtin_setvar_helper(), RESULT_FAILURE, RESULT_SHOWUSAGE, RESULT_SUCCESS, S_OR, and ast_filestream::vfs.

handle_tddmode()

static int handle_tddmode ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2582 of file res_agi.c.

{
    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) {
        /* Set channel option failed */
        ast_agi_send(agi->fd, chan, "200 result=0\n");
    } else {
        ast_agi_send(agi->fd, chan, "200 result=1\n");
    }
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_setoption(), AST_OPTION_TDD, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_verbose()

static int handle_verbose ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 3441 of file res_agi.c.

{
    int level = 0;
 
    if (argc < 2)
        return RESULT_SHOWUSAGE;
 
    if (argv[2])
        sscanf(argv[2], "%30d", &level);
 
    ast_verb(level, "%s: %s\n", ast_channel_data(chan), argv[1]);
 
    ast_agi_send(agi->fd, chan, "200 result=1\n");
 
    return RESULT_SUCCESS;
}

References ast_agi_send(), ast_channel_data(), ast_verb, agi_state::fd, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

handle_waitfordigit()

static int handle_waitfordigit ( struct ast_channel *  chan, AGI *  agi, int  argc, const char *const  argv[]  )

static

Definition at line 2513 of file res_agi.c.

{
    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, NULL, agi->audio, agi->ctrl);
    ast_agi_send(agi->fd, chan, "200 result=%d\n", res);
    return (res >= 0) ? RESULT_SUCCESS : RESULT_FAILURE;
}

References ast_agi_send(), ast_waitfordigit_full(), agi_state::audio, agi_state::ctrl, agi_state::fd, NULL, RESULT_FAILURE, RESULT_SHOWUSAGE, and RESULT_SUCCESS.

help_workhorse()

static char * help_workhorse ( int  fd, const char *const  match[]  )

static

Definition at line 3928 of file res_agi.c.

{
    char fullcmd[MAX_CMD_LEN], matchstr[MAX_CMD_LEN];
    struct agi_command *e;
 
    if (match)
        ast_join(matchstr, sizeof(matchstr), match);
 
    ast_cli(fd, "%5.5s %30.30s   %s\n","Dead","Command","Description");
    AST_RWLIST_RDLOCK(&agi_commands);
    AST_RWLIST_TRAVERSE(&agi_commands, e, list) {
        if (!e->cmda[0])
            break;
        /* Hide commands that start with '_' */
        if ((e->cmda[0])[0] == '_')
            continue;
        ast_join(fullcmd, sizeof(fullcmd), e->cmda);
        if (match && strncasecmp(matchstr, fullcmd, strlen(matchstr)))
            continue;
        ast_cli(fd, "%5.5s %30.30s   %s\n", e->dead ? "Yes" : "No" , fullcmd, S_OR(e->summary, "Not available"));
    }
    AST_RWLIST_UNLOCK(&agi_commands);
 
    return CLI_SUCCESS;
}

References ast_cli(), ast_join, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, CLI_SUCCESS, agi_command::cmda, agi_command::dead, agi_command::list, match(), MAX_CMD_LEN, S_OR, and agi_command::summary.

Referenced by handle_cli_agi_show().

launch_asyncagi()

static enum agi_result launch_asyncagi ( struct ast_channel *  chan, int  argc, char *  argv[], int *  efd  )

static

Definition at line 1913 of file res_agi.c.

{
/* 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
    enum agi_result cmd_status;
    struct agi_cmd *cmd;
    int res;
    int fds[2];
    int hungup;
    int timeout = 100;
    char agi_buffer[AGI_BUF_SIZE + 1];
    char ami_buffer[AMI_BUF_SIZE];
    enum agi_result returnstatus = AGI_RESULT_SUCCESS;
    AGI async_agi;
    RAII_VAR(struct ast_json *, startblob, NULL, ast_json_unref);
 
    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", ast_channel_name(chan));
        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 the datastore added with
         * add_to_agi() the from channel.  It will be removed when the
         * channel is hung up anyway.
         */
        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;
    async_agi.speech = NULL;
 
    /* notify possible manager users of a new channel ready to
       receive commands */
    setup_env(chan, "async", fds[1], 0, argc, argv);
    /* read the environment */
    res = read(fds[0], agi_buffer, AGI_BUF_SIZE);
    if (res <= 0) {
        ast_log(LOG_ERROR, "Failed to read from Async AGI pipe on channel %s: %s\n",
                ast_channel_name(chan), res < 0 ? strerror(errno) : "EOF");
        returnstatus = AGI_RESULT_FAILURE;
        goto async_agi_abort;
    }
    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, ast_uri_http);
    startblob = ast_json_pack("{s: s}", "Env", ami_buffer);
 
    ast_channel_publish_cached_blob(chan, agi_async_start_type(), startblob);
 
    hungup = ast_check_hangup_locked(chan);
 
    for (;;) {
        /*
         * Process as many commands as we can.  Commands are added via
         * the manager or the cli threads.
         */
        while (!hungup) {
            RAII_VAR(struct ast_json *, execblob, NULL, ast_json_unref);
            res = get_agi_cmd(chan, &cmd);
 
            if (res) {
                returnstatus = AGI_RESULT_FAILURE;
                goto async_agi_done;
            } else if (!cmd) {
                break;
            }
 
            /* OK, we have a command, let's call the command handler. */
            cmd_status = agi_handle_command(chan, &async_agi, cmd->cmd_buffer, 0);
 
            /*
             * 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 <= 0) {
                ast_log(LOG_ERROR, "Failed to read from Async AGI pipe on channel %s: %s\n",
                    ast_channel_name(chan), res < 0 ? strerror(errno) : "EOF");
                free_agi_cmd(cmd);
                returnstatus = AGI_RESULT_FAILURE;
                goto async_agi_done;
            }
            /*
             * 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, ast_uri_http);
 
            execblob = ast_json_pack("{s: s}", "Result", ami_buffer);
            if (execblob && !ast_strlen_zero(cmd->cmd_id)) {
                ast_json_object_set(execblob, "CommandId", ast_json_string_create(cmd->cmd_id));
            }
            ast_channel_publish_cached_blob(chan, agi_async_exec_type(), execblob);
 
            free_agi_cmd(cmd);
 
            /*
             * Check the command status to determine if we should continue
             * executing more commands.
             */
            hungup = ast_check_hangup(chan);
            switch (cmd_status) {
            case AGI_RESULT_FAILURE:
                if (!hungup) {
                    /* The failure was not because of a hangup. */
                    returnstatus = AGI_RESULT_FAILURE;
                    goto async_agi_done;
                }
                break;
            case AGI_RESULT_SUCCESS_ASYNC:
                /* Only the "asyncagi break" command does this. */
                returnstatus = AGI_RESULT_SUCCESS_ASYNC;
                goto async_agi_done;
            default:
                break;
            }
        }
 
        if (!hungup) {
            /* Wait a bit for a frame to read or to poll for a new command. */
            res = ast_waitfor(chan, timeout);
            if (res < 0) {
                ast_debug(1, "ast_waitfor returned <= 0 on chan %s\n", ast_channel_name(chan));
                returnstatus = AGI_RESULT_FAILURE;
                break;
            }
        } else {
            /*
             * Read the channel control queue until it is dry so we can
             * quit.
             */
            res = 1;
        }
        if (0 < res) {
            do {
                cmd_status = async_agi_read_frame(chan);
                if (cmd_status != AGI_RESULT_SUCCESS) {
                    returnstatus = cmd_status;
                    goto async_agi_done;
                }
                hungup = ast_check_hangup(chan);
            } while (hungup);
        } else {
            hungup = ast_check_hangup(chan);
        }
    }
async_agi_done:
 
    if (async_agi.speech) {
        ast_speech_destroy(async_agi.speech);
    }
    /* notify manager users this channel cannot be controlled anymore by Async AGI */
    ast_channel_publish_cached_blob(chan, agi_async_end_type(), NULL);
 
async_agi_abort:
    /* close the pipe */
    close(fds[0]);
    close(fds[1]);
 
    /*
     * Intentionally do not remove the datastore added with
     * add_to_agi() the from channel.  There might be commands still
     * in the queue or in-flight to us and AsyncAGI may get called
     * again.  The datastore destructor will be called on channel
     * destruction anyway.
     */
 
    if (returnstatus == AGI_RESULT_SUCCESS) {
        returnstatus = AGI_RESULT_SUCCESS_ASYNC;
    }
    return returnstatus;
 
#undef AGI_BUF_SIZE
#undef AMI_BUF_SIZE
}

References add_to_agi(), AGI_BUF_SIZE, agi_handle_command(), AGI_RESULT_FAILURE, AGI_RESULT_SUCCESS, AGI_RESULT_SUCCESS_ASYNC, AMI_BUF_SIZE, ast_channel_name(), ast_channel_publish_cached_blob(), ast_check_hangup(), ast_check_hangup_locked(), ast_debug, ast_json_object_set(), ast_json_pack(), ast_json_string_create(), ast_json_unref(), ast_log, ast_speech_destroy(), ast_strlen_zero(), ast_uri_encode(), ast_uri_http, ast_waitfor(), async_agi_read_frame(), agi_state::audio, agi_cmd::cmd_buffer, agi_cmd::cmd_id, agi_state::ctrl, errno, agi_state::fast, agi_state::fd, free_agi_cmd(), get_agi_cmd(), LOG_ERROR, LOG_WARNING, NULL, RAII_VAR, setup_env(), and agi_state::speech.

Referenced by launch_script().

launch_ha_netscript()

static enum agi_result launch_ha_netscript ( char *  agiurl, char *  argv[], int *  fds  )

static

Definition at line 2272 of file res_agi.c.

{
    char *host, *script;
    enum agi_result result;
    struct srv_context *context = NULL;
    int srv_ret;
    char service[256];
    char resolved_uri[1024];
    const char *srvhost;
    unsigned short srvport;
 
    /* format of agiurl is "hagi://host.domain[:port][/script/name]" */
    if (strlen(agiurl) < 7) { /* Remove hagi:// */
        ast_log(LOG_WARNING, "An error occurred parsing the AGI URI: %s", agiurl);
        return AGI_RESULT_FAILURE;
    }
    host = ast_strdupa(agiurl + 7);
 
    /* Strip off any script name */
    if ((script = strchr(host, '/'))) {
        *script++ = '\0';
    } else {
        script = "";
    }
 
    if (strchr(host, ':')) {
        ast_log(LOG_WARNING, "Specifying a port number disables SRV lookups: %s\n", agiurl);
        return launch_netscript(agiurl + 1, argv, fds); /* +1 to strip off leading h from hagi:// */
    }
 
    snprintf(service, sizeof(service), "%s%s", SRV_PREFIX, host);
 
    while (!(srv_ret = ast_srv_lookup(&context, service, &srvhost, &srvport))) {
        snprintf(resolved_uri, sizeof(resolved_uri), "agi://%s:%d/%s", srvhost, srvport, script);
        result = launch_netscript(resolved_uri, argv, fds);
        if (result == AGI_RESULT_FAILURE || result == AGI_RESULT_NOTFOUND) {
            ast_log(LOG_WARNING, "AGI request failed for host '%s' (%s:%d)\n", host, srvhost, srvport);
        } else {
            /* The script launched so we must cleanup the context. */
            ast_srv_cleanup(&context);
            return result;
        }
    }
    /*
     * The DNS SRV lookup failed or we ran out of servers to check.
     * ast_srv_lookup() has already cleaned up the context for us.
     */
    if (srv_ret < 0) {
        ast_log(LOG_WARNING, "SRV lookup failed for %s\n", agiurl);
    }
 
    return AGI_RESULT_FAILURE;
}

References AGI_RESULT_FAILURE, AGI_RESULT_NOTFOUND, ast_log, ast_srv_cleanup(), ast_srv_lookup(), ast_strdupa, launch_netscript(), LOG_WARNING, NULL, result, service, and SRV_PREFIX.

Referenced by launch_script().

launch_netscript()

static enum agi_result launch_netscript ( char *  agiurl, char *  argv[], int *  fds  )

static

Definition at line 2179 of file res_agi.c.

{
    int s = 0;
    char *host, *script;
    int num_addrs = 0, i = 0;
    struct ast_sockaddr *addrs;
 
    /* agiurl is "agi://host.domain[:port][/script/name]" */
    host = ast_strdupa(agiurl + 6); /* Remove agi:// */
 
    /* Strip off any script name */
    if ((script = strchr(host, '/'))) {
        *script++ = '\0';
    } else {
        script = "";
    }
 
    if (!(num_addrs = ast_sockaddr_resolve(&addrs, host, 0, AST_AF_UNSPEC))) {
        ast_log(LOG_WARNING, "Unable to locate host '%s'\n", host);
        return AGI_RESULT_FAILURE;
    }
 
    for (i = 0; i < num_addrs; i++) {
        if (!ast_sockaddr_port(&addrs[i])) {
            ast_sockaddr_set_port(&addrs[i], AGI_PORT);
        }
 
        if ((s = ast_socket_nonblock(addrs[i].ss.ss_family, SOCK_STREAM, IPPROTO_TCP)) < 0) {
            ast_log(LOG_WARNING, "Unable to create socket: %s\n", strerror(errno));
            continue;
        }
 
        if (ast_connect(s, &addrs[i]) && errno == EINPROGRESS) {
 
            if (handle_connection(agiurl, addrs[i], s)) {
                close(s);
                continue;
            }
 
        } else {
            ast_log(LOG_WARNING, "Connection to %s failed with unexpected error: %s\n",
            ast_sockaddr_stringify(&addrs[i]), strerror(errno));
        }
 
        break;
    }
 
    ast_free(addrs);
 
    if (i == num_addrs) {
        ast_log(LOG_WARNING, "Couldn't connect to any host.  FastAGI failed.\n");
        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;
    return AGI_RESULT_SUCCESS_FAST;
}

References AGI_PORT, AGI_RESULT_FAILURE, AGI_RESULT_SUCCESS_FAST, AST_AF_UNSPEC, ast_agi_send(), ast_connect(), ast_debug, ast_free, ast_log, ast_sockaddr_port, ast_sockaddr_resolve(), ast_sockaddr_set_port, ast_sockaddr_stringify(), ast_socket_nonblock, ast_strdupa, ast_strlen_zero(), errno, handle_connection(), LOG_WARNING, NULL, and ast_sockaddr::ss.

Referenced by launch_ha_netscript(), and launch_script().

launch_script()

static enum agi_result launch_script ( struct ast_channel *  chan, char *  script, int  argc, char *  argv[], int *  fds, int *  efd, int *  opid, int *  safe_fork_called  )

static

Definition at line 2326 of file res_agi.c.

{
    char tmp[256];
    int pid, toast[2], fromast[2], audio[2], res;
    struct stat st;
 
    /* We should not call ast_safe_fork_cleanup() if we never call ast_safe_fork(1) */
    *safe_fork_called = 0;
 
    if (!strncasecmp(script, "agi://", 6)) {
        return (efd == NULL) ? launch_netscript(script, argv, fds) : AGI_RESULT_FAILURE;
    }
    if (!strncasecmp(script, "hagi://", 7)) {
        return (efd == NULL) ? launch_ha_netscript(script, argv, fds) : AGI_RESULT_FAILURE;
    }
    if (!strncasecmp(script, "agi:async", sizeof("agi:async") - 1)) {
        return launch_asyncagi(chan, argc, 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 = ast_fd_set_flags(audio[1], 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;
        }
    }
 
    *safe_fork_called = 1;
 
    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;
}

References AGI_RESULT_FAILURE, AGI_RESULT_NOTFOUND, AGI_RESULT_SUCCESS, ast_child_verbose(), ast_close_fds_above_n(), ast_config_AST_AGI_DIR, ast_config_AST_CONFIG_DIR, ast_config_AST_CONFIG_FILE, ast_config_AST_DATA_DIR, ast_config_AST_KEY_DIR, ast_config_AST_LOG_DIR, ast_config_AST_MODULE_DIR, ast_config_AST_MONITOR_DIR, ast_config_AST_RUN_DIR, ast_config_AST_SPOOL_DIR, ast_config_AST_VAR_DIR, ast_fd_set_flags, ast_log, ast_safe_fork(), ast_set_priority(), ast_verb, errno, launch_asyncagi(), launch_ha_netscript(), launch_netscript(), LOG_WARNING, NULL, and setenv().

Referenced by agi_exec_full().

load_module()

static int load_module ( void  )

static

Definition at line 4849 of file res_agi.c.

{
    int err = 0;
 
    err |= STASIS_MESSAGE_TYPE_INIT(agi_exec_start_type);
    err |= STASIS_MESSAGE_TYPE_INIT(agi_exec_end_type);
    err |= STASIS_MESSAGE_TYPE_INIT(agi_async_start_type);
    err |= STASIS_MESSAGE_TYPE_INIT(agi_async_exec_type);
    err |= STASIS_MESSAGE_TYPE_INIT(agi_async_end_type);
 
    err |= ast_cli_register_multiple(cli_agi, ARRAY_LEN(cli_agi));
    err |= ast_agi_register_multiple(ast_module_info->self, commands, ARRAY_LEN(commands));
    err |= ast_register_application_xml(eapp, eagi_exec);
    err |= ast_manager_register_xml("AGI", EVENT_FLAG_AGI, action_add_agi_cmd);
    err |= ast_register_application_xml(app, agi_exec);
 
    AST_TEST_REGISTER(test_agi_null_docs);
 
    if (err) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
 
    return AST_MODULE_LOAD_SUCCESS;
}

References action_add_agi_cmd(), agi_exec(), app, ARRAY_LEN, ast_agi_register_multiple(), ast_cli_register_multiple, ast_manager_register_xml, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, ast_register_application_xml, AST_TEST_REGISTER, cli_agi, commands, eagi_exec(), eapp, EVENT_FLAG_AGI, ast_module_info::self, STASIS_MESSAGE_TYPE_INIT, and unload_module().

parse_args()

static int parse_args ( char *  s, int *  max, const char *  argv[]  )

static

Definition at line 4124 of file res_agi.c.

{
    int x = 0, quoted = 0, escaped = 0, whitespace = 1;
    char *cur;
 
    cur = s;
    while(*s) {
        switch(*s) {
        case '"':
            /* If it's escaped, put a literal quote */
            if (escaped)
                goto normal;
            else
                quoted = !quoted;
            if (quoted && whitespace) {
                /* If we're starting a quote, coming off white space start a new word, too */
                argv[x++] = cur;
                whitespace=0;
            }
            escaped = 0;
        break;
        case ' ':
        case '\t':
            if (!quoted && !escaped) {
                /* If we're not quoted, mark this as whitespace, and
                   end the previous argument */
                whitespace = 1;
                *(cur++) = '\0';
            } else
                /* Otherwise, just treat it as anything else */
                goto normal;
            break;
        case '\\':
            /* If we're escaped, print a literal, otherwise enable escaping */
            if (escaped) {
                goto normal;
            } else {
                escaped=1;
            }
            break;
        default:
normal:
            if (whitespace) {
                if (x >= MAX_ARGS -1) {
                    ast_log(LOG_WARNING, "Too many arguments, truncating\n");
                    break;
                }
                /* Coming off of whitespace, start the next argument */
                argv[x++] = cur;
                whitespace=0;
            }
            *(cur++) = *s;
            escaped=0;
        }
        s++;
    }
    /* Null terminate */
    *(cur++) = '\0';
    argv[x] = NULL;
    *max = x;
    return 0;
}

References ast_log, LOG_WARNING, max, MAX_ARGS, and NULL.

Referenced by agi_handle_command().

publish_async_exec_end()

static void publish_async_exec_end ( struct ast_channel *  chan, int  command_id, const char *  command, int  result_code, const char *  result  )

static

Definition at line 4187 of file res_agi.c.

{
    RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
    blob = ast_json_pack("{s: i, s: s, s: i, s: s}",
                 "CommandId", command_id,
                 "Command", command,
                 "ResultCode", result_code,
                 "Result", result);
    ast_channel_publish_cached_blob(chan, agi_exec_end_type(), blob);
}

References ast_channel_publish_cached_blob(), ast_json_pack(), ast_json_unref(), NULL, RAII_VAR, and result.

Referenced by agi_handle_command().

run_agi()

static enum agi_result run_agi ( struct ast_channel *  chan, char *  request, AGI *  agi, int  pid, int *  status, int  dead, int  argc, char *  argv[]  )

static

Running in an interception routine is like when channel is hung up. No touchy the channel frames.

Definition at line 4289 of file res_agi.c.

{
    struct ast_channel *c;
    int outfd;
    int ms;
    int needhup = 0;
    enum agi_result returnstatus = AGI_RESULT_SUCCESS;
    struct ast_frame *f;
    char buf[AGI_BUF_LEN];
    char *res = NULL;
    FILE *readf;
    /* how many times we'll retry if ast_waitfor_nandfs will return without either
      channel or file descriptor in case select is interrupted by a system call (EINTR) */
    int retry = AGI_NANDFS_RETRY;
    int send_sighup;
    const char *sighup_str;
    const char *exit_on_hangup_str;
    int exit_on_hangup;
    /*! Running in an interception routine is like when channel is hung up.  No touchy the channel frames. */
    int in_intercept = ast_channel_get_intercept_mode();
 
    ast_channel_lock(chan);
    sighup_str = pbx_builtin_getvar_helper(chan, "AGISIGHUP");
    send_sighup = !ast_false(sighup_str);
    exit_on_hangup_str = pbx_builtin_getvar_helper(chan, "AGIEXITONHANGUP");
    exit_on_hangup = ast_true(exit_on_hangup_str);
    ast_channel_unlock(chan);
 
    if (!(readf = fdopen(agi->ctrl, "r"))) {
        ast_log(LOG_WARNING, "Unable to fdopen file descriptor\n");
        if (send_sighup && pid > -1)
            kill(pid, SIGHUP);
        close(agi->ctrl);
        return AGI_RESULT_FAILURE;
    }
 
    setlinebuf(readf);
    setup_env(chan, request, agi->fd, (agi->audio > -1), argc, argv);
    for (;;) {
        if (needhup) {
            needhup = 0;
            dead = 1;
            if (send_sighup) {
                if (pid > -1) {
                    kill(pid, SIGHUP);
                } else if (agi->fast) {
                    ast_agi_send(agi->fd, chan, "HANGUP\n");
                }
            }
            if (exit_on_hangup) {
                break;
            }
        }
        ms = -1;
        if (dead || in_intercept) {
            c = ast_waitfor_nandfds(&chan, 0, &agi->ctrl, 1, NULL, &outfd, &ms);
        } else if (!ast_check_hangup(chan)) {
            c = ast_waitfor_nandfds(&chan, 1, &agi->ctrl, 1, NULL, &outfd, &ms);
        } else {
            /*
             * Read the channel control queue until it is dry so we can
             * switch to dead mode.
             */
            c = chan;
        }
        if (c) {
            retry = AGI_NANDFS_RETRY;
            /* Idle the channel until we get a command */
            f = ast_read(c);
            if (!f) {
                ast_debug(1, "%s hungup\n", ast_channel_name(chan));
                needhup = 1;
                if (!returnstatus) {
                    returnstatus = AGI_RESULT_HANGUP;
                }
            } else {
                /* If it's voice, write it to the audio pipe */
                if ((agi->audio > -1) && (f->frametype == AST_FRAME_VOICE)) {
                    /* Write, ignoring errors */
                    if (write(agi->audio, f->data.ptr, f->datalen) < 0) {
                    }
                }
                ast_frfree(f);
            }
        } else if (outfd > -1) {
            size_t len = sizeof(buf);
            size_t buflen = 0;
            enum agi_result cmd_status;
 
            retry = AGI_NANDFS_RETRY;
            buf[0] = '\0';
 
            while (len > 1) {
                res = fgets(buf + buflen, len, readf);
                if (feof(readf))
                    break;
                if (ferror(readf) && ((errno != EINTR) && (errno != EAGAIN)))
                    break;
                if (res != NULL && !agi->fast)
                    break;
                buflen = strlen(buf);
                if (buflen && buf[buflen - 1] == '\n')
                    break;
                len = sizeof(buf) - buflen;
                if (agidebug)
                    ast_verbose("AGI Rx << temp buffer %s - errno %s\nNo \\n received, checking again.\n", buf, strerror(errno));
            }
 
            if (!buf[0]) {
                /* Program terminated */
                ast_verb(3, "<%s>AGI Script %s completed, returning %d\n", ast_channel_name(chan), request, returnstatus);
                if (pid > 0)
                    waitpid(pid, status, 0);
                /* No need to kill the pid anymore, since they closed us */
                pid = -1;
                break;
            }
 
            /* Special case for inability to execute child process */
            if (*buf && strncasecmp(buf, "failure", 7) == 0) {
                returnstatus = AGI_RESULT_FAILURE;
                break;
            }
 
            /* get rid of trailing newline, if any */
            buflen = strlen(buf);
            if (buflen && buf[buflen - 1] == '\n') {
                buf[buflen - 1] = '\0';
            }
 
            if (agidebug)
                ast_verbose("<%s>AGI Rx << %s\n", ast_channel_name(chan), buf);
            cmd_status = agi_handle_command(chan, agi, buf, dead || in_intercept);
            switch (cmd_status) {
            case AGI_RESULT_FAILURE:
                if (dead || in_intercept || !ast_check_hangup(chan)) {
                    /* The failure was not because of a hangup. */
                    returnstatus = AGI_RESULT_FAILURE;
                }
                break;
            default:
                break;
            }
        } else {
            if (--retry <= 0) {
                ast_log(LOG_WARNING, "No channel, no fd?\n");
                returnstatus = AGI_RESULT_FAILURE;
                break;
            }
        }
    }
 
    if (agi->speech) {
        ast_speech_destroy(agi->speech);
    }
    /* Notify process */
    if (send_sighup) {
        if (pid > -1) {
            if (kill(pid, SIGHUP)) {
                ast_log(LOG_WARNING, "unable to send SIGHUP to AGI process %d: %s\n", pid, strerror(errno));
            } else { /* Give the process a chance to die */
                usleep(1);
            }
            waitpid(pid, status, WNOHANG);
        } else if (agi->fast) {
            ast_agi_send(agi->fd, chan, "HANGUP\n");
        }
    }
    fclose(readf);
    return returnstatus;
}

References AGI_BUF_LEN, agi_handle_command(), AGI_NANDFS_RETRY, AGI_RESULT_FAILURE, AGI_RESULT_HANGUP, AGI_RESULT_SUCCESS, agidebug, ast_agi_send(), ast_channel_get_intercept_mode(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_check_hangup(), ast_debug, ast_false(), AST_FRAME_VOICE, ast_frfree, ast_log, ast_read(), ast_speech_destroy(), ast_true(), ast_verb, ast_verbose, ast_waitfor_nandfds(), agi_state::audio, buf, c, agi_state::ctrl, ast_frame::data, ast_frame::datalen, errno, agi_state::fast, agi_state::fd, ast_frame::frametype, len(), LOG_WARNING, NULL, pbx_builtin_getvar_helper(), ast_frame::ptr, request(), setup_env(), agi_state::speech, and status.

Referenced by agi_exec_full().

setup_env()

static void setup_env ( struct ast_channel *  chan, char *  request, int  fd, int  enhanced, int  argc, char *  argv[]  )

static

Definition at line 2449 of file res_agi.c.

{
    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", ast_channel_name(chan));
    ast_agi_send(fd, chan, "agi_language: %s\n", ast_channel_language(chan));
    ast_agi_send(fd, chan, "agi_type: %s\n", ast_channel_tech(chan)->type);
    ast_agi_send(fd, chan, "agi_uniqueid: %s\n", ast_channel_uniqueid(chan));
    ast_agi_send(fd, chan, "agi_version: %s\n", ast_get_version());
 
    /* ANI/DNIS */
    ast_agi_send(fd, chan, "agi_callerid: %s\n",
        S_COR(ast_channel_caller(chan)->id.number.valid, ast_channel_caller(chan)->id.number.str, "unknown"));
    ast_agi_send(fd, chan, "agi_calleridname: %s\n",
        S_COR(ast_channel_caller(chan)->id.name.valid, ast_channel_caller(chan)->id.name.str, "unknown"));
    ast_agi_send(fd, chan, "agi_callingpres: %d\n",
        ast_party_id_presentation(&ast_channel_caller(chan)->id));
    ast_agi_send(fd, chan, "agi_callingani2: %d\n", ast_channel_caller(chan)->ani2);
    ast_agi_send(fd, chan, "agi_callington: %d\n", ast_channel_caller(chan)->id.number.plan);
    ast_agi_send(fd, chan, "agi_callingtns: %d\n", ast_channel_dialed(chan)->transit_network_select);
    ast_agi_send(fd, chan, "agi_dnid: %s\n", S_OR(ast_channel_dialed(chan)->number.str, "unknown"));
    ast_agi_send(fd, chan, "agi_rdnis: %s\n",
        S_COR(ast_channel_redirecting(chan)->from.number.valid, ast_channel_redirecting(chan)->from.number.str, "unknown"));
 
    /* Context information */
    ast_agi_send(fd, chan, "agi_context: %s\n", ast_channel_context(chan));
    ast_agi_send(fd, chan, "agi_extension: %s\n", ast_channel_exten(chan));
    ast_agi_send(fd, chan, "agi_priority: %d\n", ast_channel_priority(chan));
    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", ast_channel_accountcode(chan) ? ast_channel_accountcode(chan) : "");
    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");
}

References ast_agi_send(), ast_channel_accountcode(), ast_channel_caller(), ast_channel_context(), ast_channel_dialed(), ast_channel_exten(), ast_channel_language(), ast_channel_name(), ast_channel_priority(), ast_channel_redirecting(), ast_channel_uniqueid(), ast_get_version(), ast_party_id_presentation(), name, request(), S_COR, S_OR, and type.

Referenced by launch_asyncagi(), and run_agi().

speech_streamfile()

static int speech_streamfile ( struct ast_channel *  chan, const char *  filename, const char *  preflang, int  offset  )

static

Definition at line 3705 of file res_agi.c.

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

References ast_applystream(), ast_openstream(), ast_playstream(), ast_seekstream(), ast_filestream::filename, and NULL.

Referenced by handle_speechrecognize().

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [1/5]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	agi_async_end_type	,
		.	to_ami = agi_async_end_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [2/5]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	agi_async_exec_type	,
		.	to_ami = agi_async_exec_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [3/5]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	agi_async_start_type	,
		.	to_ami = agi_async_start_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [4/5]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	agi_exec_end_type	,
		.	to_ami = agi_exec_end_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [5/5]

STASIS_MESSAGE_TYPE_DEFN_LOCAL	(	agi_exec_start_type	,
		.	to_ami = agi_exec_start_to_ami
	)

unload_module()

static int unload_module ( void  )

static

Definition at line 4832 of file res_agi.c.

{
    STASIS_MESSAGE_TYPE_CLEANUP(agi_exec_start_type);
    STASIS_MESSAGE_TYPE_CLEANUP(agi_exec_end_type);
    STASIS_MESSAGE_TYPE_CLEANUP(agi_async_start_type);
    STASIS_MESSAGE_TYPE_CLEANUP(agi_async_exec_type);
    STASIS_MESSAGE_TYPE_CLEANUP(agi_async_end_type);
 
    ast_cli_unregister_multiple(cli_agi, ARRAY_LEN(cli_agi));
    ast_agi_unregister_multiple(commands, ARRAY_LEN(commands));
    ast_unregister_application(eapp);
    ast_manager_unregister("AGI");
    ast_unregister_application(app);
    AST_TEST_UNREGISTER(test_agi_null_docs);
    return 0;
}

References app, ARRAY_LEN, ast_agi_unregister_multiple(), ast_cli_unregister_multiple(), ast_manager_unregister(), AST_TEST_UNREGISTER, ast_unregister_application(), cli_agi, commands, eapp, and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by load_module().

write_html_escaped()

static void write_html_escaped ( FILE *  htmlfile, char *  str  )

static

Convert string to use HTML escaped characters.

Note

Maybe this should be a generic function?

Definition at line 4561 of file res_agi.c.

{
    char *cur = str;
 
    while(*cur) {
        switch (*cur) {
        case '<':
            fprintf(htmlfile, "%s", "&lt;");
            break;
        case '>':
            fprintf(htmlfile, "%s", "&gt;");
            break;
        case '&':
            fprintf(htmlfile, "%s", "&amp;");
            break;
        case '"':
            fprintf(htmlfile, "%s", "&quot;");
            break;
        default:
            fprintf(htmlfile, "%c", *cur);
            break;
        }
        cur++;
    }
 
    return;
}

References str.

Referenced by write_htmldump().

write_htmldump()

static int write_htmldump ( const char *  filename )

static

Definition at line 4589 of file res_agi.c.

{
    struct agi_command *command;
    char fullcmd[MAX_CMD_LEN];
    FILE *htmlfile;
 
    if (!(htmlfile = fopen(filename, "wt")))
        return -1;
 
    fprintf(htmlfile, "<HTML>\n<HEAD>\n<TITLE>AGI Commands</TITLE>\n</HEAD>\n");
    fprintf(htmlfile, "<BODY>\n<CENTER><B><H1>AGI Commands</H1></B></CENTER>\n\n");
    fprintf(htmlfile, "<TABLE BORDER=\"0\" CELLSPACING=\"10\">\n");
 
    AST_RWLIST_RDLOCK(&agi_commands);
    AST_RWLIST_TRAVERSE(&agi_commands, command, list) {
        char *tempstr, *stringp;
 
        if (!command->cmda[0])  /* end ? */
            break;
        /* Hide commands that start with '_' */
        if ((command->cmda[0])[0] == '_')
            continue;
        ast_join(fullcmd, sizeof(fullcmd), command->cmda);
 
        fprintf(htmlfile, "<TR><TD><TABLE BORDER=\"1\" CELLPADDING=\"5\" WIDTH=\"100%%\">\n");
        fprintf(htmlfile, "<TR><TH ALIGN=\"CENTER\"><B>%s - %s</B></TH></TR>\n", fullcmd, command->summary);
#ifdef AST_XML_DOCS
        stringp = ast_xmldoc_printable(command->usage, 0);
#else
        stringp = ast_strdup(command->usage);
#endif
        tempstr = strsep(&stringp, "\n");
 
        fprintf(htmlfile, "<TR><TD ALIGN=\"CENTER\">");
        write_html_escaped(htmlfile, tempstr);
        fprintf(htmlfile, "</TD></TR>\n");
        fprintf(htmlfile, "<TR><TD ALIGN=\"CENTER\">\n");
 
        while ((tempstr = strsep(&stringp, "\n")) != NULL) {
            write_html_escaped(htmlfile, tempstr);
            fprintf(htmlfile, "<BR>\n");
        }
        fprintf(htmlfile, "</TD></TR>\n");
        fprintf(htmlfile, "</TABLE></TD></TR>\n\n");
        ast_free(stringp);
    }
    AST_RWLIST_UNLOCK(&agi_commands);
    fprintf(htmlfile, "</TABLE>\n</BODY>\n</HTML>\n");
    fclose(htmlfile);
    return 0;
}

References ast_free, ast_join, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strdup, ast_xmldoc_printable(), agi_command::cmda, agi_command::list, MAX_CMD_LEN, NULL, strsep(), agi_command::summary, agi_command::usage, and write_html_escaped().

Referenced by handle_cli_agi_dump_html().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "Asterisk Gateway Interface (AGI)" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_APP_DEPEND, .requires = "res_speech", }

static

Definition at line 4881 of file res_agi.c.

agi_commands

struct agi_commands agi_commands = AST_RWLIST_HEAD_INIT_VALUE

static

agi_commands_datastore_info

const struct ast_datastore_info agi_commands_datastore_info

static

Initial value:

= {
    .type = "AsyncAGI",
    .destroy = agi_destroy_commands_cb
}

Definition at line 1670 of file res_agi.c.

                                                                     {
    .type = "AsyncAGI",
    .destroy = agi_destroy_commands_cb
};

Referenced by add_agi_cmd(), add_to_agi(), and get_agi_cmd().

agidebug

int agidebug = 0

static

Definition at line 1526 of file res_agi.c.

Referenced by ast_agi_send(), handle_cli_agi_debug(), and run_agi().

app

char* app = "AGI"

static

Definition at line 1522 of file res_agi.c.

Referenced by load_module(), and unload_module().

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4881 of file res_agi.c.

cli_agi

struct ast_cli_entry cli_agi[]

static

Definition at line 4785 of file res_agi.c.

                                        {
    AST_CLI_DEFINE(handle_cli_agi_add_cmd,   "Add AGI command to a channel in Async AGI"),
    AST_CLI_DEFINE(handle_cli_agi_debug,     "Enable/Disable AGI debugging"),
    AST_CLI_DEFINE(handle_cli_agi_show,      "List AGI commands or specific help"),
    AST_CLI_DEFINE(handle_cli_agi_dump_html, "Dumps a list of AGI commands in HTML format")
};

Referenced by load_module(), and unload_module().

commands

struct agi_command commands[]

static

AGI commands list.

Definition at line 3877 of file res_agi.c.

                                       {
    { { "answer", NULL }, handle_answer, NULL, NULL, 0 },
    { { "asyncagi", "break", NULL }, handle_asyncagi_break, NULL, NULL, 1 },
    { { "channel", "status", NULL }, handle_channelstatus, NULL, NULL, 0 },
    { { "database", "del", NULL }, handle_dbdel, NULL, NULL, 1 },
    { { "database", "deltree", NULL }, handle_dbdeltree, NULL, NULL, 1 },
    { { "database", "get", NULL }, handle_dbget, NULL, NULL, 1 },
    { { "database", "put", NULL }, handle_dbput, NULL, NULL, 1 },
    { { "exec", NULL }, handle_exec, NULL, NULL, 1 },
    { { "get", "data", NULL }, handle_getdata, NULL, NULL, 0 },
    { { "get", "full", "variable", NULL }, handle_getvariablefull, NULL, NULL, 1 },
    { { "get", "option", NULL }, handle_getoption, NULL, NULL, 0 },
    { { "get", "variable", NULL }, handle_getvariable, NULL, NULL, 1 },
    { { "hangup", NULL }, handle_hangup, NULL, NULL, 0 },
    { { "noop", NULL }, handle_noop, NULL, NULL, 1 },
    { { "receive", "char", NULL }, handle_recvchar, NULL, NULL, 0 },
    { { "receive", "text", NULL }, handle_recvtext, NULL, NULL, 0 },
    { { "record", "file", NULL }, handle_recordfile, NULL, NULL, 0 },
    { { "say", "alpha", NULL }, handle_sayalpha, NULL, NULL, 0},
    { { "say", "digits", NULL }, handle_saydigits, NULL, NULL, 0 },
    { { "say", "number", NULL }, handle_saynumber, NULL, NULL, 0 },
    { { "say", "phonetic", NULL }, handle_sayphonetic, NULL, NULL, 0},
    { { "say", "date", NULL }, handle_saydate, NULL, NULL, 0},
    { { "say", "time", NULL }, handle_saytime, NULL, NULL, 0},
    { { "say", "datetime", NULL }, handle_saydatetime, NULL, NULL, 0},
    { { "send", "image", NULL }, handle_sendimage, NULL, NULL, 0},
    { { "send", "text", NULL }, handle_sendtext, NULL, NULL, 0},
    { { "set", "autohangup", NULL }, handle_autohangup, NULL, NULL, 0},
    { { "set", "callerid", NULL }, handle_setcallerid, NULL, NULL, 0},
    { { "set", "context", NULL }, handle_setcontext, NULL, NULL, 0},
    { { "set", "extension", NULL }, handle_setextension, NULL, NULL, 0},
    { { "set", "music", NULL }, handle_setmusic, NULL, NULL, 0 },
    { { "set", "priority", NULL }, handle_setpriority, NULL, NULL, 0 },
    { { "set", "variable", NULL }, handle_setvariable, NULL, NULL, 1 },
    { { "stream", "file", NULL }, handle_streamfile, NULL, NULL, 0 },
    { { "control", "stream", "file", NULL }, handle_controlstreamfile, NULL, NULL, 0 },
    { { "tdd", "mode", NULL }, handle_tddmode, NULL, NULL, 0 },
    { { "verbose", NULL }, handle_verbose, NULL, NULL, 1 },
    { { "wait", "for", "digit", NULL }, handle_waitfordigit, NULL, NULL, 0 },
    { { "speech", "create", NULL }, handle_speechcreate, NULL, NULL, 0 },
    { { "speech", "set", NULL }, handle_speechset, NULL, NULL, 0 },
    { { "speech", "destroy", NULL }, handle_speechdestroy, NULL, NULL, 1 },
    { { "speech", "load", "grammar", NULL }, handle_speechloadgrammar, NULL, NULL, 0 },
    { { "speech", "unload", "grammar", NULL }, handle_speechunloadgrammar, NULL, NULL, 1 },
    { { "speech", "activate", "grammar", NULL }, handle_speechactivategrammar, NULL, NULL, 0 },
    { { "speech", "deactivate", "grammar", NULL }, handle_speechdeactivategrammar, NULL, NULL, 0 },
    { { "speech", "recognize", NULL }, handle_speechrecognize, NULL, NULL, 0 },
};

Referenced by dundi_showframe(), load_module(), unload_module(), and xmpp_component_service_discovery_get_hook().

eapp

char* eapp = "EAGI"

static

Definition at line 1524 of file res_agi.c.

Referenced by load_module(), and unload_module().