Merge "pjproject_bundled: Allow IPv4/IPv6 (Dual Stack) configurations."
[asterisk/asterisk.git] / apps / app_externalivr.c
index 1023204..2bb1d8b 100644 (file)
  * \ingroup applications
  */
 
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <errno.h>
+/*** MODULEINFO
+       <support_level>extended</support_level>
+ ***/
 
 #include "asterisk.h"
 
-ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+ASTERISK_REGISTER_FILE()
+
+#include <signal.h>
 
 #include "asterisk/lock.h"
 #include "asterisk/file.h"
-#include "asterisk/logger.h"
 #include "asterisk/channel.h"
 #include "asterisk/pbx.h"
 #include "asterisk/module.h"
 #include "asterisk/linkedlists.h"
 #include "asterisk/app.h"
 #include "asterisk/utils.h"
-
-static const char *tdesc = "External IVR Interface Application";
-
-static const char *app = "ExternalIVR";
-
-static const char *synopsis = "Interfaces with an external IVR application";
-
-static const char *descrip = 
-"  ExternalIVR(command[|arg[|arg...]]): Forks an process to run the supplied command,\n"
-"and starts a generator on the channel. The generator's play list is\n"
-"controlled by the external application, which can add and clear entries\n"
-"via simple commands issued over its stdout. The external application\n"
-"will receive all DTMF events received on the channel, and notification\n"
-"if the channel is hung up. The application will not be forcibly terminated\n"
-"when the channel is hung up.\n"
-"See doc/README.externalivr for a protocol specification.\n";
+#include "asterisk/tcptls.h"
+#include "asterisk/astobj2.h"
+
+/*** DOCUMENTATION
+       <application name="ExternalIVR" language="en_US">
+               <synopsis>
+                       Interfaces with an external IVR application.
+               </synopsis>
+               <syntax>
+                       <parameter name="command|ivr://host" required="true" hasparams="true">
+                               <argument name="arg1" />
+                               <argument name="arg2" multiple="yes" />
+                       </parameter>
+                       <parameter name="options">
+                               <optionlist>
+                                       <option name="n">
+                                               <para>Tells ExternalIVR() not to answer the channel.</para>
+                                       </option>
+                                       <option name="i">
+                                               <para>Tells ExternalIVR() not to send a hangup and exit when the
+                                               channel receives a hangup, instead it sends an <literal>I</literal>
+                                               informative message meaning that the external application MUST hang
+                                               up the call with an <literal>H</literal> command.</para>
+                                       </option>
+                                       <option name="d">
+                                               <para>Tells ExternalIVR() to run on a channel that has been hung up
+                                               and will not look for hangups. The external application must exit with
+                                               an <literal>E</literal> command.</para>
+                                       </option>
+                               </optionlist>
+                       </parameter>
+               </syntax>
+               <description>
+                       <para>Either forks a process to run given command or makes a socket to connect
+                       to given host and starts a generator on the channel. The generator's play list
+                       is controlled by the external application, which can add and clear entries via
+                       simple commands issued over its stdout. The external application will receive
+                       all DTMF events received on the channel, and notification if the channel is
+                       hung up. The received on the channel, and notification if the channel is hung
+                       up. The application will not be forcibly terminated when the channel is hung up.
+                       For more information see <filename>doc/AST.pdf</filename>.</para>
+               </description>
+       </application>
+ ***/
+
+static const char app[] = "ExternalIVR";
 
 /* XXX the parser in gcc 2.95 gets confused if you don't put a space between 'name' and the comma */
-#define ast_chan_log(level, channel, format, ...) ast_log(level, "%s: " format, channel->name , ## __VA_ARGS__)
+#define ast_chan_log(level, channel, format, ...) ast_log(level, "%s: " format, ast_channel_name(channel) , ## __VA_ARGS__)
+
+/* Commands */
+#define EIVR_CMD_APND 'A' /* append to prompt queue */
+#define EIVR_CMD_DTMF 'D' /* send DTMF */
+#define EIVR_CMD_EXIT 'E' /* exit */
+#define EIVR_CMD_GET  'G' /* get channel varable(s) */
+#define EIVR_CMD_HGUP 'H' /* hangup */
+#define EIVR_CMD_IRPT 'I' /* interrupt */
+#define EIVR_CMD_LOG  'L' /* log message */
+#define EIVR_CMD_OPT  'O' /* option */
+#define EIVR_CMD_PARM 'P' /* return supplied params */
+#define EIVR_CMD_SQUE 'S' /* (re)set prompt queue */
+#define EIVR_CMD_ANS  'T' /* answer channel */
+#define EIVR_CMD_SVAR 'V' /* set channel varable(s) */
+#define EIVR_CMD_XIT  'X' /* exit **depricated** */
+
+#define EXTERNALIVR_PORT 2949
+
+enum options_flags {
+       noanswer = (1 << 0),
+       ignore_hangup = (1 << 1),
+       run_dead = (1 << 2),
+};
+
+AST_APP_OPTIONS(app_opts, {
+       AST_APP_OPTION('n', noanswer),
+       AST_APP_OPTION('i', ignore_hangup),
+       AST_APP_OPTION('d', run_dead),
+});
 
 struct playlist_entry {
        AST_LIST_ENTRY(playlist_entry) list;
        char filename[1];
 };
 
