/*
    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 <netinet/in.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <errno.h>

#include "main.h"
#include "eth_linux.h"

enum {
    MAXPACKET = 1500,
    MAXSEQ = 100,
    HEAD = 13
};

static struct
{
    int socket;
    char partner[6];
    int partner_set;
    int send_acked;
    int send_retries_left;
    unsigned int seq_send;
    unsigned int seq_wait;
    unsigned int wrong_recv;
    char send_buffer[MAXPACKET];
    int send_buffer_size;
    int port;
} edata;

enum Control {
    SEND,
    ACK,
    INIT
};

static char eth_buffer[MAXPACKET];

static void eth_fill_mac(unsigned char *mac, const char *str);

static int make_head(unsigned char *data, unsigned int seq, enum Control c,
        int size)
{
    *((unsigned int *) data) = htonl(seq);
    data[4] = (unsigned char) c;
    *((unsigned int *)(data+5)) = htonl(edata.port);
    *((unsigned int *)(data+5+4)) = htonl(size);
    return HEAD;
}

static int parse_head(unsigned char *data, unsigned int *seq, enum Control *c,
        int *port, int *size)
{
    *seq = ntohl( *((unsigned int*) data) );
    *c = data[4];
    if (port)
        *port = ntohl(*((unsigned int *)(data+5)));
    if (size)
        *size = ntohl(*((unsigned int *)(data+5+4)));
    return HEAD;
}

int eth_proto_max_send()
{
    return MAXPACKET - HEAD;
}

void eth_proto_init()
{
    edata.socket = -1;
    edata.port = command_line.eth_port;
    edata.seq_send = 0;
    edata.seq_wait = 0;
    edata.send_acked = 1; /* Fine at the beginning, as if the last data was acked */
    edata.partner_set = 0;
}

int eth_proto_allow_sending()
{
    return edata.send_acked;
}

static int seq_next(int val)
{
    if (val >= 0 && val < MAXSEQ)
        val = val + 1;
    else
        val = 0;
    return val;
}

static int seq_before(int val)
{
    if (val > 0 && val < MAXSEQ)
        val = val - 1;
    else
        val = MAXSEQ;
    return val;
}

int eth_proto_open(enum Eth_type type)
{
    edata.socket = eth_open(command_line.eth_device, type);
    if (edata.socket == -1)
        error("Cannot open device %s", command_line.eth_device);

    if ( !command_line.is_server)
    {
        if (command_line.c_param.server_address == 0)
            error("You must specify the MAC you want to connect to.");
        eth_fill_mac(edata.partner, command_line.c_param.server_address);
        edata.partner_set = 1;

        make_head(eth_buffer, edata.seq_send, INIT, 0);
        eth_send(command_line.eth_device, edata.partner, eth_buffer, HEAD);
        edata.seq_send = seq_next(edata.seq_send);
    }

    return edata.socket;
}

int eth_proto_recv(char *data, int size)
{
    int res;
    int seq;
    int data_length;
    int port;
    enum Control c;
    char partner[6];

    do {
            res = eth_recv(eth_buffer, sizeof(eth_buffer), partner);
            edata.partner_set = 1;
    } while(res < HEAD);
    parse_head(eth_buffer, &seq, &c, &port, &data_length);
    if (port != edata.port)
        return -1; /* Nothing the parent should care about. Not a packet for us. */

    /* We admit any first connection */
    if (seq == 0 && c == INIT)
    {
      edata.seq_wait = 1; /* next of the just receive 0 */
      edata.seq_send = 0; /* New partner we send to, so 0 sent */
      memcpy(edata.partner, partner, sizeof(edata.partner));
      return -1; /* Nothing the parent should care about */
    }
    if (c == SEND)
    {
        if (seq != edata.seq_wait && seq != seq_before(edata.seq_wait))
        {
            dump_line("Wrong data packet seq received. Recvd: %i Expected: %i\n",
                    seq, edata.seq_wait);
            edata.wrong_recv++;
            return -1;
        }

        if (seq == seq_before(edata.seq_wait))
            dump_line("Repeated data seq received: %i\n", seq);

        if (seq == edata.seq_wait)
        {
            if (data_length == 0)
            {
                edata.partner_set = 0;
                edata.seq_wait = 0;
                edata.seq_send = 0;
                /* We should send ACK anyway */
            }
            else
            {
                memcpy(data, eth_buffer + HEAD, data_length);
                edata.seq_wait = seq_next(edata.seq_wait);
            }
        }

        /* Ack the packed we received. In these conditions:
         * - We received the packed we expected
         * - We received a repeat of the old packet. The
         *   ACK was lost probably, so we resend it */
        make_head(eth_buffer, seq, ACK, 0);
        eth_send(command_line.eth_device, edata.partner, eth_buffer, HEAD);
    }
    else if (c == ACK)
    {
        if (seq == edata.seq_send)
        {
            edata.send_acked = 1;
            edata.seq_send = seq_next(edata.seq_send);
            unprogram_timeout();
        }
        else
        {
            dump_line("Wrong ack received. Recvd: %i Expected: %i\n",
                    seq, edata.seq_send);
        }
        return -1; /* not data */
    }
    else
        return -1;

    return data_length;
}

static int eth_proto_link_send()
{
    int sent;
    sent = eth_send(command_line.eth_device,
            edata.partner,
            edata.send_buffer,
            edata.send_buffer_size);

    if (sent >= 0) /* expected */
    {
        edata.send_retries_left -= 1;
        edata.send_acked = 0;
        program_timeout(1);
    }
    else /* strange case, data not sent */
    {
        sent = 0;
        edata.send_acked = 1;
    }
    return sent;
}

int eth_proto_send(const char *data, int size)
{
    int sent;

    assert(edata.send_acked);

    if (!edata.partner_set)
    {
        if (edata.seq_send == 0 && !command_line.is_server
                && command_line.c_param.server_address != 0)
        {
            eth_fill_mac(edata.partner, command_line.c_param.server_address);
            edata.partner_set = 1;
        }
        else
            return 0;
    }

    edata.send_retries_left = 3;

    /* Prepare packet */
    make_head(edata.send_buffer, edata.seq_send, SEND, size);
    memcpy(edata.send_buffer+HEAD, data, size);
    edata.send_buffer_size = size + HEAD;

    sent = eth_proto_link_send();
    sent -= HEAD;
    return sent;
}

int eth_proto_process_timeouts()
{
    if (!edata.send_acked && did_timeout_happen())
    {
        unprogram_timeout();
        if (edata.send_retries_left > 0)
        {
            dump_line("Retrying. Left:%i\n", edata.send_retries_left);
            eth_proto_link_send();
        }
        else
        {
            /* The connection has been lost */
            dump_line("Connection lost");
            edata.send_acked = 1;
            edata.partner_set = 0;
            edata.seq_wait = 0;
            edata.seq_send = 0;
            return 0; /* FAIL */
        }
    }
    return 1; /* OK */
}

static void eth_fill_mac(unsigned char *mac, const char *str)
{
  int res;
  int imac[6];
  res = sscanf(str, "%x:%x:%x:%x:%x:%x",
      &imac[0], &imac[1], &imac[2], &imac[3], &imac[4], &imac[5]);
  if (res != 6)
  {
    error("Error parsing mac: %02x:%02x:%02x:%02x:%02x:%02x\n",
      imac[0], imac[1], imac[2], imac[3], imac[4], imac[5]);
  }
  mac[0] = imac[0];  mac[1] = imac[1];  mac[2] = imac[2];
  mac[3] = imac[3];  mac[4] = imac[4];  mac[5] = imac[5];
}