path: root/impl/DiagnosticModule/DiagnosticModule/protocol/data.c

/* Author: Jan Sucan */

#include <protocol/data.h>
#include <protocol/frame.h>
#include <clock/wait.h>
#include <stdbool.h>

/**
 * Kod verzie protokolu YUP pre pouzitie v hlavicke ramcov.
 */
#define DATA_PROTOCOL_VERSION  0x0

/**
 * Timeout YUP relacie.
 */
#define DATA_RELATION_TIMEOUT_MS 60000 // ms

/** 
 * Timeout pre prijatie ACK na odoslany ramec pri odosielani dat.
 */
#define DATA_ACK_TIMEOUT_MS       250 // ms

/** 
 * Urcuje maximalny pocet stratenych ACK ramcov, a teda aj znovu odoslani datoveho ramca, pri odosielani dat.
 */
#define DATA_ACK_RETRY_COUNT       4


yup_retcode_t data_is_data_frame     (const frame_t * const frame);
yup_retcode_t data_is_starting_frame (const frame_t * const frame);
yup_retcode_t data_is_ack_for_frame  (const frame_t * const ack, const frame_t * const frame);
void          data_send_ack          (uint16_t relation_id, uint16_t seq_number);
void          data_send_rej_for_frame(const frame_t * const frame, uint8_t err_code);


/**
 * @brief Kontrola ramca, ci sa jedna o datovy ramec.
 *
 * @param fram  Ukazovatel na kontrolovany ramec.
 *
 * @return  Popis chyby ramca.
 */
yup_retcode_t
data_is_data_frame(const frame_t * const frame)
{
	yup_retcode_t yr = DATA_OK;
		
	if (frame_get_data_length(frame) == 0) {
		yr = DATA_DATA_HAS_NO_PAYLOAD;
	} else if (frame_is_flag_ack_set(frame)) {
		yr = DATA_DATA_HAS_REJ_FLAG;
	} else if (frame_is_flag_rej_set(frame)) {
		yr = DATA_DATA_HAS_REJ_FLAG;
	}
		
	return yr;
}

/**
 * @brief Kontrola ramca, ci sa jedna o startovaci ramec relacie.
 *
 * @param frame  Ukazovatel na kontrolovany ramec.
 *
 * @return  Popis chyby ramca.
 */
yup_retcode_t
data_is_starting_frame(const frame_t * const frame)
{
	yup_retcode_t yr = DATA_OK;
		
	if ((yr = data_is_data_frame(frame)) != DATA_OK) {
		;
	} else if (frame_get_seq_number(frame) != 0) {
		yr = DATA_STARTING_HAS_NONZERO_SEQ_NUMBER;
	}
		
	return yr;
}

/**
 * @brief Kontrola ramca, ci sa jedna o platny ACK ramec na dany datovy ramec.
 *
 * @param ack    Ukazovatel na ACK ramec.
 * @param framr  Ukazovatel na datovy ramec.
 *
 * @return  Popis chyby ACK ramca.
 */
yup_retcode_t
data_is_ack_for_frame(const frame_t * const ack, const frame_t * const frame)
{
	yup_retcode_t yr = DATA_OK;
	
	if (frame_get_data_length(ack) != 0) {
		yr = DATA_ACK_HAS_PAYLOAD;
	} else if (!frame_is_flag_ack_set(ack)) {
		yr = DATA_ACK_HAS_NOT_ACK_FLAG;
	} else if (frame_is_flag_lor_set(ack)) {
		yr = DATA_ACK_HAS_LOR_FLAG;
	} else if (frame_is_flag_rej_set(ack)) {
		yr = DATA_ACK_HAS_REJ_FLAG;
	} else if (frame_get_relation_id(ack) != frame_get_relation_id(frame)) {
		yr = DATA_ACK_RELATION_ID_MISMATCH;
	} else if (frame_get_seq_number(ack) != frame_get_seq_number(frame)) {
		yr = DATA_ACK_SEQ_NUMBER_MISMATCH;
	}
	
	return yr;
}