-struct localuser {
+struct ivr_localuser {
        struct ast_channel *chan;
-       struct localuser *next;
        AST_LIST_HEAD(playlist, playlist_entry) playlist;
        AST_LIST_HEAD(finishlist, playlist_entry) finishlist;
        int abort_current_sound;
        int playing_silence;
        int option_autoclear;
+       int gen_active;
 };
 
-LOCAL_USER_DECL;
 
 struct gen_state {
-       struct localuser *u;
+       struct ivr_localuser *u;
        struct ast_filestream *stream;
        struct playlist_entry *current;
        int sample_queue;
 };
 
-static void send_child_event(FILE *handle, const char event, const char *data,
-                            const struct ast_channel *chan)
+static int eivr_comm(struct ast_channel *chan, struct ivr_localuser *u, 
+       int *eivr_events_fd, int *eivr_commands_fd, int *eivr_errors_fd, 
+       const struct ast_str *args, const struct ast_flags flags);
+
+static void send_eivr_event(FILE *handle, const char event, const char *data,
+       const struct ast_channel *chan)
 {
-       char tmp[256];
+       struct ast_str *tmp = ast_str_create(12);
 
-       if (!data) {
-               snprintf(tmp, sizeof(tmp), "%c,%10d", event, (int)time(NULL));
-       } else {
-               snprintf(tmp, sizeof(tmp), "%c,%10d,%s", event, (int)time(NULL), data);
+       ast_str_append(&tmp, 0, "%c,%10d", event, (int)time(NULL));
+       if (data) {
+               ast_str_append(&tmp, 0, ",%s", data);
        }
 
-       fprintf(handle, "%s\n", tmp);
-       ast_chan_log(LOG_DEBUG, chan, "sent '%s'\n", tmp);
+       fprintf(handle, "%s\n", ast_str_buffer(tmp));
+       ast_debug(1, "sent '%s'\n", ast_str_buffer(tmp));
+       ast_free(tmp);
 }
 
 static void *gen_alloc(struct ast_channel *chan, void *params)
 {
-       struct localuser *u = params;
+       struct ivr_localuser *u = params;
        struct gen_state *state;
-       
+
        if (!(state = ast_calloc(1, sizeof(*state))))
                return NULL;
 
@@ -128,7 +189,7 @@ static void gen_closestream(struct gen_state *state)
                return;
 
        ast_closestream(state->stream);
-       state->u->chan->stream = NULL;
+       ast_channel_stream_set(state->u->chan, NULL);
        state->stream = NULL;
 }
 
@@ -137,33 +198,36 @@ static void gen_release(struct ast_channel *chan, void *data)
        struct gen_state *state = data;
 
        gen_closestream(state);
-       free(data);
+       ast_free(data);
 }
 
 /* caller has the playlist locked */
 static int gen_nextfile(struct gen_state *state)
 {
-       struct localuser *u = state->u;
+       struct ivr_localuser *u = state->u;
        char *file_to_stream;
-       
+
        u->abort_current_sound = 0;
        u->playing_silence = 0;
        gen_closestream(state);
 
        while (!state->stream) {
-               state->current = AST_LIST_REMOVE_HEAD(&u->playlist, list);
+               state->current = AST_LIST_FIRST(&u->playlist);
                if (state->current) {
                        file_to_stream = state->current->filename;
                } else {
-                       file_to_stream = "silence-10";
+                       file_to_stream = "silence/10";
                        u->playing_silence = 1;
                }
 
-               if (!(state->stream = ast_openstream_full(u->chan, file_to_stream, u->chan->language, 1))) {
+               if (!(state->stream = ast_openstream_full(u->chan, file_to_stream, ast_channel_language(u->chan), 1))) {
                        ast_chan_log(LOG_WARNING, u->chan, "File '%s' could not be opened: %s\n", file_to_stream, strerror(errno));
+                       AST_LIST_LOCK(&u->playlist);
+                       AST_LIST_REMOVE_HEAD(&u->playlist, list);
+                       AST_LIST_UNLOCK(&u->playlist);
                        if (!u->playing_silence) {
                                continue;
-                       } else { 
+                       } else {
                                break;
                        }
                }
@@ -175,10 +239,10 @@ static int gen_nextfile(struct gen_state *state)
 static struct ast_frame *gen_readframe(struct gen_state *state)
 {
        struct ast_frame *f = NULL;
-       struct localuser *u = state->u;
-       
+       struct ivr_localuser *u = state->u;
+
        if (u->abort_current_sound ||
-           (u->playing_silence && AST_LIST_FIRST(&u->playlist))) {
+               (u->playing_silence && AST_LIST_FIRST(&u->playlist))) {
                gen_closestream(state);
                AST_LIST_LOCK(&u->playlist);
                gen_nextfile(state);
@@ -187,6 +251,11 @@ static struct ast_frame *gen_readframe(struct gen_state *state)
 
        if (!(state->stream && (f = ast_readframe(state->stream)))) {
                if (state->current) {
+                       /* remove finished file from playlist */
+                        AST_LIST_LOCK(&u->playlist);
+                        AST_LIST_REMOVE_HEAD(&u->playlist, list);
+                        AST_LIST_UNLOCK(&u->playlist);
+                       /* add finished file to finishlist */
                        AST_LIST_LOCK(&u->finishlist);
                        AST_LIST_INSERT_TAIL(&u->finishlist, state->current, list);
                        AST_LIST_UNLOCK(&u->finishlist);
@@ -225,16 +294,92 @@ static int gen_generate(struct ast_channel *chan, void *data, int len, int sampl
 
 static struct ast_generator gen =
 {
-       alloc: gen_alloc,
-       release: gen_release,
-       generate: gen_generate,
+       .alloc = gen_alloc,
+       .release = gen_release,
+       .generate = gen_generate,
 };
 
+static void ast_eivr_getvariable(struct ast_channel *chan, char *data, char *outbuf, int outbuflen)
+{
+       /* original input data: "G,var1,var2," */
+       /* data passed as "data":  "var1,var2" */
+
+       char *inbuf, *variable;
+       const char *value;
+       int j;
+       struct ast_str *newstring = ast_str_alloca(outbuflen); 
+
+       outbuf[0] = '\0';
+
+       for (j = 1, inbuf = data; ; j++) {
+               variable = strsep(&inbuf, ",");
+               if (variable == NULL) {
+                       int outstrlen = strlen(outbuf);
+                       if (outstrlen && outbuf[outstrlen - 1] == ',') {
+                               outbuf[outstrlen - 1] = 0;
+                       }
+                       break;
+               }
+               
+               ast_channel_lock(chan);
+               if (!(value = pbx_builtin_getvar_helper(chan, variable))) {
+                       value = "";
+               }
+
+               ast_str_append(&newstring, 0, "%s=%s,", variable, value);
+               ast_channel_unlock(chan);
+               ast_copy_string(outbuf, ast_str_buffer(newstring), outbuflen);
+       }
+}
+
+static void ast_eivr_setvariable(struct ast_channel *chan, char *data)
+{
+       char *value;
+
+       char *inbuf = ast_strdupa(data), *variable;
+
+       for (variable = strsep(&inbuf, ","); variable; variable = strsep(&inbuf, ",")) {
+               ast_debug(1, "Setting up a variable: %s\n", variable);
+               /* variable contains "varname=value" */
+               value = strchr(variable, '=');
+               if (!value) {
+                       value = "";
+               } else {
+                       *value++ = '\0';
+               }
+               pbx_builtin_setvar_helper(chan, variable, value);
+       }
+}
+
+static void ast_eivr_senddtmf(struct ast_channel *chan, char *vdata)
+{
+
+       char *data;
+       int dinterval = 0, duration = 0;
+       AST_DECLARE_APP_ARGS(args,
+               AST_APP_ARG(digits);
+               AST_APP_ARG(dinterval);
+               AST_APP_ARG(duration);
+       );
+
+       data = ast_strdupa(vdata);
+       AST_STANDARD_APP_ARGS(args, data);
+
+       if (!ast_strlen_zero(args.dinterval)) {
+               ast_app_parse_timelen(args.dinterval, &dinterval, TIMELEN_MILLISECONDS);
+       }
+       if (!ast_strlen_zero(args.duration)) {
+               ast_app_parse_timelen(args.duration, &duration, TIMELEN_MILLISECONDS);
+       }
+       ast_verb(4, "Sending DTMF: %s %d %d\n", args.digits, dinterval <= 0 ? 250 : dinterval, duration);
+       ast_dtmf_stream(chan, NULL, args.digits, dinterval <= 0 ? 250 : dinterval, duration);
+}
+
 static struct playlist_entry *make_entry(const char *filename)
 {
        struct playlist_entry *entry;
-       
-       if (!(entry = ast_calloc(1, sizeof(*entry) + strlen(filename) + 10)))
+
+       if (!(entry = ast_calloc(1, sizeof(*entry) + strlen(filename) + 10))) /* XXX why 10 ? */
                return NULL;
 
        strcpy(entry->filename, filename);
@@ -242,344 +387,535 @@ static struct playlist_entry *make_entry(const char *filename)
        return entry;
 }
 
-static int app_exec(struct ast_channel *chan, void *data)
+static int app_exec(struct ast_channel *chan, const char *data)
 {
-       struct localuser *u = NULL;
+       struct ast_flags flags = { 0, };
+       char *opts[0];
        struct playlist_entry *entry;
-       const char *args = data;
-       int child_stdin[2] = { 0,0 };
-       int child_stdout[2] = { 0,0 };
-       int child_stderr[2] = { 0,0 };
+       int child_stdin[2] = { -1, -1 };
+       int child_stdout[2] = { -1, -1 };
+       int child_stderr[2] = { -1, -1 };
        int res = -1;
-       int gen_active = 0;
        int pid;
-       char *argv[32];
-       int argc = 1;
-       char *buf, *command;
-       FILE *child_commands = NULL;
-       FILE *child_errors = NULL;
-       FILE *child_events = NULL;
-
-       LOCAL_USER_ADD(u);
-       
-       AST_LIST_HEAD_INIT(&u->playlist);
-       AST_LIST_HEAD_INIT(&u->finishlist);
+
+       struct ast_tcptls_session_instance *ser = NULL;
+
+       struct ivr_localuser foo = {
+               .playlist = AST_LIST_HEAD_INIT_VALUE,
+               .finishlist = AST_LIST_HEAD_INIT_VALUE,
+               .gen_active = 0,
+               .playing_silence = 1,
+       };
+       struct ivr_localuser *u = &foo;
+
+       char *buf;
+       int j;
+       char *s, **app_args, *e; 
+       struct ast_str *comma_delim_args = ast_str_alloca(100);
+
+       AST_DECLARE_APP_ARGS(eivr_args,
+               AST_APP_ARG(application);
+               AST_APP_ARG(options);
+       );
+       AST_DECLARE_APP_ARGS(application_args,
+               AST_APP_ARG(cmd)[32];
+       );
+
        u->abort_current_sound = 0;
-       
-       if (ast_strlen_zero(args)) {
-               ast_log(LOG_WARNING, "ExternalIVR requires a command to execute\n");
+       u->chan = chan;
+
+       if (ast_strlen_zero(data)) {
+               ast_log(LOG_ERROR, "ExternalIVR requires a command to execute\n");
                goto exit;
        }
 
        buf = ast_strdupa(data);
-       if (!buf) {
-               ast_log(LOG_ERROR, "Out of memory!\n");
-               LOCAL_USER_REMOVE(u);
-               return -1;
-       }
+       AST_STANDARD_APP_ARGS(eivr_args, buf);
 
-       argc = ast_app_separate_args(buf, '|', argv, sizeof(argv) / sizeof(argv[0]));
+       ast_verb(4, "ExternalIVR received application and arguments: %s\n", eivr_args.application);
+       ast_verb(4, "ExternalIVR received options: %s\n", eivr_args.options);
 
-       if (pipe(child_stdin)) {
-               ast_chan_log(LOG_WARNING, chan, "Could not create pipe for child input: %s\n", strerror(errno));
-               goto exit;
+       /* Parse out any application arguments */
+       if ((s = strchr(eivr_args.application, '('))) {
+               s[0] = ',';
+               if ((e = strrchr(s, ')'))) {
+                       *e = '\0';
+               } else {
+                       ast_log(LOG_ERROR, "Parse error, missing closing parenthesis\n");
+                       goto exit;
+               }
        }
 
-       if (pipe(child_stdout)) {
-               ast_chan_log(LOG_WARNING, chan, "Could not create pipe for child output: %s\n", strerror(errno));
-               goto exit;
+       AST_STANDARD_APP_ARGS(application_args, eivr_args.application);
+       app_args = application_args.argv;
+
+       /* Put the application + the arguments in a , delimited list */
+       ast_str_reset(comma_delim_args);
+       for (j = 0; application_args.cmd[j] != NULL; j++) {
+               ast_str_append(&comma_delim_args, 0, "%s%s", j == 0 ? "" : ",", application_args.cmd[j]);
        }
 
-       if (pipe(child_stderr)) {
-               ast_chan_log(LOG_WARNING, chan, "Could not create pipe for child errors: %s\n", strerror(errno));
-               goto exit;
+       /* Get rid of any extraneous arguments */
+       if (eivr_args.options && (s = strchr(eivr_args.options, ','))) {
+               *s = '\0';
        }
 
-       if (chan->_state != AST_STATE_UP) {
-               ast_answer(chan);
+       /* Parse the ExternalIVR() arguments */
+       ast_verb(4, "Parsing options from: [%s]\n", eivr_args.options);
+       ast_app_parse_options(app_opts, &flags, opts, eivr_args.options);
+       if (ast_test_flag(&flags, noanswer)) {
+               ast_verb(4, "noanswer is set\n");
+       }
+       if (ast_test_flag(&flags, ignore_hangup)) {
+               ast_verb(4, "ignore_hangup is set\n");
+       }
+       if (ast_test_flag(&flags, run_dead)) {
+               ast_verb(4, "run_dead is set\n");
+       }
+       
+       if (!(ast_test_flag(&flags, noanswer))) {
+               ast_verb(3, "Answering channel and starting generator\n");
+               if (ast_channel_state(chan) != AST_STATE_UP) {
+                       if (ast_test_flag(&flags, run_dead)) {
+                               ast_chan_log(LOG_ERROR, chan, "Running ExternalIVR with 'd'ead flag on non-hungup channel isn't supported\n");
+                               goto exit;
+                       }
+                       ast_answer(chan);
+               }
+               if (ast_activate_generator(chan, &gen, u) < 0) {
+                       ast_chan_log(LOG_ERROR, chan, "Failed to activate generator\n");
+                       goto exit;
+               } else {
+                       u->gen_active = 1;
+               }
        }
 
-       if (ast_activate_generator(chan, &gen, u) < 0) {
-               ast_chan_log(LOG_WARNING, chan, "Failed to activate generator\n");
-               goto exit;
-       } else
-               gen_active = 1;
+       if (!strncmp(app_args[0], "ivr://", sizeof("ivr://") - 1)) {
+               struct ast_tcptls_session_args ivr_desc = {
+                       .accept_fd = -1,
+                       .name = "IVR",
+               };
+               struct ast_sockaddr *addrs;
+               int num_addrs = 0, i = 0;
+               char *host = app_args[0] + sizeof("ivr://") - 1;
 
-       pid = fork();
-       if (pid < 0) {
-               ast_log(LOG_WARNING, "Failed to fork(): %s\n", strerror(errno));
-               goto exit;
-       }
+               /* Communicate through socket to server */
+               ast_debug(1, "Parsing hostname/port for socket connect from \"%s\"\n", host);
 
-       if (!pid) {
-               /* child process */
-               int i;
+               if (!(num_addrs = ast_sockaddr_resolve(&addrs, host, 0, AST_AF_UNSPEC))) {
+                       ast_chan_log(LOG_ERROR, chan, "Unable to locate host '%s'\n", host);
+                       goto exit;
+               }
 
-               dup2(child_stdin[0], STDIN_FILENO);
-               dup2(child_stdout[1], STDOUT_FILENO);
-               dup2(child_stderr[1], STDERR_FILENO);
-               for (i = STDERR_FILENO + 1; i < 1024; i++)
-                       close(i);
-               execv(argv[0], argv);
-               fprintf(stderr, "Failed to execute '%s': %s\n", argv[0], strerror(errno));
-               exit(1);
-       } else {
-               /* parent process */
-               int child_events_fd = child_stdin[1];
-               int child_commands_fd = child_stdout[0];
-               int child_errors_fd = child_stderr[0];
-               struct ast_frame *f;
-               int ms;
-               int exception;
-               int ready_fd;
-               int waitfds[2] = { child_errors_fd, child_commands_fd };
-               struct ast_channel *rchan;
+               for (i = 0; i < num_addrs; i++) {
+                       if (!ast_sockaddr_port(&addrs[i])) {
+                               /* Default port if not specified */
+                               ast_sockaddr_set_port(&addrs[i], EXTERNALIVR_PORT);
+                       }
+                       ast_sockaddr_copy(&ivr_desc.remote_address, &addrs[i]);
+                       if (!(ser = ast_tcptls_client_create(&ivr_desc)) || !(ser = ast_tcptls_client_start(ser))) {
+                               continue;
+                       }
+                       break;
+               }
 
-               close(child_stdin[0]);
-               child_stdin[0] = 0;
-               close(child_stdout[1]);
-               child_stdout[1] = 0;
-               close(child_stderr[1]);
-               child_stderr[1] = 0;
+               ast_free(addrs);
 
-               if (!(child_events = fdopen(child_events_fd, "w"))) {
-                       ast_chan_log(LOG_WARNING, chan, "Could not open stream for child events\n");
+               if (i == num_addrs) {
+                       ast_chan_log(LOG_ERROR, chan, "Could not connect to any host.  ExternalIVR failed.\n");
                        goto exit;
                }
 
-               if (!(child_commands = fdopen(child_commands_fd, "r"))) {
-                       ast_chan_log(LOG_WARNING, chan, "Could not open stream for child commands\n");
+               res = eivr_comm(chan, u, &ser->fd, &ser->fd, NULL, comma_delim_args, flags);
+
+       } else {
+               if (pipe(child_stdin)) {
+                       ast_chan_log(LOG_ERROR, chan, "Could not create pipe for child input: %s\n", strerror(errno));
                        goto exit;
                }
-
-               if (!(child_errors = fdopen(child_errors_fd, "r"))) {
-                       ast_chan_log(LOG_WARNING, chan, "Could not open stream for child errors\n");
+               if (pipe(child_stdout)) {
+                       ast_chan_log(LOG_ERROR, chan, "Could not create pipe for child output: %s\n", strerror(errno));
+                       goto exit;
+               }
+               if (pipe(child_stderr)) {
+                       ast_chan_log(LOG_ERROR, chan, "Could not create pipe for child errors: %s\n", strerror(errno));
+                       goto exit;
+               }
+       
+               pid = ast_safe_fork(0);
+               if (pid < 0) {
+                       ast_log(LOG_ERROR, "Failed to fork(): %s\n", strerror(errno));
                        goto exit;
                }
+       
+               if (!pid) {
+                       /* child process */
+                       if (ast_opt_high_priority)
+                               ast_set_priority(0);
+       
+                       dup2(child_stdin[0], STDIN_FILENO);
+                       dup2(child_stdout[1], STDOUT_FILENO);
+                       dup2(child_stderr[1], STDERR_FILENO);
+                       ast_close_fds_above_n(STDERR_FILENO);
+                       execv(app_args[0], app_args);
+                       fprintf(stderr, "Failed to execute '%s': %s\n", app_args[0], strerror(errno));
+                       _exit(1);
+               } else {
+                       /* parent process */
+                       close(child_stdin[0]);
+                       child_stdin[0] = -1;
+                       close(child_stdout[1]);
+                       child_stdout[1] = -1;
+                       close(child_stderr[1]);
+                       child_stderr[1] = -1;
+                       res = eivr_comm(chan, u, &child_stdin[1], &child_stdout[0], &child_stderr[0], comma_delim_args, flags);
+               }
+       }
 
-               setvbuf(child_events, NULL, _IONBF, 0);
-               setvbuf(child_commands, NULL, _IONBF, 0);
-               setvbuf(child_errors, NULL, _IONBF, 0);
+       exit:
+       if (u->gen_active) {
+               ast_deactivate_generator(chan);
+       }
+       if (child_stdin[0] > -1) {
+               close(child_stdin[0]);
+       }
+       if (child_stdin[1] > -1) {
+               close(child_stdin[1]);
+       }
+       if (child_stdout[0] > -1) {
+               close(child_stdout[0]);
+       }
+       if (child_stdout[1] > -1) {
+               close(child_stdout[1]);
+       }
+       if (child_stderr[0] > -1) {
+               close(child_stderr[0]);
+       }
+       if (child_stderr[1] > -1) {
+               close(child_stderr[1]);
+       }
+       if (ser) {
+               ao2_ref(ser, -1);
+       }
+       while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+               ast_free(entry);
+       }
+       return res;
+}
 
-               res = 0;
+static int eivr_comm(struct ast_channel *chan, struct ivr_localuser *u, 
+                               int *eivr_events_fd, int *eivr_commands_fd, int *eivr_errors_fd, 
+                               const struct ast_str *args, const struct ast_flags flags)
+{
+       struct playlist_entry *entry;
+       struct ast_frame *f;
+       int ms;
+       int exception;
+       int ready_fd;
+       int waitfds[2] = { *eivr_commands_fd, (eivr_errors_fd) ? *eivr_errors_fd : -1 };
+       struct ast_channel *rchan;
+       int res = -1;
+       int test_available_fd = -1;
+       int hangup_info_sent = 0;
+  
+       FILE *eivr_commands = NULL;
+       FILE *eivr_errors = NULL;
+       FILE *eivr_events = NULL;
+
+       if (!(eivr_events = fdopen(*eivr_events_fd, "w"))) {
+               ast_chan_log(LOG_ERROR, chan, "Could not open stream to send events\n");
+               goto exit;
+       }
+       if (!(eivr_commands = fdopen(*eivr_commands_fd, "r"))) {
+               ast_chan_log(LOG_ERROR, chan, "Could not open stream to receive commands\n");
+               goto exit;
+       }
+       if (eivr_errors_fd) {  /* if opening a socket connection, error stream will not be used */
+               if (!(eivr_errors = fdopen(*eivr_errors_fd, "r"))) {
+                       ast_chan_log(LOG_ERROR, chan, "Could not open stream to receive errors\n");
+                       goto exit;
+               }
+       }
 
-               while (1) {
-                       if (ast_test_flag(chan, AST_FLAG_ZOMBIE)) {
-                               ast_chan_log(LOG_NOTICE, chan, "Is a zombie\n");
-                               res = -1;
-                               break;
-                       }
+       test_available_fd = open("/dev/null", O_RDONLY);
+       setvbuf(eivr_events, NULL, _IONBF, 0);
+       setvbuf(eivr_commands, NULL, _IONBF, 0);
+       if (eivr_errors) {
+               setvbuf(eivr_errors, NULL, _IONBF, 0);
+       }
 
-                       if (ast_check_hangup(chan)) {
-                               ast_chan_log(LOG_NOTICE, chan, "Got check_hangup\n");
-                               send_child_event(child_events, 'H', NULL, chan);
-                               res = -1;
-                               break;
+       while (1) {
+               if (ast_test_flag(ast_channel_flags(chan), AST_FLAG_ZOMBIE)) {
+                       ast_chan_log(LOG_ERROR, chan, "Is a zombie\n");
+                       break;
+               }
+               if (!hangup_info_sent && !(ast_test_flag(&flags, run_dead)) && ast_check_hangup(chan)) {
+                       if (ast_test_flag(&flags, ignore_hangup)) {
+                               ast_verb(3, "Got check_hangup, but ignore_hangup set so sending 'I' command\n");
+                               send_eivr_event(eivr_events, 'I', "HANGUP", chan);
+                               hangup_info_sent = 1;
+                       } else {
+                               ast_verb(3, "Got check_hangup\n");
+                               send_eivr_event(eivr_events, 'H', NULL, chan);
+                               break;
                        }
-
-                       ready_fd = 0;
-                       ms = 100;
-                       errno = 0;
-                       exception = 0;
-
-                       rchan = ast_waitfor_nandfds(&chan, 1, waitfds, 2, &exception, &ready_fd, &ms);
-
-                       if (!AST_LIST_EMPTY(&u->finishlist)) {
-                               AST_LIST_LOCK(&u->finishlist);
-                               while ((entry = AST_LIST_REMOVE_HEAD(&u->finishlist, list))) {
-                                       send_child_event(child_events, 'F', entry->filename, chan);
-                                       free(entry);
+               }
+               ready_fd = 0;
+               ms = 100;
+               errno = 0;
+               exception = 0;
+               rchan = ast_waitfor_nandfds(&chan, 1, waitfds, (eivr_errors_fd) ? 2 : 1, &exception, &ready_fd, &ms);
+               if (ast_channel_state(chan) == AST_STATE_UP && !AST_LIST_EMPTY(&u->finishlist)) {
+                       AST_LIST_LOCK(&u->finishlist);
+                       while ((entry = AST_LIST_REMOVE_HEAD(&u->finishlist, list))) {
+                               send_eivr_event(eivr_events, 'F', entry->filename, chan);
+                               ast_free(entry);
+                       }
+                       AST_LIST_UNLOCK(&u->finishlist);
+               }
+               if (ast_channel_state(chan) == AST_STATE_UP && !(ast_check_hangup(chan)) && rchan) {
+                       /* the channel has something */
+                       f = ast_read(chan);
+                       if (!f) {
+                               ast_verb(3, "Returned no frame\n");
+                               send_eivr_event(eivr_events, 'H', NULL, chan);
+                               break;
+                       }
+                       if (f->frametype == AST_FRAME_DTMF) {
+                               send_eivr_event(eivr_events, f->subclass.integer, NULL, chan);
+                               if (u->option_autoclear) {
+                                       AST_LIST_LOCK(&u->playlist);
+                                       if (!u->abort_current_sound && !u->playing_silence) {
+                                               /* send interrupted file as T data */
+                                               if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                                       send_eivr_event(eivr_events, 'T', entry->filename, chan);
+                                                       ast_free(entry);
+                                               }
+                                       }
+                                       while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                               send_eivr_event(eivr_events, 'D', entry->filename, chan);
+                                               ast_free(entry);
+                                       }
+                                       if (!u->playing_silence)
+                                               u->abort_current_sound = 1;
+                                       AST_LIST_UNLOCK(&u->playlist);
+                               }
+                       } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass.integer == AST_CONTROL_HANGUP)) {
+                               ast_verb(3, "Got AST_CONTROL_HANGUP\n");
+                               send_eivr_event(eivr_events, 'H', NULL, chan);
+                               if (f->data.uint32) {
+                                       ast_channel_hangupcause_set(chan, f->data.uint32);
                                }
-                               AST_LIST_UNLOCK(&u->finishlist);
+                               ast_frfree(f);
+                               break;
+                       }
+                       ast_frfree(f);
+               } else if (ready_fd == *eivr_commands_fd) {
+                       char input[1024];
+                       if (exception || (dup2(*eivr_commands_fd, test_available_fd) == -1) || feof(eivr_commands)) {
+                               ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
+                               break;
+                       }
+  
+                       if (!fgets(input, sizeof(input), eivr_commands)) {
+                               continue;
                        }
 
-                       if (rchan) {
-                               /* the channel has something */
-                               f = ast_read(chan);
-                               if (!f) {
-                                       ast_chan_log(LOG_NOTICE, chan, "Returned no frame\n");
-                                       send_child_event(child_events, 'H', NULL, chan);
-                                       res = -1;
-                                       break;
-                               }
+                       ast_strip(input);
+                       ast_verb(4, "got command '%s'\n", input);
 
-                               if (f->frametype == AST_FRAME_DTMF) {
-                                       send_child_event(child_events, f->subclass, NULL, chan);
-                                       if (u->option_autoclear) {
-                                               if (!u->abort_current_sound && !u->playing_silence)
-                                                       send_child_event(child_events, 'T', NULL, chan);
-                                               AST_LIST_LOCK(&u->playlist);
-                                               while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
-                                                       send_child_event(child_events, 'D', entry->filename, chan);
-                                                       free(entry);
-                                               }
-                                               if (!u->playing_silence)
-                                                       u->abort_current_sound = 1;
-                                               AST_LIST_UNLOCK(&u->playlist);
+                       if (strlen(input) < 3) {
+                               continue;
+                       }
+
+                       if (input[0] == EIVR_CMD_PARM) {
+                               struct ast_str *tmp = (struct ast_str *) args;
+                               send_eivr_event(eivr_events, 'P', ast_str_buffer(tmp), chan);
+                       } else if (input[0] == EIVR_CMD_DTMF) {
+                               ast_verb(4, "Sending DTMF: %s\n", &input[2]);
+                               ast_eivr_senddtmf(chan, &input[2]);
+                       } else if (input[0] == EIVR_CMD_ANS) {
+                               ast_verb(3, "Answering channel if needed and starting generator\n");
+                               if (ast_channel_state(chan) != AST_STATE_UP) {
+                                       if (ast_test_flag(&flags, run_dead)) {
+                                               ast_chan_log(LOG_WARNING, chan, "Running ExternalIVR with 'd'ead flag on non-hungup channel isn't supported\n");
+                                               send_eivr_event(eivr_events, 'Z', "ANSWER_FAILURE", chan);
+                                               continue;
+                                       }
+                                       if (ast_answer(chan)) {
+                                               ast_chan_log(LOG_WARNING, chan, "Failed to answer channel\n");
+                                               send_eivr_event(eivr_events, 'Z', "ANSWER_FAILURE", chan);
+                                               continue;
                                        }
-                               } else if ((f->frametype == AST_FRAME_CONTROL) && (f->subclass == AST_CONTROL_HANGUP)) {
-                                       ast_chan_log(LOG_NOTICE, chan, "Got AST_CONTROL_HANGUP\n");
-                                       send_child_event(child_events, 'H', NULL, chan);
-                                       ast_frfree(f);
-                                       res = -1;
-                                       break;
                                }
-                               ast_frfree(f);
-                       } else if (ready_fd == child_commands_fd) {
-                               char input[1024];
-
-                               if (exception || feof(child_commands)) {
-                                       ast_chan_log(LOG_WARNING, chan, "Child process went away\n");
-                                       res = -1;
-                                       break;
+                               if (!(u->gen_active)) {
+                                       if (ast_activate_generator(chan, &gen, u) < 0) {
+                                               ast_chan_log(LOG_WARNING, chan, "Failed to activate generator\n");
+                                               send_eivr_event(eivr_events, 'Z', "GENERATOR_FAILURE", chan);
+                                       } else {
+                                               u->gen_active = 1;
+                                       }
                                }
-
-                               if (!fgets(input, sizeof(input), child_commands))
+                       } else if (input[0] == EIVR_CMD_IRPT) {
+                               if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
+                                       ast_chan_log(LOG_WARNING, chan, "Queue 'I'nterrupt called on unanswered channel\n");
+                                       send_eivr_event(eivr_events, 'Z', NULL, chan);
                                        continue;
-
-                               command = ast_strip(input);
-
-                               ast_chan_log(LOG_DEBUG, chan, "got command '%s'\n", input);
-
-                               if (strlen(input) < 4)
+                               }
+                               AST_LIST_LOCK(&u->playlist);
+                               if (!u->abort_current_sound && !u->playing_silence) {
+                                       /* send interrupted file as T data */
+                                       if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                               send_eivr_event(eivr_events, 'T', entry->filename, chan);
+                                               ast_free(entry);
+                                       }
+                               }
+                               while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                       send_eivr_event(eivr_events, 'D', entry->filename, chan);
+                                       ast_free(entry);
+                               }
+                               if (!u->playing_silence) {
+                                       u->abort_current_sound = 1;
+                               }
+                               AST_LIST_UNLOCK(&u->playlist);
+                       } else if (input[0] == EIVR_CMD_SQUE) {
+                               if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
+                                       ast_chan_log(LOG_WARNING, chan, "Queue re'S'et called on unanswered channel\n");
+                                       send_eivr_event(eivr_events, 'Z', NULL, chan);
                                        continue;
-
-                               if (input[0] == 'S') {
-                                       if (ast_fileexists(&input[2], NULL, NULL) == -1) {
-                                               ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
-                                               send_child_event(child_events, 'Z', NULL, chan);
-                                               strcpy(&input[2], "exception");
+                               }
+                               if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
+                                       ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
+                                       send_eivr_event(eivr_events, 'Z', &input[2], chan);
+                               } else {
+                                       AST_LIST_LOCK(&u->playlist);
+                                       if (!u->abort_current_sound && !u->playing_silence) {
+                                               /* send interrupted file as T data */
+                                               if ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                                       send_eivr_event(eivr_events, 'T', entry->filename, chan);
+                                                       ast_free(entry);
+                                               }
                                        }
-                                       if (!u->abort_current_sound && !u->playing_silence)
-                                               send_child_event(child_events, 'T', NULL, chan);
-                                       AST_LIST_LOCK(&u->playlist);
-                                       while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
-                                               send_child_event(child_events, 'D', entry->filename, chan);
-                                               free(entry);
+                                       while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list))) {
+                                               send_eivr_event(eivr_events, 'D', entry->filename, chan);
+                                               ast_free(entry);
                                        }
-                                       if (!u->playing_silence)
-                                               u->abort_current_sound = 1;
-                                       entry = make_entry(&input[2]);
-                                       if (entry)
-                                               AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
-                                       AST_LIST_UNLOCK(&u->playlist);
-                               } else if (input[0] == 'A') {
-                                       if (ast_fileexists(&input[2], NULL, NULL) == -1) {
-                                               ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
-                                               send_child_event(child_events, 'Z', NULL, chan);
-                                               strcpy(&input[2], "exception");
+                                       if (!u->playing_silence) {
+                                               u->abort_current_sound = 1;
                                        }
-                                       entry = make_entry(&input[2]);
-                                       if (entry) {
-                                               AST_LIST_LOCK(&u->playlist);
-                                               AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
-                                               AST_LIST_UNLOCK(&u->playlist);
+                                       entry = make_entry(&input[2]);
+                                       if (entry) {
+                                               AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
                                        }
-                               } else if (input[0] == 'H') {
-                                       ast_chan_log(LOG_NOTICE, chan, "Hanging up: %s\n", &input[2]);
-                                       send_child_event(child_events, 'H', NULL, chan);
-                                       break;
-                               } else if (input[0] == 'O') {
-                                       if (!strcasecmp(&input[2], "autoclear"))
-                                               u->option_autoclear = 1;
-                                       else if (!strcasecmp(&input[2], "noautoclear"))
-                                               u->option_autoclear = 0;
-                                       else
-                                               ast_chan_log(LOG_WARNING, chan, "Unknown option requested '%s'\n", &input[2]);
+                                       AST_LIST_UNLOCK(&u->playlist);
                                }
-                       } else if (ready_fd == child_errors_fd) {
-                               char input[1024];
-
-                               if (exception || feof(child_errors)) {
-                                       ast_chan_log(LOG_WARNING, chan, "Child process went away\n");
-                                       res = -1;
-                                       break;
-                               }
-
-                               if (fgets(input, sizeof(input), child_errors)) {
-                                       command = ast_strip(input);
-                                       ast_chan_log(LOG_NOTICE, chan, "stderr: %s\n", command);
+                       } else if (input[0] == EIVR_CMD_APND) {
+                               if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
+                                       ast_chan_log(LOG_WARNING, chan, "Queue 'A'ppend called on unanswered channel\n");
+                                       send_eivr_event(eivr_events, 'Z', NULL, chan);
+                                       continue;
                                }
-                       } else if ((ready_fd < 0) && ms) { 
-                               if (errno == 0 || errno == EINTR)
+                               if (!ast_fileexists(&input[2], NULL, ast_channel_language(u->chan))) {
+                                       ast_chan_log(LOG_WARNING, chan, "Unknown file requested '%s'\n", &input[2]);
+                                       send_eivr_event(eivr_events, 'Z', &input[2], chan);
+                               } else {
+                                       entry = make_entry(&input[2]);
+                                       if (entry) {
+                                               AST_LIST_LOCK(&u->playlist);
+                                               AST_LIST_INSERT_TAIL(&u->playlist, entry, list);
+                                               AST_LIST_UNLOCK(&u->playlist);
+                                       }
+                               }
+                       } else if (input[0] == EIVR_CMD_GET) {
+                               char response[2048];
+                               ast_verb(4, "Retriving Variables from channel: %s\n", &input[2]);
+                               ast_eivr_getvariable(chan, &input[2], response, sizeof(response));
+                               send_eivr_event(eivr_events, 'G', response, chan);
+                       } else if (input[0] == EIVR_CMD_SVAR) {
+                               ast_verb(4, "Setting Variables in channel: %s\n", &input[2]);
+                               ast_eivr_setvariable(chan, &input[2]);
+                       } else if (input[0] == EIVR_CMD_LOG) {
+                               ast_chan_log(LOG_NOTICE, chan, "Log message from EIVR: %s\n", &input[2]);
+                       } else if (input[0] == EIVR_CMD_XIT) {
+                               ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
+                               ast_chan_log(LOG_WARNING, chan, "e'X'it command is depricated, use 'E'xit instead\n");
+                               res = 0;
+                               break;
+                       } else if (input[0] == EIVR_CMD_EXIT) {
+                               ast_chan_log(LOG_NOTICE, chan, "Exiting: %s\n", &input[2]);
+                               send_eivr_event(eivr_events, 'E', NULL, chan);
+                               res = 0;
+                               break;
+                       } else if (input[0] == EIVR_CMD_HGUP) {
+                               ast_chan_log(LOG_NOTICE, chan, "Hanging up: %s\n", &input[2]);
+                               send_eivr_event(eivr_events, 'H', NULL, chan);
+                               break;
+                       } else if (input[0] == EIVR_CMD_OPT) {
+                               if (ast_channel_state(chan) != AST_STATE_UP || ast_check_hangup(chan)) {
+                                       ast_chan_log(LOG_WARNING, chan, "Option called on unanswered channel\n");
+                                       send_eivr_event(eivr_events, 'Z', NULL, chan);
                                        continue;
-
-                               ast_chan_log(LOG_WARNING, chan, "Wait failed (%s)\n", strerror(errno));
-                               break;
-                       }
-               }
+                               }
+                               if (!strcasecmp(&input[2], "autoclear"))
+                                       u->option_autoclear = 1;
+                               else if (!strcasecmp(&input[2], "noautoclear"))
+                                       u->option_autoclear = 0;
+                               else
+                                       ast_chan_log(LOG_WARNING, chan, "Unknown option requested: %s\n", &input[2]);
+                       }
+               } else if (eivr_errors_fd && (ready_fd == *eivr_errors_fd)) {
+                       char input[1024];
+  
+                       if (exception || feof(eivr_errors)) {
+                               ast_chan_log(LOG_ERROR, chan, "Child process went away\n");
+                               break;
+                       }
+                       if (fgets(input, sizeof(input), eivr_errors)) {
+                               ast_chan_log(LOG_NOTICE, chan, "stderr: %s\n", ast_strip(input));
+                       }
+               } else if ((ready_fd < 0) && ms) { 
+                       if (errno == 0 || errno == EINTR)
+                               continue;
+                       ast_chan_log(LOG_ERROR, chan, "Wait failed (%s)\n", strerror(errno));
+                       break;
+               }
+       }
+       exit:
+       if (test_available_fd > -1) {
+               close(test_available_fd);
        }
-
- exit:
-       if (gen_active)
-               ast_deactivate_generator(chan);
-
-       if (child_events)
-               fclose(child_events);
-
-       if (child_commands)
-               fclose(child_commands);
-
-       if (child_errors)
-               fclose(child_errors);
-
-       if (child_stdin[0])
-               close(child_stdin[0]);
-
-       if (child_stdin[1])
-               close(child_stdin[1]);
-
-       if (child_stdout[0])
-               close(child_stdout[0]);
-
-       if (child_stdout[1])
-               close(child_stdout[1]);
-
-       if (child_stderr[0])
-               close(child_stderr[0]);
-
-       if (child_stderr[1])
-               close(child_stderr[1]);
-
-       while ((entry = AST_LIST_REMOVE_HEAD(&u->playlist, list)))
-               free(entry);
-
-       LOCAL_USER_REMOVE(u);
-
-       return res;
-}
-
-int unload_module(void)
-{
-       int res;
-
-       res = ast_unregister_application(app);
-
-       STANDARD_HANGUP_LOCALUSERS;
-
-       return res;
+       if (eivr_events) {
+               fclose(eivr_events);
+               *eivr_events_fd = -1;
+       }
+       if (eivr_commands) {
+               fclose(eivr_commands);
+               *eivr_commands_fd = -1;
+       }
+       if (eivr_errors) {
+               fclose(eivr_errors);
+               *eivr_errors_fd = -1;
+       }
+       return res;
 }
 
-int load_module(void)
+static int unload_module(void)
 {
-       return ast_register_application(app, app_exec, synopsis, descrip);
+       return ast_unregister_application(app);
 }
 
-char *description(void)
+static int load_module(void)
 {
-       return (char *) tdesc;
+       return ast_register_application_xml(app, app_exec);
 }
 
-int usecount(void)
-{
-       int res;
-
-       STANDARD_USECOUNT(res);
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "External IVR Interface Application");
 
-       return res;
-}
-
-char *key()
-{
-       return ASTERISK_GPL_KEY;
-}