[RCOM - Final] Receiver Functions

#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 2
#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;

typedef struct
{
    long int filesize, position;
    unsigned char *filepath;
    unsigned char *filedata;
} imageFile;

imageFile ficheiro_de_imagem;

typedef struct
{
    int dataSeq, packetSize;
    unsigned char tramaSeq;
} dataConnection;

dataConnection dataHandler;

// Funções

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

void printBar (unsigned 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 (unsigned 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);
}

unsigned char * performStuffing(unsigned char *buffer, int length, int *destLength)
{
    unsigned char *stuffed = malloc(length * 2 * sizeof(unsigned char));  //  Worse case scenario!

    int i = 0, j = 0;

    for (; i < length; i++) {

        if (buffer[i] == 0x7e) {

            stuffed[j++] = 0x7d;
            stuffed[j++] = 0x5e;

        } else if (buffer[i] == 0x7d) {

            stuffed[j++] = 0x7d;
            stuffed[j++] = 0x5d;

        } else
            stuffed[j++] = buffer[i];

    }

    (* destLength) = j;

    return stuffed;
}

unsigned char * performDestuffing(unsigned char *buffer, int length, int *destLength)
{
    unsigned char *destuffed = malloc(length * sizeof(unsigned char));  //  Worse case scenario!

    int i = 0, j = 0;

    for (; i < length; i++, j++)
    {

        if (buffer[i] == 0x7d)
        {

            if (buffer[i + 1] == 0x5e)
            {

                destuffed[j] = 0x7e;

                i++;

            }
            else if (buffer[i + 1] == 0x5d) {

                destuffed[j] = 0x7d;

                i++;

            } else
                destuffed[j] = 0x7d;

        } else
            destuffed[j] = buffer[i];

    }

    (* destLength) = j;

    return destuffed;
}

unsigned char *getDataSeq (unsigned char *total_buffer, int total_size, int seq, int *new_size)
{
    int i, j, start;
    unsigned char *buffer;

    if ((seq + 1) * packetsize > ficheiro_de_imagem.filesize)
        *new_size = ficheiro_de_imagem.filesize - seq * packetsize;
    else
        *new_size = (seq + 1) * packetsize;

    buffer = (unsigned char *) malloc (sizeof(unsigned char) * packetsize);

    if (seq == 0)
        start = 0;
    else
        start = seq * packetsize - 1;

    for (j = 0, i = start; i < *new_size; i++, j++)
        buffer[j] = total_buffer[i];

    return buffer;
}

void create_information (unsigned char *buffer, int *buffer_size, unsigned char c, unsigned char *data, int data_size, unsigned 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];

    if (BCC2 != NULL)
    {
        buffer[data_size + 4] = BCC2;
        buffer[data_size + 5] = F;
    }
    else
    {
        buffer[data_size + 4] = F;
        *buffer_size--;
    }

    buffer = performStuffing(buffer, buffer_size, &buffer_size);

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

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

    *buffer_size = strlen(file_name) + 6;

    buffer[0] = (unsigned char) c;

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

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

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

    return BCC2;
}

// BCC2 = create_data_packet (Nova mensagem, tamanho, N, data, tamanho da data)
unsigned char create_data_packet (unsigned char *buffer, int *buffer_size, int n, unsigned char *file_data, int datasize)
{
    unsigned char BCC2;
    int i, L2 = (int) (packetsize * 8 / 256), L1 = (int) (packetsize * 8) - L2 * 256;

    *buffer_size = datasize + 4;

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

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

    for(i = 0; i < datasize; i++)
        buffer[4+i] = file_data[i];

    BCC2 = buffer[0];
    for (i = 1; i < *buffer_size; 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);
}

