app_festival.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2002, Christos Ricudis
 *
 * Christos Ricudis <ricudis@itc.auth.gr>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */
 
/*! \file
 *
 * \brief Connect to festival
 *
 * \author Christos Ricudis <ricudis@itc.auth.gr>
 *
 * \extref  The Festival Speech Synthesis System - http://www.cstr.ed.ac.uk/projects/festival/
 *
 * \ingroup applications
 */
 
/*! \li \ref app_festival.c uses the configuration file \ref festival.conf
 * \addtogroup configuration_file Configuration Files
 */
 
/*!
 * \page festival.conf festival.conf
 * \verbinclude festival.conf.sample
 */
 
/*** MODULEINFO
    <support_level>extended</support_level>
 ***/
 
#include "asterisk.h"
 
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <errno.h>
 
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/module.h"
#include "asterisk/md5.h"
#include "asterisk/config.h"
#include "asterisk/utils.h"
#include "asterisk/lock.h"
#include "asterisk/app.h"
#include "asterisk/endian.h"
#include "asterisk/format_cache.h"
 
#define FESTIVAL_CONFIG "festival.conf"
#define MAXLEN 180
#define MAXFESTLEN 2048
 
/*** DOCUMENTATION
    <application name="Festival" language="en_US">
        <synopsis>
            Say text to the user.
        </synopsis>
        <syntax>
            <parameter name="text" required="true" />
            <parameter name="intkeys" />
        </syntax>
        <description>
            <para>Connect to Festival, send the argument, get back the waveform, play it to the user,
            allowing any given interrupt keys to immediately terminate and return the value, or
            <literal>any</literal> to allow any number back (useful in dialplan).</para>
        </description>
    </application>
 ***/
 
static char *app = "Festival";
 
static char *socket_receive_file_to_buff(int fd, int *size)
{
    /* Receive file (probably a waveform file) from socket using
     * Festival key stuff technique, but long winded I know, sorry
     * but will receive any file without closing the stream or
     * using OOB data
     */
    static char *file_stuff_key = "ft_StUfF_key"; /* must == Festival's key */
    char *buff, *tmp;
    int bufflen;
    int n,k,i;
    char c;
 
    bufflen = 1024;
    if (!(buff = ast_malloc(bufflen)))
        return NULL;
    *size = 0;
 
    for (k = 0; file_stuff_key[k] != '\0';) {
        n = read(fd, &c, 1);
        if (n == 0)
            break;  /* hit stream eof before end of file */
        if ((*size) + k + 1 >= bufflen) {
            /* +1 so you can add a terminating NULL if you want */
            bufflen += bufflen / 4;
            if (!(tmp = ast_realloc(buff, bufflen))) {
                ast_free(buff);
                return NULL;
            }
            buff = tmp;
        }
        if (file_stuff_key[k] == c)
            k++;
        else if ((c == 'X') && (file_stuff_key[k+1] == '\0')) {
            /* It looked like the key but wasn't */
            for (i = 0; i < k; i++, (*size)++)
                buff[*size] = file_stuff_key[i];
            k = 0;
            /* omit the stuffed 'X' */
        } else {
            for (i = 0; i < k; i++, (*size)++)
                buff[*size] = file_stuff_key[i];
            k = 0;
            buff[*size] = c;
            (*size)++;
        }
    }
 
    return buff;
}
 
static int send_waveform_to_fd(char *waveform, int length, int fd)
{
    int res;
#if __BYTE_ORDER == __BIG_ENDIAN
    int x;
    char c;
#endif
 
    res = ast_safe_fork(0);
    if (res < 0)
        ast_log(LOG_WARNING, "Fork failed\n");
    if (res) {
        return res;
    }
    dup2(fd, 0);
    ast_close_fds_above_n(0);
    if (ast_opt_high_priority)
        ast_set_priority(0);
#if __BYTE_ORDER == __BIG_ENDIAN
    for (x = 0; x < length; x += 2) {
        c = *(waveform + x + 1);
        *(waveform + x + 1) = *(waveform + x);
        *(waveform + x) = c;
    }
#endif
 
    if (write(0, waveform, length) < 0) {
        /* Cannot log -- all FDs are already closed */
    }
 
    close(fd);
    _exit(0);
}
 
