[RCOM] Untested

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <signal.h>
#include <termios.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>

// Variáveis de configuração

#define BAUDRATE B38400
#define MODEMDEVICE "/dev/ttyS"
#define RECEIVER 0
#define TRANSMITTER 1
#define alarm_timeout 3
#define numTransmissions 3
#define filename "pinguim.gif"
#define packetsize 100

// Variáveis de mensagem

#define F 0x7e
#define A 0x03
#define S 0x03
#define U 0x07

#define I0 0x00
#define I1 0x40

#define RR0 0x05
#define RR1 0x85

#define REJ0 0x01
#define REJ1 0x81

#define DISC 0x0B


// Variáveis globais

int time_flag, counter = 0 ;
struct termios oldtio;

// Funções

void atende()
{
    time_flag = 1;
    counter++;
}

void printBar (char symbol)
{
    int i;
    struct winsize w;

    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

    for (i = 0; i < w.ws_col; i++)
        printf ("%c", symbol);
}

void printm (char *string, int adjust)
{
    int i;
    struct winsize w;

    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);

    for (i = 0; i < (w.ws_col / 2) - (strlen(string) / 2) + adjust ; i++)
        printf (" ");

    printf ("%s", string);
}

void create_information (char *buffer, int *buffer_size, char c, char *data, int data_size, char BCC2)
{
    int i;

    *buffer_size = data_size + 6;

    printm ("Data:", 0);
    printf ("\n");
    for (i = 0; i < data_size; i++)
        printf ("%x |", data[i]);
    printf ("\n");

    buffer[0] = F;
    buffer[1] = A;
    buffer[2] = c;
    buffer[3] = buffer[1] ^ buffer[2];

    for (i = 0; i < data_size; i++)
        buffer[i + 4] = data[i];

    buffer[data_size + 4] = BCC2;
    buffer[data_size + 5] = F;

    printm ("Information:", 0);
    printf ("\n");
    for (i = 0; i < *buffer_size; i++)
        printf ("%x |", buffer[i]);
    printf ("\n");
}

unsigned char create_control_packet (char *buffer, int *buffer_size , int c, char *file_name, int filesize)
{
    int i;
    unsigned char BCC2;

    *buffer_size = strlen(file_name) + 6;

    buffer[0] = (char) c;

    buffer[1] = (char) 0;
    buffer[2] = (char) sizeof ((char) filesize);
    buffer[3] = (char) filesize;

    buffer[4] = (char) 1;
    buffer[5] = (char) sizeof (file_name);
    for (i = 0; i < strlen(file_name); i++)
        buffer[i + 6] = (char) file_name[i];

    BCC2 = buffer[0];
    for (i = 1; i < strlen(file_name) + 6; i++)
        BCC2 ^= buffer[i];

    return BCC2;
}

unsigned char create_data_packet (char* buffer, int* buffer_size, int n, char *file_name, int filesize)
{
    char BCC2;
    int i, L2 = (int) (packetsize * 8 / 256), L1 = (int) (packetsize * 8) - L2 * 256;

    *buffer_size = strlen(file_name) + 4;

    buffer[0] = (char) 1;
    buffer[1] = (char) n;

    buffer[2] = (char) L2;
    buffer[3]= (char) L1;

    for(i = 0; i < strlen(file_name); i++)
        buffer[4+i]=file_name[i];

    BCC2 = buffer[0];
    for (i = 1; i < strlen(file_name) + 4; i++)
        BCC2 ^= buffer[i];

    return BCC2;
}

int menu ()
{
    int op = 0;

    system ("clear");
    printBar ('*');
    printm ("Programa iniciado!", 0);
    printf ("\n\n\n");
    printm ("Menu (escolher função do programa):", 0);
    printf ("\n");
    printm ("1. Emissor (llwrite).", 0);
    printf ("\n");
    printm ("2. Receptor (llread).", 0);
    printf ("\n");
    printm ("3. Sair.", 0);
    printf ("\n\n");
    printm ("Opcao: ", 0);
    scanf ("%d", &op);

    return op;
}

void sair ()
{
    system ("clear");

    printBar ('*');
    printm ("Programa a encerrar...", 0);
    printf ("\n");
    printBar ('*');
    sleep (1);
}

void main (int argc, char** argv)
{
    int op = 0, fd, filesize;
    char *buffer;

    while (op != 3)
    {
        op = menu();
        switch (op)
        {
            case 1:
                fd = llopen (0, TRANSMITTER);
                if (fd != -1)
                {
                    //filesize = myWrite (buffer);
                    llwrite(fd, buffer, filesize);
                }
                break;
            case 2:
                fd = llopen (0, RECEIVER);
                break;
            case 3:
                llclose (fd);
                sair();
                break;
            default:
                break;
        }
    }
}

