/*

    Terminal Mixer - multi-point multi-user access to terminal applications

    Copyright (C) 2007  Lluís Batlle i Rossell

    Please find the license in the provided COPYING file.

*/

#include <signal.h>

#include <string.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <assert.h>

#include "main.h"

#include "handlers.h"

static int child;

int child_died;

static char old_alarm_handler_set;

static struct sigaction old_alarm_handler;

static int timeout_timed_out; 

static void forward_signals_to_child_handler(int val)

{

    kill(child, val);

}

static void sig_child_died(int val)

{

    int status; 

    int res;

    assert(child_died == 0);

    res = wait(&status);

    if (WIFEXITED(status) || WIFSIGNALED(status))

    {

        debugmsg("Child exited");

        child_died = 1;

    }

    debugmsg("Child handler");

}

static void update_window_size(int val)

{

    char *xterm_str;

    int len;

    pass_winsize_to_slave();

    kill(child, val);

    /* Resend the xterm string */

    xterm_str = get_xterm_resize_string();

    len = strlen(xterm_str);

    if (command_line.s_param.serve_unix)

        s_unix_send_to_connected(xterm_str, len);

    if (command_line.s_param.serve_tcp)

        s_tcp_send_to_connected(xterm_str, len);

#ifdef linux

    if (command_line.s_param.serve_eth)

        s_eth_send_to_connected(xterm_str, len);

#endif /* linux */

}

void install_signal_forwarders(int _child)

{

    struct sigaction act;

    child = _child;

    act.sa_handler = forward_signals_to_child_handler;

    sigemptyset(&act.sa_mask);

    act.sa_flags = 0;

    sigaction(SIGTERM, &act, 0);

    sigaction(SIGINT, &act, 0);

    act.sa_handler = update_window_size;

    sigaction(SIGWINCH, &act, 0);

    act.sa_handler = sig_child_died;

    act.sa_flags = SA_NOCLDSTOP;

    sigaction(SIGCHLD, &act, 0);

}

static void alarm_handler(int x)

{

    timeout_timed_out = 1;

    dump_line("Timeout timed out.");

}

void program_timeout(int secs)

{

    struct sigaction act;

    struct sigaction *old;

    int res;

    dump_line("Programming timeout for %i seconds.\n", secs);

    sigemptyset(&act.sa_mask);

    act.sa_flags = 0;

    act.sa_handler = alarm_handler;

    if (old_alarm_handler_set)

        old = 0;

    else

        old = &old_alarm_handler;

    res = sigaction(SIGALRM, &act, old);

    if (res == -1)

        error("Sigaction SIGALRM failed");

    old_alarm_handler_set = 1;

    timeout_timed_out = 0;

    alarm(secs);

}

int did_timeout_happen()

{

    return timeout_timed_out;

}

void unprogram_timeout()

{

    alarm(0);

    dump_line("Unprogramming timeout");

    timeout_timed_out = 0;

    if (old_alarm_handler_set)

    {

        sigaction(SIGALRM, &old_alarm_handler, 0);

        old_alarm_handler_set = 0;

    }

}

void ignore_sighup()

{

    struct sigaction act;

    act.sa_handler = SIG_IGN;

    sigemptyset(&act.sa_mask);

    act.sa_flags = 0;

    sigaction(SIGHUP, &act, 0);

}