/*
    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 <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/select.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <string.h>

#include "main.h"
#include "filter.h"
#include "handlers.h"

struct FilterRules *client_recv_fr = 0;
struct FilterRules *client_termin_fr = 0;

static void loop(Net_c_prepare_read_fdset net_prepare,
        Net_c_process_read_fdset net_process,
        Net_c_send net_send)
{
    fd_set read_set;
    sigset_t sigempty,signoalarm;
    int maxfd;
    int res;

    /* Prepare the sigset for blocking alarm */
    sigemptyset(&signoalarm);
    sigaddset(&signoalarm, SIGALRM);
    sigemptyset(&sigempty);

    do
    {
        FD_ZERO(&read_set);

        FD_SET(0, &read_set); /* stdin */
        maxfd = 0;

        net_prepare(&read_set, &maxfd);

        /* Prepare checking for timeout */
        sigprocmask(SIG_BLOCK, &signoalarm, 0);

#ifdef linux
        if (command_line.s_param.serve_eth)
        {
            int res;
            /* This will check if the timeout occurred,
             * and will not do anything otherwise.
               Will return false when the connection is lost. */
            res = eth_proto_process_timeouts();
            if (!res)
            {
                printf("Connection lost (no ACK received).\n");
                break;
            }
        }
#endif

        res = pselect(maxfd + 1, &read_set, 0, 0, 0, &sigempty);
#ifdef linux
        if (command_line.c_param.transport == ETHERNET)
            /* If there isn't a good result, we quit */
            if (!eth_proto_process_timeouts())
            {
                    printf("Connection lost (no ACK received).\n");
                    break;
            }
#endif
        if (res == -1)
        {
            if (errno == EINTR)
                continue;
            else
                error("Error in select()");
        }

        res = net_process(&read_set);
        if (res == -1) /* EOF */
            break;

        if (FD_ISSET(0, &read_set))
        {
            res = read(0, stream_buffer, stream_buffer_size);
            if (client_termin_fr)
            {
                int olen;
                /* We use ostream_buffer2 for data from the
                 * keyboard to the tm client, because
                 * *_client.c use the ostream_buffer for data
                 * from the server to us (tm client). */
                hex_dump("Client prefilter", stream_buffer, res);
                filter_stream(client_termin_fr, ostream_buffer2, &olen,
                        stream_buffer,
                        res);
                if (olen > 0)
                    net_send(ostream_buffer2, olen);
            }
            else
                net_send(stream_buffer, res);
            if (res == 0) /* EOF */
                break;
        }
    } while (1);
}

void filtercb_tildes(struct FilterRules *fr, const struct FFilter *ff,
        char *obuf, int *olen, const char *ibuf, int pos)
{
    dump_line("filtercb_tildes: '%c'\n", ibuf[pos+3]);
    if (ibuf[pos+3] == '.')
        kill(getpid(), SIGINT);
    else
    {
        obuf[(*olen)++] = '~';
        obuf[(*olen)++] = '~';
        obuf[(*olen)++] = '~';
    }
}

int client()
{
    Net_c_prepare_read_fdset net_prepare_read_fdset;
    Net_c_process_read_fdset net_process_read_fdset;
    Net_c_send net_send;

    /* Prepare the filter */
    {
        struct FFilter *ff;
        client_recv_fr = new_filter_rules();
        ff = new_ftelnet();
        add_ffilter(client_recv_fr, ff);
        if (command_line.c_param.raw_mode)
        {
            client_termin_fr = new_filter_rules();
            ff = new_ftildes();
            ff->callback = filtercb_tildes;
            add_ffilter(client_termin_fr, ff);
        }
    }

    if (command_line.c_param.transport == UNIX)
        /* Will be 'tcp', 'ether', ... */
    {
        c_unix_connect_socket();
        net_prepare_read_fdset = c_unix_prepare_read_fdset;
        net_process_read_fdset = c_unix_process_read_fdset;
        net_send = c_unix_send;
    }
#ifdef linux
    else if (command_line.c_param.transport == ETHERNET)
    {
        c_eth_init();
        net_prepare_read_fdset = c_eth_prepare_read_fdset;
        net_process_read_fdset = c_eth_process_read_fdset;
        net_send = c_eth_send_to_connected;
    }
#endif /* linux */

    if (command_line.c_param.raw_mode)
        prepare_user_terminal();

    loop(net_prepare_read_fdset, net_process_read_fdset, net_send);

    if (command_line.c_param.raw_mode)
        restore_user_terminal();

    return 0;
}