int llopen (int porta, int flag)
{
    /* -----    Variáveis  ----- */

    unsigned char send_message[5], receive_message[5], bit_received;
    char buffer[1], gate[10] = MODEMDEVICE;
    int vtime, fd, res[2], return_value, i;
    unsigned int msg_sent = 0, state;
    struct termios newtio;

    /* -----    Código     ----- */

    sprintf (buffer, "%d", porta);
    strcat (gate, buffer);

    system ("clear");

    printBar ('*');
    printm ("Função \"llopen(", -7);
    printf ("%d, %d)\" iniciada!\n", porta, flag);

    if (flag == TRANSMITTER)
    {
        send_message[0] = F;
        send_message[1] = A;
        send_message[2] = S;
        send_message[3] = send_message[1] ^ send_message[2];
        send_message[4] = F;

        vtime = 3;

        fd = open(gate, O_RDWR | O_NOCTTY | O_NONBLOCK);
    }
    else if (flag == RECEIVER)
    {
        send_message[0] = F;
        send_message[1] = A;
        send_message[2] = U;
        send_message[3] = send_message[1] ^ send_message[2];
        send_message[4] = F;

        vtime = 0;

        fd = open(gate, O_RDWR | O_NOCTTY);
    }
    else
        return -1;

    if (fd < 0)
            return -1;

    // Teste ao apontador para o Pipe.

    if (tcgetattr (fd, &oldtio) == -1)
    {
        perror ("tcgetattr");
        return -1;
    }

    // Configuração da ligação.

    bzero(&newtio, sizeof(newtio));
    newtio.c_cflag = BAUDRATE | CS8 | CLOCAL | CREAD;
    newtio.c_iflag = IGNPAR;
    newtio.c_oflag = 0;

    /* set input mode (non-canonical, no echo,...) */
    newtio.c_lflag = 0;

    newtio.c_cc[VTIME]    = vtime;   /* inter-character timer unused */
    newtio.c_cc[VMIN]     = 1;   /* blocking read until 1 chars received */

    /* VTIME e VMIN devem ser alterados de forma a proteger com um temporizador a leitura do(s) próximo(s) caracter(es) */

    tcflush(fd, TCIOFLUSH);
    if (tcsetattr (fd, TCSANOW, &newtio) == -1)
    {
        perror ("tcsetattr");
        return -1;
    }

    (void) signal(SIGALRM, atende);

    if (flag == TRANSMITTER)
    {
        for (time_flag = 1, state = 0, counter = 0; counter < numTransmissions && msg_sent != 1;)
        {
            if (time_flag)
            {
                alarm (alarm_timeout);
                time_flag = 0;

                printm ("A enviar SETUP: tentativa #", -1);
                printf ("%d\n", counter + 1);

                res[0] = write (fd, send_message, 5);

                while (state < 5)
                {
                    res[1] = read (fd, &bit_received, 1);
                    if(res[1] == -1)
                        break;

                    switch (state)
                    {
                        case 0:
                          if (bit_received == F)
                          {
                            receive_message[state]=bit_received;
                            state++;
                          }
                          break;

                        case 1:
                          if (bit_received == A)
                          {
                            receive_message[state]=bit_received;
                            state++;
                          }
                          else if (bit_received != A && bit_received !=F)
                            state--;
                          break;

                        case 2:
                          if (bit_received == U)
                          {
                            receive_message[state]=bit_received;
                            state++;
                          }
                          else if (bit_received == F)
                            state--;
                          else
                            state = 0;
                          break;

                        case 3:
                          if (bit_received == (A^U))
                          {
                            receive_message[state]=bit_received;
                            state++;
                          }
                          else
                            state = 0;
                          break;

                        case 4:
                          if (bit_received == F)
                          {
                            receive_message[state]=bit_received;
                            state++;
                            msg_sent = 1;
                          }
                          else
                            state = 0;
                          break;

                        default:
                            break;
                    }
                }
            }
        }

        if (msg_sent == 0)
        {
            printm ("Mensagem não enviada (não recebeu UA).", +3);
            printf ("\n");
            return_value = -1;
        }
        else
        {
            printm ("Mensagem enviada (recebeu UA).", 0);
            printf ("\n");
            printm ("Mensagem UA:", 0);
            printf ("\n");
            printm (" ", -5);
            for(i = 0; i < state; i++)
                printf("%x", receive_message[i]);
            printf ("\n");
            return_value = fd;
        }
    }
    else if (flag == RECEIVER)
    {
        state = 0;
        while (state < 5)
        {
            res[1] = read (fd, &bit_received, 1);

            switch (state)
            {
                    case 0:
                            if (bit_received == F)
                            {
                                    receive_message[state] = bit_received;
                                    state++;
                            }
                            break;
                    case 1:
                            if (bit_received == A)
                            {
                                    receive_message[state] = bit_received;
                                    state++;
                            }
                            else if (bit_received != F && bit_received != A)
                                    state--;
                            break;
                    case 2:
                            if (bit_received == S)
                            {
                                    receive_message[state] = bit_received;
                                    state++;
                            }
                            else if (bit_received == F)
                                    state--;
                            else
                                    state = 0;
                            break;
                    case 3:
                            if (bit_received == (A ^ S))
                            {
                                    receive_message[state] = bit_received;
                                    state++;
                            }
                            else if (bit_received == F)
                                    state = 1;
                            else
                                    state = 0;
                            break;
                    case 4:
                            if (bit_received == F)
                            {
                                    receive_message[state] = bit_received;
                                    state++;
                                    msg_sent = 1;
                            }
                            else
                                    state = 0;
                            break;
                    default:
                        break;
            }
        }

        if (msg_sent == 0)
        {
            printm ("Mensagem não enviada (não recebeu SETUP).", +3);
            printf ("\n");
            return_value = -1;
        }
        else
        {
            printm ("Mensagem enviada (recebeu SETUP).", 0);
            printf ("\n");
            printm ("Mensagem SETUP:", 0);
            printf ("\n");
            printm (" ", -5);
            for(i = 0; i < state; i++)
                printf("%x", receive_message[i]);
            printf ("\n");

            res[0] = write(fd, send_message, 5);
            /*if (!res[0])
                printf("Mensagem (UA) não enviada.\n");
            else
                printf("%d bytes (UA) enviados.\n", res[0]);*/

            return_value = fd;
        }
    }

    printf ("\n\n");
    printm ("Função \"llopen(", -7);
    printf ("%d, %d)\" a fechar!\n", porta, flag);
    printm ("Clique numa tecla para voltar ao menu.", 0);
    printf ("\n");
    printBar ('*');
    getchar();
    getchar();

    return return_value;
}

