#include <sys/types.h>

#include <unistd.h>

#include <errno.h>

#include <fcntl.h>

#include <string.h>

#include <sys/select.h>

#include <sys/ioctl.h>

#include <termios.h>

#include <pty.h>

#include "main.h"

enum

{

    STDIN,

    STDOUT,

    STDERR

};

static void set_close_on_exec(int fd)

{

    int res;

    res = fcntl(fd, F_SETFD, FD_CLOEXEC);

    if (res == -1)

        error("Set close-on-exec failed");

}

static void give_terminal(int parent[], int child[])

{

    struct termios tios;

    struct winsize wsize;

    int res;

    int master, slave;

    res = tcgetattr(1, &tios);

    if (res == -1)

        error("tcgetatttr");

    res = ioctl(1, TIOCGWINSZ, &wsize);

    if (res == -1)

        error("ioctl TIOCGWINSZ");

    res = openpty(&master, &slave, 0, &tios, &wsize);

    if (res == -1)

        error("openpty");

    parent[STDIN]  = master;

    parent[STDOUT] = master;

    parent[STDERR] = master;

    child[STDIN]  = slave;

    child[STDOUT] = slave;

    child[STDERR] = slave;

    set_close_on_exec(master);

    set_close_on_exec(slave);

}

static void give_pipes(int parent[], int child[])

{

    int p_stdin[2]; /* from us to mpg321 */

    int p_stdout[2]; /* from mpg321 to us */

    int p_stderr[2]; /* from mpg321 to us, its stderr */

    pipe(p_stdin);

    pipe(p_stdout);

    pipe(p_stderr);

    parent[STDIN]  = p_stdin[1];

    parent[STDOUT] = p_stdout[0];

    parent[STDERR] = p_stderr[0];

    child[STDIN]   = p_stdin[0];

    child[STDOUT]  = p_stdout[1];

    child[STDERR]  = p_stderr[1];

    set_close_on_exec(parent[STDIN]);

    set_close_on_exec(parent[STDOUT]);

    set_close_on_exec(parent[STDERR]);

    set_close_on_exec(child[STDIN]);

    set_close_on_exec(child[STDOUT]);

    set_close_on_exec(child[STDERR]);

}

int fork_app(char * const command[])

{

    int p_parent[3];

    int p_child[3];

    int pid;

    int res;

    if (command_line.s_param.run_in_subterminal)

        give_terminal(p_parent, p_child);

    else

        give_pipes(p_parent, p_child);

    /* globals */

    app_stdin  = p_parent[STDIN];  /* For us to write */

    app_stdout = p_parent[STDOUT]; /* For us to read */

    app_stderr = p_parent[STDERR]; /* For us to read */

    pid = fork();

    switch(pid)

    {

        case 0: /* child */

            res = dup2(p_child[STDIN], 0);

            if (res == -1) error("Dup2 stdin");

            res = dup2(p_child[STDOUT], 1);

            if (res == -1) error("Dup2 stdout");

            res = dup2(p_child[STDERR], 2);

            if (res == -1) error("Dup2 stderr");

            execvp(command[0], command);

            error("Cannot execvp %s", command[0]);

        case -1:

            error("Failed fork");

        default: /* parent */

            close(p_child[STDIN]);

            close(p_child[STDOUT]);

            close(p_child[STDERR]);

    }

    return pid;

}