/**
 * @brief Odoslanie ACK ramca.
 *
 * @param relation_id  ID relacie.
 * @param seq_number   Sekvencne cislo ramca.
 */
void
data_send_ack(uint16_t relation_id, uint16_t seq_number)
{
	frame_t ack;
	
	frame_init(&ack, DATA_PROTOCOL_VERSION);
	frame_set_flag_ack(&ack);
	frame_set_relation_id(&ack, relation_id);
	frame_set_seq_number(&ack, seq_number);
	
	frame_send(&ack);
}

/**
 * @brief Odoslanie REJ ramca k danemu odoslanemu ramca.
 *
 * @param frame     Ukazovatel na nespravny ramec.
 * @param err_code  Chybovy kod vrateny v odosielanom REJ ramci.
 */
void
data_send_rej_for_frame(const frame_t * const frame, uint8_t err_code)
{
	frame_t rej;
	
	frame_init(&rej, frame_get_protocol_version(frame));
	frame_set_flag_rej(&rej);
	frame_set_relation_id(&rej, frame_get_relation_id(frame));
	frame_set_seq_number(&rej, frame_get_seq_number(frame));
	frame_set_data(&rej, &err_code, sizeof(err_code));
	
	frame_send(&rej);
}


typedef enum data_receive_automaton_states {
	DATA_R_WAITING_FOR_STARTING_FRAME,
	DATA_R_START_RELATION,
	DATA_R_SAVE,
	DATA_R_ACK_LAST_FRAME,
	DATA_R_WAITING_NEXT_DATA_FRAME,
	DATA_R_END
} data_receive_automaton_state_t;

typedef enum data_send_automaton_states {
	DATA_S_START_RELATION,
	DATA_S_PEPARE_DATA_FRAME,
	DATA_S_SEND_DATA_FRAME,
	DATA_S_WAIT_ACK,
	DATA_S_END
} data_send_automaton_state_t;

/**
 * @brief Prijatie dat protokolom YUP.
 *
 * @param buf         Ukazovatel na buffer pre ulozenie prijatych dat.
 * @param bufsize     Velkost bufferu v bajtoch.
 * @param bytes_read  Pocet skutocne prijatych bajtov.
 */