unsigned char read_control_packet (unsigned char *msg, long int start, unsigned char BCC2, unsigned char *auxFilepath, int *auxFilepathsize, int *auxFilesize, int *size_of_packet)
{
    unsigned char bit_received, auxFile[30];
    unsigned char received_message[255];
    int state = 0, i, res, count = 0, ind;

    while (state < 6)
    {
        /*res = read (fd, &bit_received, 1);
        if(res == -1)
            return NULL;*/

        //printf ("State: %d\nMessage: %x\n", state, msg[start + count]);
        switch (state)
        {
                case 0: // T1
                    if (msg[start] == 0)
                    {
                        received_message[count] = msg[start + count];
                        state++;
                        count++;
                    }
                    else
                        return NULL;
                    break;

                case 1: // L1
                    received_message[count] = msg[start + count];
                    state++;
                    count++;
                    break;

                case 2: // V1
                    ind = (int) received_message[count - 1];
                    for(i = 0; i < ind; i++, count++)
                    {
                        auxFile[i] = msg[start + count];
                        received_message[count] = msg[start + count];
                    }

                    *auxFilesize = (int) msg[start + count];

                    state++;
                    break;

                case 3: // T2
                    if (msg[start + count] == 1)
                    {
                        received_message[count] = msg[start + count];
                        state++;
                        count++;
                    }
                    else
                        return NULL;
                    break;

                case 4: // L2
                    received_message[count] = msg[start + count];
                    state++;
                    count++;
                    break;

                case 5: // V2
                    ind = (int) received_message[count - 1];

                    auxFilepath = (char *) malloc (sizeof(char) * (ind + 1));

                    printf ("IND: %d\n", ind);
                    for(i = 0; i < ind; i++, count++)
                    {
                        auxFilepath[i] = msg[start + count];
                        received_message[count] = msg[start + count];
                    }
                    *auxFilepathsize = ind + 1;
                    printf ("auxFilepath = %s\n", auxFilepath); // aqui está coorecto
                    //auxFilepath[*auxFilepathsize] = '\0';

                    state++;
                    count++;
                    break;

                default:
                    break;
        }
    }

    for (i = 0; i < count; i++)
        BCC2 ^= received_message[i];

    printf ("Count: %d\n", count);
    for (i = 0; i < count; i++)
        printf ("MSG: %x\n", received_message[i]);

    *size_of_packet = count;

    return BCC2;
}

