/*
    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 <stdio.h>

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

static struct
{
    int socket;
    char partner[6];
    int partner_set;
    unsigned int seq_send;
    unsigned int seq_wait;
    unsigned int wrong_recv;
} edata;

enum Control{
    SEND,
    ACK,
    NAK
};

enum {
    MAXPACKET = 1000,
    HEAD = 9
};

static char eth_buffer[1000];

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(size);
    return HEAD;
}

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

void eth_proto_init()
{
    edata.socket = -1;
    edata.seq_send = 0;
    edata.seq_wait = 0;
    edata.partner_set = 0;
    if (command_line.c_param.server_address);
}

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

int eth_proto_recv(char *data, int size)
{
    int res;
    int seq;
    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, &res);
    /* We admit any first connection */
    if (seq == 0)
    {
      edata.seq_wait = 0;
      memcpy(edata.partner, partner, sizeof(edata.partner));
    }
    /*
    if (seq != edata.seq_wait)
    {
        edata.wrong_recv++;
        return -1;
    }
    */
    /* res comes from parse_head. */
    memcpy(data, eth_buffer + HEAD, min(size, res));

    /*
    make_head(eth_buffer, seq, ACK, 0);
    eth_send(command_line.eth_device, edata.partner, eth_buffer, HEAD);
    */
    edata.seq_wait++;

    return res;
}

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

    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;
    }

    do {
        int once;
        int sent;
        int rseq;
        enum Control rc;

        once = min(sizeof(eth_buffer)-HEAD, size);

        make_head(eth_buffer, edata.seq_send, SEND, once);
        memcpy(eth_buffer+HEAD, data, once);
        sent = eth_send(command_line.eth_device, edata.partner,
                eth_buffer, once+HEAD);

        /*
        eth_recv(eth_buffer, HEAD, 0);
        parse_head(eth_buffer, &rseq, &rc, 0);
        if (rc != ACK || rseq != edata.seq_send)
            continue;
        */

        edata.seq_send++;
        size -= sent;
        data += sent;
    } while(size > 0);
    return total;
}

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];
}