#include <stdio.h>

#include <stdlib.h>

#include <sys/select.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>

#include "dictre.h"

extern struct Def defs[];

extern int ndefs;

extern int dont_touch[];

extern int ndont_touch;

static void more_memory(void **ptr, int size)

{

    void *new;

    new = realloc(*ptr, size);

    *ptr = new;

}

static

char * manage_filter(const char *def, int deflen, int writeto, int readfrom,

        int *outlen)

{

    int maxfd;

    int defptr;

    int outptr;

    char *out;

    int outsize;

    int outrest;

    out = 0;

    outsize = 1000;

    outptr = 0;

    more_memory((void **) &out, outsize);

    outrest = 1000;

    maxfd = writeto;

    if (readfrom > maxfd)

        maxfd = readfrom;

    defptr = 0;

    do

    {

        fd_set writeset, readset;

        FD_ZERO(&writeset);

        FD_ZERO(&readset);

        if (defptr < deflen)

            FD_SET(writeto, &writeset);

        FD_SET(readfrom, &readset);

        select(maxfd+1, &readset, &writeset, 0, 0);

        if (FD_ISSET(readfrom, &readset))

        {

            int res;

            res = read(readfrom, out + outptr, outrest);

            if (res == 0)

            {

                close(readfrom);

                break;

            }

            outrest -= res;

            outptr += res;

            if (outrest == 0)

            {

                outrest = 1000;

                outsize += 1000;

                more_memory((void **) &out, outsize);

            }

        }

        if (FD_ISSET(writeto, &writeset))

        {

            int res;

            res = write(writeto, def+defptr, 1);

            defptr++;

            if (defptr >= deflen)

                close(writeto);

        }

    } while(1);

    if (defptr < deflen)

    {

        fprintf(stderr, "Error in filter! not all written.\n");

        exit(-1);

    }

    *outlen = outptr;

    return out;

}

static char * filter(char *def, int deflen, const char *filter_par, int *outlen)

{

    int write_pipe[2];

    int read_pipe[2];

    int pid;

    int res;

    int status;

    char *out;

    pipe(write_pipe);

    pipe(read_pipe);

    pid = fork();

    switch(pid)

    {

        case 0:  /* child */

            close(0);

            dup(write_pipe[0]);

            close(write_pipe[0]);

            close(write_pipe[1]);

            close(1);

            dup(read_pipe[1]);

            close(read_pipe[1]);

            close(read_pipe[0]);

            execlp("bash", "bash", "-c", filter_par, 0);

            perror("execlp");

            exit(-1);

            break;

        case -1:

            perror("fork");

            exit(-1);

            break;

        default:  /* parent */

            close(write_pipe[0]);

            close(read_pipe[1]);

            break;

    }

    /* parent */

    out = manage_filter(def, deflen, write_pipe[1], read_pipe[0], outlen);

    res = wait(&status);

    if (res != pid || WEXITSTATUS(status) != 0)

    {

        fprintf(stderr, "Error filtering: pid=%i status=%i",

                pid, WEXITSTATUS(status));

        exit(-1);

    }

    return out;

}

static int in_dont_touch(int n)

{

    int i;

    for(i =0; i < ndont_touch; ++i)

    {

        if (n == dont_touch[i])

        {

            return 1;

        }

    }

    return 0;

}

void filter_all(const char *filter_par)

{

    int i;

    for(i=0; i < ndefs; ++i)

    {

        char *newdef;

        int newdeflen;

        if (!in_dont_touch(i))

        {

            newdef = filter(defs[i].d, defs[i].length,

                    filter_par, &newdeflen);

            defs[i].length = newdeflen;

            defs[i].d = newdef;

        }

    }

}