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

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

extern char *optarg;
extern int optind, opterr, optopt;

/* From main.h given external */
int app_stdin;
int app_stdout;
int app_stderr;

struct Command_line command_line;

static const char version[] = "0.4.1";

static int showhelp(const char *pname)
{
    printf("tm v%s - terminal mixer,  Copyright (C) 2007  "
            "Lluis Batlle i Rossell\n",
            version);
    printf("usage: %s [opts] [appcommand] [param1] [param2] ...\n", pname);
    printf(" If you give _appcommand_, it starts the application and\n");
    printf(" serves it through a Unix socket on $TM_SOCKET or "
            "/tmp/tm-socket.UID,\n");
    printf(" unless '-p' is used.\n");
    printf(" Without _appcomand_, starts a the Unix socket client.\n");
    printf("options: \n");
    printf(" -h     Show help.\n");
    printf(" -P     Run the child as connected to a pipe (default).\n");
    printf(" -t     Run the child as connected to a terminal (raw mode in "
        "client).\n");
    printf(" -n     Unlink the program from the terminal (as 'nohup').\n");
    printf(" -N MAX Serve at most MAX sockets for each transport (1 default)."
            "\n");
    printf(" -w     The remote clients can write to the application.\n");
    printf(" -C     The remote clients end will close app's stdin.\n");
    printf(" -p NUM Listen to tcp port NUM for 'telnet', and not listen to "
            "any\n"
           "        Unix socket.\n");
    printf(" -E     Echo remote input to the server terminal.\n");
#ifdef linux
    printf(" -e dev[:port] Also serve/connect using raw ethernet, device 'dev'.\n");
    printf(" -c adr Connect to address (MAC if eth).\n");
    printf(" -s fil Save the child stdin/stdout to the filename 'fil'.\n");
#endif /* linux */
    printf(" -x     Send xterm's resize control string to clients.\n");
    return 0;
}

static int my_getopt(int argc, char * argv[], const char *optstring)
{
    char *old_getopt_env;
    static char getopt_env[100] = "POSIXLY_CORRECT=YES";
    int res;

    old_getopt_env = getenv("POSIXLY_CORRECT");
    putenv(getopt_env);

    res = getopt(argc, argv, optstring);

    if (old_getopt_env == 0)
    {
        putenv("POSIXLY_CORRECT");
    }
    else
        snprintf(getopt_env, sizeof getopt_env, "POSIXLY_CORRECT=%s",
                old_getopt_env);

    return res;
}

static void parse_eth_device(char *str)
{
    char *p;
    for (p = str; *p != 0 && *p != ':'; ++p);
    if (*p == ':')
    {
        *p = '\0'; /* We want only the eth device name in str */
        ++p;
        command_line.eth_port = atoi(p);
    }

    /* The string will not have any colon or port. */
    command_line.eth_device = strdup(str);
}

static void default_command_line()
{
    command_line.is_server = 0;
    command_line.s_param.use_blocking_sockets = 1;
    command_line.s_param.run_in_subterminal = 0;
    command_line.s_param.max_served = 1;
    command_line.s_param.serve_unix = 1;
    command_line.s_param.serve_tcp = 0;
    command_line.s_param.send_xterm_resize = 1;
    command_line.s_param.client_may_close_app_stdin = 0;
    command_line.s_param.nohup = 0;
    command_line.s_param.client_can_write = 0;
    command_line.s_param.echo_in_local_terminal = 0;
    command_line.s_param.send_xterm_resize = 0;
    command_line.s_param.serve_eth = 0;
    command_line.s_param.savefile = 0;

    command_line.tcp_port = 40000; /* Arbitrary */
    command_line.eth_port = 100;   /* Arbitrary */
    command_line.buffer_size = 4096; /* Arbitrary */
    command_line.eth_device = 0;
    get_unix_path(); /* for command_line.unix_path */

    command_line.c_param.transport = UNIX;
    command_line.c_param.wait_until_char = -1;
    command_line.c_param.raw_mode = 0;
    command_line.c_param.server_address = 0; /* TODO: free it */
}

static int parse_opts(int argc, char * argv[])
{
    int c;
    extern char *optarg;
    extern int optind, opterr, optopt;

    while(1) {
        c = my_getopt(argc, argv, "s:tp:nBxdPN:hwCED"
#ifdef linux
                "c:e:"
#endif /* linux */
                );

        if (c == -1)
            break;

        switch(c)
        {
            case 't':
                command_line.s_param.run_in_subterminal = 1;
                command_line.c_param.raw_mode = 1;
                break;
            case 'P':
                command_line.s_param.run_in_subterminal = 0;
                break;
            case 'B':
                command_line.s_param.use_blocking_sockets = 0;
                break;
            case 'n':
                command_line.s_param.nohup = 1;
                break;
            case 'p':
                command_line.tcp_port = atoi(optarg);
                command_line.s_param.serve_tcp = 1;
                command_line.s_param.serve_unix = 0;
                break;
            case 'N':
                command_line.s_param.max_served = atoi(optarg);
                break;
            case 'c':
                command_line.c_param.server_address = strdup(optarg);
                break;
            case 'h':
                showhelp(argv[0]);
                exit(0);
                break;
            case 'w':
                command_line.s_param.client_can_write = 1;
                break;
            case 'C':
                command_line.s_param.client_may_close_app_stdin = 1;
                break;
            case 'x':
                command_line.s_param.send_xterm_resize = 1;
                break;
            case 'E':
                command_line.s_param.echo_in_local_terminal = 1;
                break;
            case 'D':
                should_dump = 1;
                break;
            case 'e':
                command_line.s_param.serve_eth = 1;
                command_line.s_param.serve_unix = 0;
                parse_eth_device(optarg);
                command_line.c_param.transport = ETHERNET;
                break;
            case 's':
                command_line.s_param.savefile = strdup(optarg);
                break;
            case '?':
                error("Wrong option %c.\n", optopt);
        }
    }

    if (command_line.s_param.use_blocking_sockets == 0)
        not_implemented("Not using blocking sockets.");

    if (optind < argc)
    {
        command_line.is_server = 1;
        command_line.s_param.command = &argv[optind];
    }
    return 0;
}

int main(int argc, char * argv[])
{
    int res;

    default_command_line();
    parse_opts(argc, argv);
    init_stream_buffers();

    if (command_line.is_server)
        res = server();
    else
        res = client();
    return res;
}