int llwrite (int fd, char * buffer, int length)
{
    char *cntrl_message, *data_message, *message, *message_received, I = I0;
    unsigned char BCC2;
    int file_found = 1, i, cntrl_size, message_size, msg_error = 0;
    FILE *pImg;

    while (file_found)
    {
        system ("clear");
        printBar ('*');
        printm ("Nome do ficheiro a usar: pinguim.gif", 0);
        printf ("\n");
        printm ("(certifique-se que o ficheiro está na pasta do programa)", 0);
        printf ("\n\n\n");

        pImg = fopen (filename, "r");
        if (pImg == NULL)
        {
            printm ("Ficheiro não encontrado.", 0);
            printf ("\n");
            printm ("(certifique-se que o ficheiro está na pasta do programa)", 0);
            printf ("\n");
            printm ("Clique <Enter> para voltar a tentar.", 0);
            getchar ();
        }
        else
        {
            file_found = 0;
            printm ("Ficheiro encontrado.", 0);
            printf ("\n");
            printm ("Clique <Enter> para continuar.", 0);
            getchar ();
        }
    }

    // Leitura do conteúdo da imagem para variável "buffer"
    fseek (pImg, 0, SEEK_END);
    length = ftell (pImg);
    fseek (pImg, 0, SEEK_SET);

    buffer = (char *) malloc (sizeof(char) * length);

    for (i = 0; i < length; i++)
        buffer[i] = getc(pImg);

    fclose (pImg);
    // Leitura do conteúdo da imagem para variável "buffer"

    // Primeira mensagem a enviar: Pacote de controlo (start)
    cntrl_message = (char *) malloc (sizeof(char) * (strlen(filename) + 6));
    BCC2 = create_control_packet (cntrl_message, &cntrl_size, 2, filename, length);

    message = (char *) malloc (sizeof(char) * (cntrl_size + 6));
    create_information (message, &message_size, I, cntrl_message, cntrl_size, BCC2);

    //write (fd, message, message_size); // envio do pacote de controlo
    // Primeira mensagem a enviar: Pacote de controlo (start)

    // Leitura de verificação

    for (time_flag = 1, state = 0, counter = 0; counter < numTransmissions && msg_error != -1;)
    {
        if (time_flag)
        {
            alarm (alarm_timeout);
            time_flag = 0;

            res = write (fd, message, message_size); // envio do pacote de controlo
            res = read (fd, &message_received, 5);
            if(res == 5)
                while (state < 5 || !msg_error)
                {
                    switch (state)
                    {
                        case 0:
                            if (message_received[state] == F)
                                state++;
                            else
                                msg_error = 1;
                            break;

                        case 1:
                            if (message_received[state] == A)
                                state++;
                            else
                                msg_error = 1;
                            break;

                        case 2:
                            if (message_received[state] == RR0)
                            {
                                data_message = (char *) malloc (sizeof(char) * length);
                                BCC2 = create_data_packet (buffer, buffer_size, 1, file_name, filesize);
                                create_information (message, &message_size, 0, buffer, buffer_size, BCC2);
                            }
                            else if (message_received[state] == RR1)
                            {
                                data_message = (char *) malloc (sizeof(char) * length);
                                BCC2 = create_data_packet (buffer, buffer_size, 1, file_name, filesize);
                                create_information (message, &message_size, 1, buffer, buffer_size, BCC2);
                            }
                            else if (message_received[state] == REJ0)
                            {
                                data_message = (char *) malloc (sizeof(char) * length);
                                BCC2 = create_data_packet (buffer, buffer_size, 1, file_name, filesize);
                                create_information (message, &message_size, 0, buffer, buffer_size, BCC2);
                            }
                            else if (message_received[state] == REJ1)
                            {
                                data_message = (char *) malloc (sizeof(char) * length);
                                BCC2 = create_data_packet (buffer, buffer_size, 1, file_name, filesize);
                                create_information (message, &message_size, 1, buffer, buffer_size, BCC2);
                            }
                            else if (message_received[state] == DISC)
                                msg_error = -1;
                            else
                                msg_error = 1;
                            break;

                        case 3:
                            if (message_received[state] == message_received[state - 1] ^ message_received[state - 2])
                                state++;
                            else
                                msg_error = 1;
                            break;

                        case 4:
                            if (message_received[state] == F)
                                state++;
                            else
                                msg_error = 1;
                            break;
                    }
                }
        }
    }
    // Leitura de verificação

    return length;
}