static int send_waveform_to_channel(struct ast_channel *chan, char *waveform, int length, char *intkeys)
{
    int res = 0;
    int fds[2];
    int needed = 0;
    struct ast_format *owriteformat;
    struct ast_frame *f;
    struct myframe {
        struct ast_frame f;
        char offset[AST_FRIENDLY_OFFSET];
        char frdata[2048];
    } myf = {
        .f = { 0, },
    };
 
    if (pipe(fds)) {
        ast_log(LOG_WARNING, "Unable to create pipe\n");
        return -1;
    }
 
    /* Answer if it's not already going */
    if (ast_channel_state(chan) != AST_STATE_UP)
        ast_answer(chan);
    ast_stopstream(chan);
    ast_indicate(chan, -1);
 
    owriteformat = ao2_bump(ast_channel_writeformat(chan));
    res = ast_set_write_format(chan, ast_format_slin);
    if (res < 0) {
        ast_log(LOG_WARNING, "Unable to set write format to signed linear\n");
        ao2_cleanup(owriteformat);
        return -1;
    }
 
    myf.f.frametype = AST_FRAME_VOICE;
    myf.f.subclass.format = ast_format_slin;
    myf.f.offset = AST_FRIENDLY_OFFSET;
    myf.f.src = __PRETTY_FUNCTION__;
    myf.f.data.ptr = myf.frdata;
 
    res = send_waveform_to_fd(waveform, length, fds[1]);
    if (res >= 0) {
        /* Order is important -- there's almost always going to be mp3...  we want to prioritize the
           user */
        for (;;) {
            res = ast_waitfor(chan, 1000);
            if (res < 1) {
                res = -1;
                break;
            }
            f = ast_read(chan);
            if (!f) {
                ast_log(LOG_WARNING, "Null frame == hangup() detected\n");
                res = -1;
                break;
            }
            if (f->frametype == AST_FRAME_DTMF) {
                ast_debug(1, "User pressed a key\n");
                if (intkeys && strchr(intkeys, f->subclass.integer)) {
                    res = f->subclass.integer;
                    ast_frfree(f);
                    break;
                }
            }
            if (f->frametype == AST_FRAME_VOICE) {
                /* Treat as a generator */
                needed = f->samples * 2;
                if (needed > sizeof(myf.frdata)) {
                    ast_log(LOG_WARNING, "Only able to deliver %d of %d requested samples\n",
                        (int)sizeof(myf.frdata) / 2, needed/2);
                    needed = sizeof(myf.frdata);
                }
                res = read(fds[0], myf.frdata, needed);
                if (res > 0) {
                    myf.f.datalen = res;
                    myf.f.samples = res / 2;
                    if (ast_write(chan, &myf.f) < 0) {
                        res = -1;
                        ast_frfree(f);
                        break;
                    }
                    if (res < needed) { /* last frame */
                        ast_debug(1, "Last frame\n");
                        res = 0;
                        ast_frfree(f);
                        break;
                    }
                } else {
                    ast_debug(1, "No more waveform\n");
                    res = 0;
                }
            }
            ast_frfree(f);
        }
    }
    close(fds[0]);
    close(fds[1]);
 
    if (!res && owriteformat)
        ast_set_write_format(chan, owriteformat);
    ao2_cleanup(owriteformat);
 
    return res;
}
 