unsigned char read_data_packet (int fd, unsigned char BCC2, unsigned char *data)
{
    int i, count = 0, state = 0, res;
    unsigned char received_message[255], bit_received, auxFile[255];

    printf ("read_data_packet\n");

    while (state < 4)
    {
        res = read (fd, &bit_received, 1);
        if(res == -1)
            return NULL;

        switch (state)
        {
            case 0:
                received_message[count] = bit_received;
                dataHandler.dataSeq = (int) bit_received;
                state++;
                count++;
                break;

            case 1:
                received_message[count] = bit_received;
                state++;
                count++;
                break;

            case 2:
                received_message[count] = bit_received;
                dataHandler.packetSize = (int) (256 * (int) received_message[count - 1] + (int) received_message[count]);
                state++;
                count++;
                break;

            case 3:
                auxFile[0] = bit_received;
                received_message[count++] = bit_received;
                for(i = 1; i < dataHandler.packetSize; i++, count++)
                {
                    res = read (fd, &bit_received, 1);
                    if(res == -1)
                        return NULL;

                    auxFile[i] = bit_received;
                    received_message[count] = bit_received;
                }

                state++;
                count++;
                break;
        }
    }
    for (i = 0; i < count; i++)
        BCC2 ^= received_message[i];

    data = (unsigned char *) malloc (sizeof(unsigned char) * dataHandler.packetSize);
    for(i = 0; i < dataHandler.packetSize; i++)
    {
        data[i] = auxFile[i];
        printf ("Data[%d]: %x\n", i, data[i]);
    }

    return BCC2;
}

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

    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);
                printf ("fd %d\n", fd);
                llread(fd, buffer);
                //saveToFile(buffer);
                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;
    unsigned 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);
    }
    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-unsigned character timer unused */
    newtio.c_cc[VMIN]     = 1;   /* blocking read until 1 unsigned 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)
            {
                printm ("A enviar SETUP: tentativa #", -1);
                printf ("%d\n", counter + 1);

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

                alarm (alarm_timeout);
                time_flag = 0;

                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 feunsigned char!\n", porta, flag);
    printm ("Clique numa tecla para voltar ao menu.", 0);
    printf ("\n");
    printf ("FD: ");
    printf ("%d\n", return_value);
    printBar ('*');

    return return_value;
}

int llwrite (int fd, unsigned char * buffer, int length)
{
    unsigned char *cntrl_message, *new_message, *data_message, *message, *message_received, bit_received, auxCntrl;
    unsigned char BCC2;
    int file_found = 1, i, j, cntrl_size, message_size, msg_error = 0, state, res, buffer_size, denied = 0, new_message_size;
    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 = (unsigned char *) malloc (sizeof(unsigned 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 = (unsigned char *) malloc (sizeof(unsigned char) * (strlen(filename) + 6));
    BCC2 = create_control_packet (cntrl_message, &cntrl_size, 2, filename, length);

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

    dataHandler.dataSeq = 0;
    // Primeira mensagem a enviar: Pacote de controlo (start)

    // Leitura de verificação
    for (time_flag = 1, state = 0, counter = 0; counter < numTransmissions;)
    {
        if (time_flag)
        {
            alarm (alarm_timeout);
            time_flag = 0;

            res = write (fd, message, message_size); // envio do pacote de controlo
            if (res != -1)
                denied = 0;

            while (state < 6 || denied != 1)
            {
                res = read (fd, &bit_received, 1);
                if(res == -1)
                    break;

                switch (state)
                {
                    case 0:
                        if (bit_received == F)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 1:
                        if (bit_received == A)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 2:
                        auxCntrl = bit_received;
                        state++;
                        break;

                    case 3:
                        if (bit_received == auxCntrl ^ A)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 4:
                        if (bit_received == F)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 5://verificar rej, rr, disc
                        counter = 0;
                        if (auxCntrl == RR1 && dataHandler.tramaSeq == I0)
                        {
                            dataHandler.tramaSeq = I1;
                            dataHandler.dataSeq++;

                            data_message = getDataSeq (buffer, i, dataHandler.dataSeq, &new_message_size);

                            BCC2 = create_data_packet (new_message, &message_size, dataHandler.dataSeq, data_message, new_message_size);

                            create_information (message, &message_size, dataHandler.tramaSeq, new_message, new_message_size, BCC2);

                        }
                        else if(auxCntrl == RR1 && dataHandler.tramaSeq == I1)
                        {
                            denied = 1;
                            break;
                        }
                        else if(auxCntrl == RR0 && dataHandler.tramaSeq == I0)
                        {
                            denied = 1;
                            break;
                        }
                        else if(auxCntrl == RR0 && dataHandler.tramaSeq == I1)
                        {
                            dataHandler.tramaSeq = I0;
                            dataHandler.dataSeq++;

                            data_message = getDataSeq (buffer, i, dataHandler.dataSeq, &new_message_size);

                            BCC2 = create_data_packet (new_message, &message_size, dataHandler.dataSeq, data_message, new_message_size);

                            create_information (message, &message_size, dataHandler.tramaSeq, new_message, new_message_size, BCC2);
                        }
                        else if(auxCntrl == REJ0 && dataHandler.tramaSeq == I0)
                        {
                            denied = 1;
                            break;
                        }
                        else if(auxCntrl == REJ0 && dataHandler.tramaSeq == I1)
                        {
                            dataHandler.tramaSeq = I0;

                            data_message = getDataSeq (buffer, i, dataHandler.dataSeq - 1, &new_message_size);

                            BCC2 = create_data_packet (new_message, &message_size, dataHandler.dataSeq - 1, data_message, new_message_size);

                            create_information (message, &message_size, dataHandler.tramaSeq, new_message, new_message_size, BCC2);
                        }
                        else if(auxCntrl == REJ1 && dataHandler.tramaSeq == I0)
                        {
                            dataHandler.tramaSeq = I1;

                            data_message = getDataSeq (buffer, i, dataHandler.dataSeq - 1, &new_message_size);

                            BCC2 = create_data_packet (new_message, &message_size, dataHandler.dataSeq - 1, data_message, new_message_size);

                            create_information (message, &message_size, dataHandler.tramaSeq, new_message, new_message_size, BCC2);
                        }
                        else if(auxCntrl == REJ1 && dataHandler.tramaSeq == I1)
                        {
                            denied = 1;
                            break;
                        }
                        else if(auxCntrl == DISC)
                        {
                            // --
                        }
                        break;
                }
            }
        }
    }
    // Leitura de verificação

    return length;
}

/* ----- llread -----
argumentos
    fd: identificador da ligação de dados
    buffer: array de caracteres recebidos
retorno
    comprimento do array (número de caracteres lidos)
    valor negativo em caso de erro
*/
int llread (int fd, unsigned char *buffer)
{
    unsigned char bit_received, *auxFilepath, BCC2, auxCntrl = I0, msg[255], *destuffedmsg, auxmsg[255], *data;
    int msg_wanted = 0, state = 0, res, final = 0, i, j, denied = 1, auxFilesize, auxDatasize, auxFilepathsize, buffer_size, size_of_packet;

    ficheiro_de_imagem.position = 0;
    dataHandler.tramaSeq = I0;

    printf ("LLREAD!\n");

    printf ("auxCntrl: %x\n", auxCntrl);
    while (auxCntrl != DISC)
    {
        i = 0;
        state = 0;

        res = read (fd, &bit_received, 1);
        if (bit_received == F)
        {
            auxmsg[i] = F;
            do
            {
                read (fd, &bit_received, 1);
                auxmsg[i++] = bit_received;
            }
            while (bit_received != F);

            auxmsg[i++] = bit_received;
            denied = 0;

            destuffedmsg = performDestuffing (auxmsg, i, &i);
            msg[0] = F;
            for (j = 1; j < i; j++)
                msg[j] = destuffedmsg[j - 1];
            msg[j] = F;
            i = j;
            for (j = 0; j < i; j++)
                printf ("msg[%d]: %x\n", j, msg[j]);
            printf ("\n");
        }

        while (state < 8 && denied == 0)
        {
            printf ("msg[state = %d]: %x\n", state, msg[state]);
            switch (state)
            {
                    case 0:
                        if (msg[state] == F)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 1:
                        if (msg[state] == A)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 2:
                        if (msg[state] == dataHandler.tramaSeq)
                            msg_wanted = 1;

                        state++;

                        break;

                    case 3:
                        if (msg[state] == A ^ msg[state - 1])
                            state++;
                        else
                            denied = 1;

                        break;

                    case 4:
                        if (msg[state] == 1)
                        {
                            printf ("DATA\n");
                            BCC2 = read_data_packet (fd, msg[state], data);
                            state++;
                        }
                        else if (msg[state] == 2)
                        {
                            printf ("START\n");
                            BCC2 = read_control_packet (msg, state + 1, msg[state], auxFilepath, &auxFilepathsize, &auxFilesize, &size_of_packet);
                            printf ("BCC2*: %x\n", BCC2);
                            state++;
                            //auxFilepath[auxFilepathsize] = '\0';
                            printf ("auxFilepathsize: %d\nauxFilesize: %d\nauxFilepath: %s\n", auxFilepathsize, auxFilesize, auxFilepath);
                            /*for (j = 0; j < auxFilepathsize; j++)
                                printf ("auxFile[%d]: %x - %c\n", j, auxFilepath[j], auxFilepath[j]);*/
                            //auxFilepath[auxFilepathsize] = '\0';
                        }
                        else if (msg[state] == 3)
                        {
                            printf ("END\n");
                            BCC2 = read_control_packet (msg, state + 1, msg[state], auxFilepath, &auxFilepathsize, &auxFilesize, &size_of_packet);
                            state++;
                            final = 1;
                        }
                        else
                            denied = 1;

                        break;

                    case 5:
                        printf ("BCC2 Recebido: %x\n", msg[state + size_of_packet - 1]);
                        printf ("BCC2 Calculado: %x\n", BCC2);
                        if (msg[state + size_of_packet - 1] == BCC2)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 6:
                        if (msg[state + size_of_packet - 1] == F)
                            state++;
                        else
                            denied = 1;

                        break;

                    case 7:
                        if (msg_wanted && final == 0)
                        {
                            printf ("Message wanted.\n");
                            if (dataHandler.tramaSeq == I0)
                            {
                                dataHandler.tramaSeq = I1;
                                auxCntrl = RR1;
                            }
                            else if (dataHandler.tramaSeq == I1)
                            {
                                dataHandler.tramaSeq = I0;
                                auxCntrl = RR0;
                            }

                            // concatenar data ou guardar filepath e filesize

                            if (msg[4] == 1) // Concatenar data
                            {
                                for (j = 0; j < auxDatasize; j++, ficheiro_de_imagem.position++)
                                    ficheiro_de_imagem.filedata[ficheiro_de_imagem.position] = data[j];
                            }
                            else if (msg[4] == 2 || msg[4] == 3)
                            {
                                //auxFilepath[auxFilepathsize] = '\0';

                                ficheiro_de_imagem.filepath = (unsigned char *) malloc (sizeof(unsigned char) * auxFilepathsize + 1);

                                for (j = 0; j < auxFilepathsize; j++)
                                    ficheiro_de_imagem.filepath[j] = auxFilepath[j];

                                printf ("ficheiro_de_imagem.filepath: %s\n", ficheiro_de_imagem.filepath);

                                ficheiro_de_imagem.filesize = dataHandler.packetSize;

                                ficheiro_de_imagem.filedata = (unsigned char *) malloc (sizeof(unsigned char) * ficheiro_de_imagem.filesize);
                            }

                        }
                        else if (msg_wanted && final == 1)
                        {
                            auxCntrl = DISC;
                        }
                        else if (!msg_wanted)
                        {
                            if (dataHandler.tramaSeq == I0)
                                auxCntrl = REJ0;
                            else if (dataHandler.tramaSeq == I1)
                                auxCntrl = REJ1;
                        }

                        state++;

                        buffer = (unsigned char *) malloc (sizeof(unsigned char) * 5);
                        create_information (buffer, &buffer_size, auxCntrl, NULL, 0, NULL);
                        write (fd, buffer, buffer_size);

                    default:
                        break;

            }
        }
    }
    /* --- */

    // Criação do ficheiro com data
    for (j = 0; j < ficheiro_de_imagem.filesize; j++)
        printf ("Byte[%d]: %x\n", j, ficheiro_de_imagem.filedata[j]);
}


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

    close (fd);

    return 0;
}