int read_control_packet(int fd, char* received_message, int *size)
{
    //RETURNS -1 IF ANY FAIL OTHERWISE SIZE
    char bit_received, receive_message,res[2];
    int state=0,i=0,v1_size,v2_size, final_state=0;
    while (final_state == 0)
    {
        res[1] = read (fd, &bit_received, 1);
            if(res[1] == -1)
            return -1;

            switch (state)
            {
            //C
            case 0:
              if (bit_received == 2 || bit_received == 3)
              {
                receive_message[state]=bit_received;
                state++;
              }
              else{
                return -1;
              }
              break;
            //T1
            case 1:
              if (bit_received == 0)
              {
                receive_message[state]=bit_received;
                state++;
              }
              else{
                return -1;
              }
              break;
            //L1
            case 2:
                receive_message[state]=bit_received;
                state++;
              break;
            //V1
            case 3:
              //V1 Length
                v1_size = receive_message[2];
                for(i=0;i<v1_size; i++){
                    res[1] = read (fd, &bit_received, 1);
                    if(res[1] == -1)
                        return -1;

                    receive_message[3+i]=bit_received;

                }
                state++;
                break;

            case 4:
              if (bit_received == 1)
              {
                receive_message[state+v1_size]=bit_received;
                state++;
              }
              else{
                return -1;
              }
              break;
            case 5:
              //V2 Length
                v2_size = bit_received;
                for(i=0;i<v2_size; i++){
                    res[1] = read (fd, &bit_received, 1);
                    if(res[1] == -1)
                        return -1;

                    receive_message[state+v1_size+i]=bit_received;
                }
                final_state=1;
                break;
            default:
                break;
        }
    }
    size=state+v1_size+v2_size;
    return state;
}

char * read_data_packet(int fd, char* received_message, int *size)
{
    //RETURNS -1 IF ANY FAIL OTHERWISE SIZE
    char bit_received, receive_message,res[2];
    int state=0,i=0,p_size, final_state=0;
    while (final_state == 0)
    {
        res[1] = read (fd, &bit_received, 1);
            if(res[1] == -1)
            return -1;

            switch (state)
            {
            //C
            case 0:
              if (bit_received == 1)
              {
                receive_message[state]=bit_received;
                state++;
              }
              else{
                return -1;
              }
              break;
            //N
            case 1:
                receive_message[state]=bit_received;
                state++;
              break;
            //L2
            case 2:
                receive_message[state]=bit_received;
                state++;
              break;
            //L1
            case 3:
                receive_message[state]=bit_received;
                state++;
              break;

            case 4:
              //P Length
                p_size = 256*receive_message[3]+receive_message[4];
                char data[p_size];
                for(i=0;i<p_size; i++){
                    res[1] = read (fd, &bit_received, 1);
                    if(res[1] == -1)
                        return -1;

                    data[i]=bit_received;
                    state++;
                }
              break;

            default:
                break;
        }
    }
    size=state;
    return data;
}


int llclose (int fd)
{
    if (tcgetattr (fd, &oldtio) == -1)
    {
        perror ("tcgetattr");
        return -1;
    }

    close (fd);

    return 0;
}