yup_retcode_t
data_receive(uint8_t * const buf, size_t bufsize, size_t * const bytes_read)
{
	uint16_t relation_id = 0;
	uint16_t sequence_num = 0;
	size_t data_index = 0;
	deadline_t timeout = wait_get_deadline(DATA_RELATION_TIMEOUT_MS);
	data_receive_automaton_state_t state = DATA_R_WAITING_FOR_STARTING_FRAME;
	
	// Kontrola argumentov
	if ((buf == NULL) || (bufsize == 0)) {
		return DATA_ERROR;
	}
	
	frame_t f;
			
	while (state != DATA_R_END) {
			
		yup_retcode_t r;
		uint8_t l;
				
		switch (state) {
		case DATA_R_WAITING_FOR_STARTING_FRAME:
			// Na prijem startovacieho ramca sa bude cakat donekonecna
			r = frame_receive(&f, NULL, DATA_PROTOCOL_VERSION);		
			if (r != FRAME_OK) {
				// Chyba pri prijme ramca, posle sa naspat REJ so spravou o chybe
				data_send_rej_for_frame(&f, r);
			} else if ((r = data_is_starting_frame(&f)) == DATA_OK) {
				// Mame platny startovaci ramec, zahajime relaciu
				state = DATA_R_START_RELATION;
			}
			break;
			
		case DATA_R_START_RELATION:
			// Od startovacieho ramca zacne plynut cas pre timeout relacie
			timeout = wait_get_deadline(DATA_RELATION_TIMEOUT_MS);
			relation_id = frame_get_relation_id(&f);
			sequence_num = frame_get_seq_number(&f);
			data_index = 0;
			state = DATA_R_SAVE;
			break;
			
		case DATA_R_SAVE:
			if ((bufsize - data_index) < frame_get_data_length(&f)) {
				// Data sa nezmestia do bufferu
				// Pocka sa na dalsi paket, co sa bude hodit
				state = DATA_R_WAITING_NEXT_DATA_FRAME;
			} else {
				// Data sa ulozia
				frame_get_data(&f, buf + data_index, &l);
				// Ulozia sa informacie o naposledy prijatom ramci
				sequence_num = frame_get_seq_number(&f);
				data_index += frame_get_data_length(&f);
				// Ramec sa potvrdi	
				state = DATA_R_ACK_LAST_FRAME;
			}
			break;
			
		case DATA_R_ACK_LAST_FRAME:
			// Potvrdime naposledy prijaty ramec 
			data_send_ack(relation_id, sequence_num);
			// Na posledny ramec relacie sa uz neocakava odpoved
			// Je bezpecne pristupovat k ramcu f, ak ma nastaveny LOR nemoze byt prepisany dalsim ramcom
			if (frame_is_flag_lor_set(&f)) {
				state = DATA_R_END;
			} else {
				// Pockame na prijem dalsieho datoveho ramca
				state = DATA_R_WAITING_NEXT_DATA_FRAME;
			}
			break;
			
		case DATA_R_WAITING_NEXT_DATA_FRAME:
			r = frame_receive(&f, &timeout, DATA_PROTOCOL_VERSION);
			if (r == FRAME_TIMEOUT) {
				// Pri timeoute prijmu prijmu sa nebude opakovane posielat ACK
			} else if (r != FRAME_OK) {
				// Chyba pri prijme datoveho ramca
				data_send_rej_for_frame(&f, r);
			} else if ((r = data_is_data_frame(&f)) != DATA_OK) {
				// Datovy ramec prijaty v poriadku, ale s nespavnym obsahom
				data_send_rej_for_frame(&f, r);
			} else if ((frame_get_seq_number(&f) == 0) && (frame_get_relation_id(&f) != relation_id)) {
				// Jedna sa o zaciatok novej relacie
				state = DATA_R_START_RELATION;
			} else if (frame_get_relation_id(&f) != relation_id) {
				// Obycajny datovy ramec, ale v odlisnej relacii
				data_send_rej_for_frame(&f, (uint8_t) DATA_DATA_RELATION_ID_MISMATCH);
			} else if (frame_get_seq_number(&f) != (sequence_num + 1)) {
				// Obycajny datovy ramec v spravnej relacii, ale nenavazujuci do sekvencie
				data_send_rej_for_frame(&f, (uint8_t) DATA_DATA_SEQ_NUMBER_MISMATCH);
			} else {
				// Spravny navazujuci datovy ramac, ulozia sa jeho data
				state = DATA_R_SAVE;
			}
			break;
			
		case DATA_R_END:
			// Sem sa nedostaneme, len sa umlci prekladac, ze stav nie je osetreny vo switch
			break;
		}
		
		// Kontrola ci vyprsal timeout
		if (wait_has_deadline_expired(&timeout)) {
			// Timeout relacie vyprsal
			state = DATA_R_END;
		}
	}
	
	// Pocet skutocne prijatych bajtov
	*bytes_read = data_index;

	// Pri timeoute relacie sa posle REJ paket
	if (wait_has_deadline_expired(&timeout)) {
		frame_init(&f, DATA_PROTOCOL_VERSION);
		frame_set_relation_id(&f, relation_id);
		frame_set_seq_number(&f, sequence_num);
		data_send_rej_for_frame(&f, DATA_RELATION_TIMEOUT);
		return DATA_ERROR;
	} else {
		return DATA_OK;
	}
}

/**
 * @brief Odoslanie dat protokolom YUP.
 *
 * @param buf         Ukazovatel na buffer dat pre odoslanie.
 * @param bufsize     Velkost bufferu v bajtoch.
 */
