dazibao/src/tlv.c

#include "tlv.h"

// creer un tlv
int build_tlv(tlv *tlv, cmd_token token) {
	switch(token.type) {
		case NEIGHBOUR_REQ:
			// a remplir
			break;
		case NETWORK_STATE_REQ:
			// a remplir
			break;
		case NODE_STATE_REQ:
			// a remplir
			break;
		case POST:
			// a remplir
			break;
		case ERROR:
			printf("Wrong format, use 'req {neighbour | network state | node state}' or 'post {message}'");
			break;
		default:
			perror("Unrecognized tlv type.");
			return -1;
	}

	return -1;
}

int build_pad1(tlv *tlv) {
	// Free the previously allocated memory
	free(tlv->pad1);

	pad1 *new = (pad1*) malloc(sizeof(pad1));

	if(new == NULL)
		return -1;

	new->type = 0;

	tlv->pad1 = new;

	return 0;
}

int build_padn(tlv *tlv, size_t len) {
	// Free the previously allocated memory
	free(tlv->pad1);

	padn *new = (padn*) malloc(sizeof(padn));

	if(new == NULL)
		return -1;

	new->type = 1;
	new->length = len;
	memset(new->mbz, 0, 256);

	tlv->padn = new;

	return 0;
}

int build_neighbour_req(tlv *tlv) {
	// Free the previously allocated memory
	// if (tlv != NULL) {
	// 	free(tlv->pad1);
	// }

	neighbour_req *new = (neighbour_req*) malloc(sizeof(neighbour_req));

	if(new == NULL){
		return -1;
	}

	new->type = 2;
	new->length = 0;

	tlv->neighbour_req = new;

	return 0;
}

int build_neighbour(tlv *tlv, struct in6_addr ip, int16_t port) {
	// Free the previously allocated memory
	free(tlv->pad1);

	neighbour *new = (neighbour*) malloc(sizeof(neighbour));

	if(new == NULL)
		return -1;

	new->type = 3;
	new->length = 18;
	new->ip = ip;
	new->port = port;

	tlv->neighbour = new;

	return 0;
}

int build_network_hash(tlv *tlv, list *data_list) {
	// Free the previously allocated memory
	free(tlv->pad1);

	network_hash *new = (network_hash*) malloc(sizeof(network_hash));

	if(new == NULL)
		return -1;

	new->type = 4;
	new->length = 16;
	hash_network(data_list, (unsigned char*) new->network_hash);

	tlv->network_hash = new;

	return 0;
}

int build_network_state_req(tlv *tlv) {
	// Free the previously allocated memory
	free(tlv->pad1);

	network_state_req *new = (network_state_req*) malloc(sizeof(network_state_req));

	if(new == NULL)
		return -1;

	new->type = 5;
	new->length = 0;

	tlv->network_state_req = new;

	return 0;
}

int build_node_hash(tlv *tlv, int64_t node_id, int16_t seqno, char *data) {
	// Free the previously allocated memory
	free(tlv->pad1);

	node_hash *new = (node_hash*) malloc(sizeof(node_hash));

	if(new == NULL)
		return -1;

	new->type = 6;
	new->length = 26;
	new->node_id = node_id;
	new->seqno = seqno;

	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
	hash_data(&pdata, (unsigned char*) new->node_hash);

	tlv->node_hash = new;

	return 0;
}

int build_node_state_req(tlv *tlv, int64_t node_id) {
	// Free the previously allocated memory
	free(tlv->pad1);

	node_state_req *new = (node_state_req*) malloc(sizeof(node_state_req));

	if(new == NULL)
		return -1;

	new->type = 7;
	new->length = 8;
	new->node_id = node_id;

	tlv->node_state_req = new;

	return 0;
}

int build_node_state(tlv *tlv, int64_t node_id, int16_t seqno, char *data, size_t data_len) {
	// Free the previously allocated memory
	free(tlv->pad1);

	node_state *new = (node_state*) malloc(sizeof(node_state));
	int len = data_len + 26;

	if(new == NULL)
		return -1;

	// en mettant cet octet à 0 on est surs de traiter un champ data de taille 192 max
	if(len > 192) {
		data[192] = 0;
		len = 192;
	}

	new->type = 8;
	new->length = 26 + len;
	new->node_id = node_id;
	new->seqno = seqno;
	memcpy(new->data, data, len);

	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
	hash_data(&pdata, (unsigned char*) new->node_hash);

	tlv->node_state = new;

	return 0;
}

int build_warning(tlv *tlv, char *message, size_t message_len) {
	// Free the previously allocated memory
	free(tlv->pad1);

	warning *new = (warning*) malloc(sizeof(warning));
	int len = message_len;

	if(new == NULL)
		return -1;

	// en mettant cet octet à 0 on est surs de traiter un champ message de taille 256 max
	if(len > 256) {
		message[256] = 0;
		len = 256;
	}

	new->type = 9;
	new->length = len;
	memcpy(new->message, message, len);

	tlv->warning = new;

	return 0;
}