static int festival_exec(struct ast_channel *chan, const char *vdata)
{
    int usecache;
    int res = 0;
    struct sockaddr_in serv_addr;
    int fd;
    FILE *fs;
    const char *host;
    const char *cachedir;
    const char *temp;
    const char *festivalcommand;
    int port = 1314;
    int n;
    char ack[4];
    char *waveform;
    int filesize;
    char bigstring[MAXFESTLEN];
    int i;
    struct MD5Context md5ctx;
    unsigned char MD5Res[16];
    char MD5Hex[33] = "";
    char koko[4] = "";
    char cachefile[MAXFESTLEN]="";
    int readcache = 0;
    int writecache = 0;
    int strln;
    int fdesc = -1;
    char buffer[16384];
    int seekpos = 0;
    char *data;
    struct ast_config *cfg;
    char *newfestivalcommand;
    struct ast_flags config_flags = { 0 };
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(text);
        AST_APP_ARG(interrupt);
    );
 
    if (ast_strlen_zero(vdata)) {
        ast_log(LOG_WARNING, "festival requires an argument (text)\n");
        return -1;
    }
 
    cfg = ast_config_load(FESTIVAL_CONFIG, config_flags);
    if (!cfg) {
        ast_log(LOG_WARNING, "No such configuration file %s\n", FESTIVAL_CONFIG);
        return -1;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file " FESTIVAL_CONFIG " is in an invalid format.  Aborting.\n");
        return -1;
    }
 
    if (!(host = ast_variable_retrieve(cfg, "general", "host"))) {
        host = "localhost";
    }
    if (!(temp = ast_variable_retrieve(cfg, "general", "port"))) {
        port = 1314;
    } else {
        port = atoi(temp);
    }
    if (!(temp = ast_variable_retrieve(cfg, "general", "usecache"))) {
        usecache = 0;
    } else {
        usecache = ast_true(temp);
    }
    if (!(cachedir = ast_variable_retrieve(cfg, "general", "cachedir"))) {
        cachedir = "/tmp/";
    }
 
    data = ast_strdupa(vdata);
    AST_STANDARD_APP_ARGS(args, data);
 
    if (!(festivalcommand = ast_variable_retrieve(cfg, "general", "festivalcommand"))) {
        const char *startcmd = "(tts_textasterisk \"";
        const char *endcmd = "\" 'file)(quit)\n";
 
        strln = strlen(startcmd) + strlen(args.text) + strlen(endcmd) + 1;
        newfestivalcommand = ast_alloca(strln);
        snprintf(newfestivalcommand, strln, "%s%s%s", startcmd, args.text, endcmd);
        festivalcommand = newfestivalcommand;
    } else { /* This else parses the festivalcommand that we're sent from the config file for \n's, etc */
        int x, j;
        newfestivalcommand = ast_alloca(strlen(festivalcommand) + strlen(args.text) + 1);
 
        for (x = 0, j = 0; x < strlen(festivalcommand); x++) {
            if (festivalcommand[x] == '\\' && festivalcommand[x + 1] == 'n') {
                newfestivalcommand[j++] = '\n';
                x++;
            } else if (festivalcommand[x] == '\\') {
                newfestivalcommand[j++] = festivalcommand[x + 1];
                x++;
            } else if (festivalcommand[x] == '%' && festivalcommand[x + 1] == 's') {
                sprintf(&newfestivalcommand[j], "%s", args.text); /* we know it is big enough */
                j += strlen(args.text);
                x++;
            } else
                newfestivalcommand[j++] = festivalcommand[x];
        }
        newfestivalcommand[j] = '\0';
        festivalcommand = newfestivalcommand;
    }
 
    if (args.interrupt && !strcasecmp(args.interrupt, "any"))
        args.interrupt = AST_DIGIT_ANY;
 
    ast_debug(1, "Text passed to festival server : %s\n", args.text);
    /* Connect to local festival server */
 
    fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
 
    if (fd < 0) {
        ast_log(LOG_WARNING, "festival_client: can't get socket\n");
        ast_config_destroy(cfg);
        return -1;
    }
 
    memset(&serv_addr, 0, sizeof(serv_addr));
 
    if ((serv_addr.sin_addr.s_addr = inet_addr(host)) == -1) {
        /* its a name rather than an ipnum */
        struct ast_sockaddr addr = { {0,} };
 
        if (ast_sockaddr_resolve_first_af(&addr, host, PARSE_PORT_FORBID, AF_INET)) {
            ast_log(LOG_WARNING, "festival_client: ast_sockaddr_resolve_first_af() failed\n");
            ast_config_destroy(cfg);
            close(fd);
            return -1;
        }
 
        /* We'll overwrite port and family in a sec */
        ast_sockaddr_to_sin(&addr, &serv_addr);
    }
 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(port);
 
    if (connect(fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) != 0) {
        ast_log(LOG_WARNING, "festival_client: connect to server failed\n");
        ast_config_destroy(cfg);
        close(fd);
        return -1;
    }
 
    /* Compute MD5 sum of string */
    MD5Init(&md5ctx);
    MD5Update(&md5ctx, (unsigned char *)args.text, strlen(args.text));
    MD5Final(MD5Res, &md5ctx);
    MD5Hex[0] = '\0';
 
    /* Convert to HEX and look if there is any matching file in the cache
        directory */
    for (i = 0; i < 16; i++) {
        snprintf(koko, sizeof(koko), "%X", (unsigned)MD5Res[i]);
        strncat(MD5Hex, koko, sizeof(MD5Hex) - strlen(MD5Hex) - 1);
    }
    readcache = 0;
    writecache = 0;
    if (strlen(cachedir) + sizeof(MD5Hex) + 1 <= MAXFESTLEN && (usecache == -1)) {
        snprintf(cachefile, sizeof(cachefile), "%s/%s", cachedir, MD5Hex);
        fdesc = open(cachefile, O_RDWR);
        if (fdesc == -1) {
            fdesc = open(cachefile, O_CREAT | O_RDWR, AST_FILE_MODE);
            if (fdesc != -1) {
                writecache = 1;
                strln = strlen(args.text);
                ast_debug(1, "line length : %d\n", strln);
                    if (write(fdesc,&strln,sizeof(int)) < 0) {
                    ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
                }
                    if (write(fdesc,data,strln) < 0) {
                    ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
                }
                seekpos = lseek(fdesc, 0, SEEK_CUR);
                ast_debug(1, "Seek position : %d\n", seekpos);
            }
        } else {
                if (read(fdesc,&strln,sizeof(int)) != sizeof(int)) {
                ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno));
            }
            ast_debug(1, "Cache file exists, strln=%d, strlen=%d\n", strln, (int)strlen(args.text));
            if (strlen(args.text) == strln) {
                ast_debug(1, "Size OK\n");
                    if (read(fdesc,&bigstring,strln) != strln) {
                    ast_log(LOG_WARNING, "read() failed: %s\n", strerror(errno));
                }
                bigstring[strln] = 0;
                if (strcmp(bigstring, args.text) == 0) {
                    readcache = 1;
                } else {
                    ast_log(LOG_WARNING, "Strings do not match\n");
                }
            } else {
                ast_log(LOG_WARNING, "Size mismatch\n");
            }
        }
    }
 
    if (readcache == 1) {
        close(fd);
        fd = fdesc;
        ast_debug(1, "Reading from cache...\n");
    } else {
        ast_debug(1, "Passing text to festival...\n");
        fs = fdopen(dup(fd), "wb");
 
        fprintf(fs, "%s", festivalcommand);
        fflush(fs);
        fclose(fs);
    }
 
    /* Write to cache and then pass it down */
    if (writecache == 1) {
        ast_debug(1, "Writing result to cache...\n");
        while ((strln = read(fd, buffer, 16384)) != 0) {
            if (write(fdesc,buffer,strln) < 0) {
                ast_log(LOG_WARNING, "write() failed: %s\n", strerror(errno));
            }
        }
        close(fd);
        close(fdesc);
        fd = open(cachefile, O_RDWR);
        lseek(fd, seekpos, SEEK_SET);
    }
 
    ast_debug(1, "Passing data to channel...\n");
 
    /* Read back info from server */
    /* This assumes only one waveform will come back, also LP is unlikely */
    do {
        int read_data;
        for (n = 0; n < 3; ) {
            read_data = read(fd, ack + n, 3 - n);
            /* this avoids falling in infinite loop
             * in case that festival server goes down
             */
            if (read_data == -1) {
                ast_log(LOG_WARNING, "Unable to read from cache/festival fd\n");
                close(fd);
                ast_config_destroy(cfg);
                return -1;
            }
            n += read_data;
        }
        ack[3] = '\0';
        if (strcmp(ack, "WV\n") == 0) {         /* receive a waveform */
            ast_debug(1, "Festival WV command\n");
            if ((waveform = socket_receive_file_to_buff(fd, &filesize))) {
                res = send_waveform_to_channel(chan, waveform, filesize, args.interrupt);
                ast_free(waveform);
            }
            break;
        } else if (strcmp(ack, "LP\n") == 0) {   /* receive an s-expr */
            ast_debug(1, "Festival LP command\n");
            if ((waveform = socket_receive_file_to_buff(fd, &filesize))) {
                waveform[filesize] = '\0';
                ast_log(LOG_WARNING, "Festival returned LP : %s\n", waveform);
                ast_free(waveform);
            }
        } else if (strcmp(ack, "ER\n") == 0) {    /* server got an error */
            ast_log(LOG_WARNING, "Festival returned ER\n");
            res = -1;
            break;
        }
    } while (strcmp(ack, "OK\n") != 0);
    close(fd);
    ast_config_destroy(cfg);
    return res;
}
 