yup_retcode_t
data_send(const uint8_t * const buf, size_t bufsize)
{
	static uint16_t relation_id = 0;
	
	uint16_t sequence_num = 0;
	size_t data_index = 0;
	deadline_t timeout;
	deadline_t ack_timeout;
	size_t ack_retry_count = DATA_ACK_RETRY_COUNT;
	
	data_send_automaton_state_t state = DATA_S_START_RELATION;
	timeout = wait_get_deadline(DATA_RELATION_TIMEOUT_MS);
	
	// Kontrola argumentov
	if ((buf == NULL) || (bufsize == 0)) {
		return DATA_ERROR;
	}
	
	frame_t f, a;
	
	while (state != DATA_S_END) {
	
		yup_retcode_t r;
		
		switch (state) {
		case DATA_S_START_RELATION:
			timeout = wait_get_deadline(DATA_RELATION_TIMEOUT_MS);
			++relation_id;
			sequence_num = 0;
			data_index = 0;
			ack_retry_count = DATA_ACK_RETRY_COUNT;
			state = DATA_S_PEPARE_DATA_FRAME;
			break;
			
		case DATA_S_PEPARE_DATA_FRAME:
			// Pripravi sa ramec s datami
			frame_init(&f, DATA_PROTOCOL_VERSION);
			frame_set_relation_id(&f, relation_id);
			frame_set_seq_number(&f, sequence_num);
			size_t len = ((bufsize - data_index) >= FRAME_MAX_DATA_BYTES) ? FRAME_MAX_DATA_BYTES : (bufsize - data_index);
			frame_set_data(&f, buf + data_index, len);
			data_index += len;
			// Je to posledny ramec?
			if (data_index >= bufsize) {
				frame_set_flag_lor(&f);
			}
			state = DATA_S_SEND_DATA_FRAME;
			break;
			
		case DATA_S_SEND_DATA_FRAME:
			// Odosle sa pripraveny ramec
			frame_send(&f);
			// Pocka sa na potvrdenie v danom timetoute
			ack_timeout = wait_get_deadline(DATA_ACK_TIMEOUT_MS);
			state = DATA_S_WAIT_ACK;
			break;
		
		case DATA_S_WAIT_ACK:
			r = frame_receive(&a, &ack_timeout, DATA_PROTOCOL_VERSION);
			if (r == FRAME_TIMEOUT) {
				// Neprijal sa ACK, znovu sa odoslu pipravene data
				if (ack_retry_count-- > 0) {
					state = DATA_S_SEND_DATA_FRAME;
				} else {
					// Bol dosiahnuty maximalny pocet pokusov o znozvu odoslanie dat
					return DATA_ERROR;
				}
			} else if (r != FRAME_OK) {
				// Chyba pri prijme ACK ramca
				data_send_rej_for_frame(&a, r);	
			} else if ((r = data_is_ack_for_frame(&a, &f)) != DATA_OK) {
				// ACK ramec prijaty v poriadku, ale s nespravnym obshom
				data_send_rej_for_frame(&a, r);
			} else if (frame_is_flag_lor_set(&f)) {
				// Datovy ramec, ktory som odoslal, bol posledny
				state = DATA_S_END;	
			} else {
				// Naposledy vyslany datovy ramec bol potvrdeny protistranou, odosle sa dalsi
				sequence_num++;
				state = DATA_S_PEPARE_DATA_FRAME;						
			}
			break;
			
		case DATA_S_END:
			// Sem sa nedostaneme, len sa umlci prekladac, ze stav nie je osetreny vo switch
			break;
		}
		
		// Kontrola ci vyprsal timeout
		if (wait_has_deadline_expired(&timeout)) {
			// Timeout relacie vyprsal
			state = DATA_S_END;
		}
	}
	
	// Pri timeoute relacie sa posle REJ paket
	if (wait_has_deadline_expired(&timeout)) {
		frame_t f;
		frame_init(&f, DATA_PROTOCOL_VERSION);
		frame_set_relation_id(&f, relation_id);
		frame_set_seq_number(&f, sequence_num);
		data_send_rej_for_frame(&f, DATA_RELATION_TIMEOUT);
		return DATA_ERROR;
	} else {
		return DATA_OK;
	}
}