static int unload_module(void)
{
    return ast_unregister_application(app);
}
 
/*!
 * \brief Load the module
 *
 * Module loading including tests for configuration or dependencies.
 * This function can return AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_DECLINE,
 * or AST_MODULE_LOAD_SUCCESS. If a dependency or environment variable fails
 * tests return AST_MODULE_LOAD_FAILURE. If the module can not load the
 * configuration file or other non-critical problem return
 * AST_MODULE_LOAD_DECLINE. On success return AST_MODULE_LOAD_SUCCESS.
 */
static int load_module(void)
{
    struct ast_flags config_flags = { 0 };
    struct ast_config *cfg = ast_config_load(FESTIVAL_CONFIG, config_flags);
    if (!cfg) {
        ast_log(LOG_WARNING, "No such configuration file %s\n", FESTIVAL_CONFIG);
        return AST_MODULE_LOAD_DECLINE;
    } else if (cfg == CONFIG_STATUS_FILEINVALID) {
        ast_log(LOG_ERROR, "Config file " FESTIVAL_CONFIG " is in an invalid format.  Aborting.\n");
        return AST_MODULE_LOAD_DECLINE;
    }
    ast_config_destroy(cfg);
    return ast_register_application_xml(app, festival_exec);
}
 
AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "Simple Festival Interface");