n07070/dazibao
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Trying to fix the receiving of messages

Browse Source
This commit is contained in:
n07070 2020-04-30 19:56:58 +02:00
parent 201084d9f1
commit bd8f5c452b
5 changed files with 180 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/debug.c
View File

@ -55,7 +55,7 @@ void print_data(list * l){
print_debug(">> Printing messages we know of so far :");
int nbr_msg = 0;
setlocale(LC_ALL, "en_US.utf8");
print_debug(">> 🏂🏂🏂🏂 Peer ID | Seqno | Length | Message ");
print_debug(">> Peer ID | Seqno | Length | Message ");
while(l != NULL){
pub_data * message = l->data;
printf("\x1b[31m[DEBUG]\x1b[0m >> %li | %i | %i | “%s” \n", message->id, message->seqno, message->length, message->data);

281
src/node.c
View File

@ -192,9 +192,9 @@ pub_data *get_data(uint64_t id) {
}
// Take data as args and create a pub_data structure in the heap
pub_data *copy_data(unsigned char len, uint64_t id, uint16_t seqno, char *data) {
pub_data *copy_data(unsigned char len, uint64_t id, uint16_t seqno, unsigned char *data) {
pub_data *new_data = (pub_data*) malloc(sizeof(pub_data));
char *_data = (char*) malloc(len);
unsigned char *_data = (unsigned char*) malloc(len);
if (_data == NULL) {
print_error("Failed to allocate memory for copying the data !");
return NULL;
@ -213,7 +213,7 @@ pub_data *copy_data(unsigned char len, uint64_t id, uint16_t seqno, char *data)
}
// A node state TLV was received and either no data associated to it's id is in our data list or the data was updated, return -1 if an error occurend, 0 if nothing had to be done and 1 if something was updated/added
int add_data(unsigned char len, uint64_t id, uint16_t seqno, char *data, pub_data *found) {
int add_data(unsigned char len, uint64_t id, uint16_t seqno, unsigned char *data, pub_data *found) {
// Check if it's our own id
if(id == NODE_ID) {
// wtf
@ -249,7 +249,7 @@ int add_data(unsigned char len, uint64_t id, uint16_t seqno, char *data, pub_dat
// Updata message
free(found->data);
found->data = (char*) malloc(len);
found->data = (unsigned char*) malloc(len);
memcpy(found->data, data, len);
printf(">> Updated %li's published data.\n", id);
@ -492,7 +492,7 @@ int send_packet(char *packet_buff, uint16_t length, struct sockaddr_in6 *dest, i
int response_code = sendmsg(socket_num, &packet_tlv_send_out, 0);
if (response_code < 0) {
print_debug(">> Unable to send out the packet to peer.");
print_error("Unable to send out the packet to peer.");
error_while_sending = 1;
} else if (response_code < length) {
print_debug(">> Sent out only part of the packet.");
@ -578,70 +578,70 @@ int send_single_tlv(tlv *tlv, struct sockaddr_in6 *dest, int socket_num) {
return send_packet((char*) &pack, pack.length, dest, socket_num);
}
int send_tlv(tlv *tlv_to_send, uint16_t tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num){
print_debug(">> Building packet to send a TLV.");
// We first need to build the packet,
char packet_buff[1024];
struct packet pack;
pack.magic = 95;
pack.version = 1;
if (tlv_size > 1020) {
print_debug(">> Unable to send the tlv, it's size if above 1020 bytes.");
return -1;
} else {
memcpy((void *) pack.body, tlv_to_send, tlv_size);
}
// Move the content of the paquet struct to a buffer
// That will be send out in a vectorized buffer.
// packet_buff = (char *) pack;
memcpy(&packet_buff,&pack,1024);
if (DEBUG_LEVEL > 1) {
print_debug(">> Packet has been built.");
}
// Vectorized buffer
struct iovec vec_buff = { .iov_len = sizeof(packet_buff), .iov_base = packet_buff };
int error_while_sending = 0;
// For every dest
for (size_t i = 0; i < dest_list_size; i++) {
// Creating the struct to send out with sendmsg
struct msghdr packet_tlv_send_out = {
.msg_name = &dest_list[i],
.msg_namelen = sizeof(dest_list[i]),
.msg_iov = &vec_buff,
.msg_iovlen = 1 // We have only one iovec buffer. But if we had 2, we would write 2.
};
int response_code = sendmsg((int) socket_num, &packet_tlv_send_out, 0);
if (response_code < 0) {
if (DEBUG_LEVEL > 0) {
printf("\x1b[31m[DEBUG]\x1b[0m >> Unable to send out the packet to peer %li", i);
}
error_while_sending = 1;
continue;
} else if (response_code < sizeof(packet_tlv_send_out)) {
print_debug(">> Sent out only part of the packet.");
error_while_sending = 1;
continue;
} else {
if (DEBUG_LEVEL > 0) {
printf("\x1b[31m[DEBUG]\x1b[0m >> Send out packet to peer %li", i);
}
}
}
if (error_while_sending == 1) {
print_debug(">> Error occured while sending out a packet.");
return -1;
} else {
return 0;
}
}
// TODO This function can be deleted.
// int send_tlv(tlv *tlv_to_send, uint16_t tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num){
// print_debug(">> Building packet to send a TLV.");
//
// // We first need to build the packet,
// char packet_buff[1024];
// struct packet pack;
// pack.magic = 95;
// pack.version = 1;
// if (tlv_size > 1020) {
// print_debug(">> Unable to send the tlv, it's size is above 1020 bytes.");
// return -1;
// } else {
// memcpy((void *) pack.body, tlv_to_send, tlv_size);
// }
//
// // Move the content of the paquet struct to a buffer
// // That will be send out in a vectorized buffer.
// memcpy(&packet_buff,&pack,1024);
//
// if (DEBUG_LEVEL > 1) {
// print_debug(">> Packet has been built.");
// }
//
// // Vectorized buffer
// struct iovec vec_buff = { .iov_len = sizeof(packet_buff), .iov_base = packet_buff };
//
// int error_while_sending = 0;
//
// // For every dest
// for (size_t i = 0; i < dest_list_size; i++) {
// // Creating the struct to send out with sendmsg
// struct msghdr packet_tlv_send_out = {
// .msg_name = &dest_list[i],
// .msg_namelen = sizeof(dest_list[i]),
// .msg_iov = &vec_buff,
// .msg_iovlen = 1 // We have only one iovec buffer. But if we had 2, we would write 2.
// };
//
// int response_code = sendmsg((int) socket_num, &packet_tlv_send_out, 0);
// if (response_code < 0) {
// if (DEBUG_LEVEL > 0) {
// printf("\x1b[31m[DEBUG]\x1b[0m >> Unable to send out the packet to peer %li", i);
// }
// error_while_sending = 1;
// continue;
// } else if (response_code < sizeof(packet_tlv_send_out)) {
// print_debug(">> Sent out only part of the packet.");
// error_while_sending = 1;
// continue;
// } else {
// if (DEBUG_LEVEL > 0) {
// printf("\x1b[31m[DEBUG]\x1b[0m >> Sent out packet to peer %i", i);
// }
// }
// }
//
// if (error_while_sending == 1) {
// print_debug(">> Error occured while sending out a packet.");
// return -1;
// } else {
// return 0;
// }
// }
// We need to make sure the TLV announces a length that will no go onto
// another tlv, as we might end up reading bullshit.
@ -660,13 +660,13 @@ int validate_tlv(char *data, int pos, uint16_t packet_len){
print_debug(">> Reading outside of packet's max length.");
return -1;
}
// 0 1 2 3 = Packet
// 4 = type 5 = tlv_len
// 0 1 2 3 = Packet
// 4 = type 5 = tlv_len
unsigned char tlv_len = data[pos+1];
// Check that the tlv does not exceed the packet length
if(pos + tlv_len > packet_len){
print_debug(">> The TLV Length exceed the packet length\n");
print_debug(">> The TLV Length exceeds the packet length\n");
return -1;
}
@ -738,8 +738,9 @@ int check_header(char * received_data_buffer, int received_data_len, struct pack
int add_message(char * message, int message_len){
// Don't update the message if it's empty
if(message_len == 0)
if(message_len == 0){
return -1;
}
// If not, get our data in the list and update it
pub_data *our_data = get_data(NODE_ID);
@ -748,8 +749,8 @@ int add_message(char * message, int message_len){
our_data->seqno = (our_data->seqno + 1) % 65535;
our_data->length = message_len;
free(our_data->data);
our_data->data = (char*) malloc(message_len);
memcpy(our_data->data, message, message_len);
our_data->data = (unsigned char*) malloc(message_len);
memcpy(our_data->data, (unsigned char *) message, message_len);
print_debug(">> Message added.");
@ -768,6 +769,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
print_debug(">> Length indicated in packet differs from real length of packet received, disgarding packet.");
return -1;
}
int nbr_of_tlvs = 0;
int pos = 4;
unsigned char tlv_len, hash[16];
@ -780,11 +782,13 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
new_tlv.pad1 = NULL;
cur_tlv.pad1 = NULL;
list *tmp_list;
pub_data *pdata;
list * tmp_list;
pub_data * pdata;
// holds the random neighbour we send back in case of a neighbour_req.
struct neighbour_peer *random_neighbour;
// memset(random_neighbour, 0, sizeof(struct neighbour_peer));
// Holds the new neighbour send to us by a "neighbour tlv"
struct sockaddr_in6 new_neighbour;
@ -792,32 +796,31 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
packet pack = (packet) {.magic = 95, .version = 1, .length = 0};
memset(pack.body, 0, 1020);
/*
int ifindex = if_nametoindex("enp3s0");
if(ifindex == 0) {
int ifindex = if_nametoindex("eth0");
if(ifindex == 0) {
perror("if_nametoindex failed");
return -1;
}
}
*/
int ifindex = 0;
while(pos < total_packet_len) {
// Making sure the current TLV we are looking at is valid.
// TODO : I think we should reset all the structs here.
// memset(random_neighbour, 0, sizeof(struct neighbour_peer));
// memset(pdata, 0, sizeof(struct pub_data));
// memset(tmp_list, 0, sizeof(struct list));
memset(hash, 0, 16);
memset(warn, 0, 32);
tlv_len = 0;
switch(validate_tlv(data, pos, total_packet_len)) {
case 0:
// We received a padding tlv so it is ignored
print_debug(">> Received padding tlv, ignoring...");
pos += 1;
nbr_of_tlvs++;
break;
case 1:
// We received a padding tlv so it is ignored
print_debug(">> Received padding(n) tlv, ignoring...");
tlv_len = data[pos+1];
pos += tlv_len + 2;
nbr_of_tlvs++;
break;
case 2:
@ -840,6 +843,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
// The position is updated
tlv_len = data[pos+1];
pos += tlv_len + 2;
nbr_of_tlvs++;
break;
case 3:
@ -862,6 +866,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
// The position is updated
tlv_len = data[pos+1];
pos += tlv_len + 2;
nbr_of_tlvs++;
break;
case 4:
@ -898,6 +903,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
// The position is updated
tlv_len = data[pos+1];
pos += tlv_len + 2;
nbr_of_tlvs++;
break;
case 5:
@ -915,7 +921,8 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
}
// The position is updated
pos += 2;
tlv_len = data[pos+1];
pos += tlv_len + 2;
break;
case 6:
@ -936,13 +943,14 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
if(memcmp(hash, cur_tlv.node_hash->node_hash, 16) == 0) {
// The position is updated
tlv_len = data[pos+1];
pos += 2;
pos += tlv_len + 2;
print_debug(">> Both hashs are the same, nothing to do.");
break;
}
}
print_debug(">> No hash found, or hashs are differents, sending back node state request.");
// If no pub_data was found or the hashes differ then we send a node state request
build_node_state_req(&new_tlv, be64toh(cur_tlv.node_hash->node_id));
add_tlv(&pack, &new_tlv, sender, socket_num);
@ -964,7 +972,9 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
if(pdata != NULL) {
build_node_state(&new_tlv, pdata->id, pdata->seqno, pdata->data, pdata->length);
add_tlv(&pack, &new_tlv, sender, socket_num);
}
} else {
print_debug(">> Found no data for the requested node, skipping...");
}
// The position is updated
tlv_len = data[pos+1];
@ -976,19 +986,23 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
// we add it to the data list
// or update the data stored
print_debug(">> Received node state, updating...");
cur_tlv.node_state = (node_state*) (data + pos);
cur_tlv.node_state = (node_state*) (data + pos);
print_debug(">> Received message ! ");
printf("%d\n", cur_tlv.node_state->type );
printf("%d\n", cur_tlv.node_state->length );
printf("%lu\n", cur_tlv.node_state->node_id );
printf("%hu\n", cur_tlv.node_state->seqno );
printf("%.16s\n", cur_tlv.node_state->node_hash);
printf("%s\0\n", cur_tlv.node_state->data);
sprintf(warn, ">> WARNING:\n%%.%ds", cur_tlv.node_state->length);
printf(warn, cur_tlv.node_state->data);
sleep(3);
printf("Type : %d\n", cur_tlv.node_state->type );
printf("Length : %d\n", cur_tlv.node_state->length );
printf("Node ID : %lu\n", be64toh(cur_tlv.node_state->node_id) );
printf("Seqno : %hu\n", be16toh(cur_tlv.node_state->seqno) );
printf("Hash :");
for(int x = 0; x < 16; x++){
printf("%02x", cur_tlv.node_state->node_hash[x]);
fflush(0);
}
printf("\n");
for(int x = 0; x < 192; x++){
printf("%d", cur_tlv.node_state->data[x]);
fflush(0);
}
if (DEBUG_LEVEL > 0) {
if (cur_tlv.node_state->data == NULL) {
@ -996,6 +1010,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
return -1;
}
printf("\x1b[31m[DEBUG]\x1b[0m >> “%ls\0”\n", (const wchar_t*) cur_tlv.node_state->data);
sleep(1);
}
// Compare hashes
@ -1011,7 +1026,7 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
if(memcmp(hash, cur_tlv.node_state->node_hash, 16) == 0) {
// The position is updated
tlv_len = data[pos+1];
pos += 2;
pos += tlv_len + 2;
break;
}
@ -1046,7 +1061,8 @@ int work_with_tlvs(char * data, uint16_t total_packet_len, struct sockaddr_in6 *
// A malformed packet was found so we stop looking for more packets and send a warning tlv
strcpy(warn, "Packet is malformed.");
print_debug(">> Malformed packet, we won't treat it.");
build_warning(&new_tlv, warn, strlen(warn));
print_debug(">> Sending back a Warning to sender.");
build_warning(&new_tlv,(unsigned char *) warn, strlen(warn));
add_tlv(&pack, &new_tlv, sender, socket_num);
return -1;
@ -1221,20 +1237,20 @@ int run_node(int sock_fd){
/* Call poll() */
ret = poll(fds, 2, 5);
ret = poll(fds, 2, 10);
if (ret < 0) {
print_debug(">> Error - poll returned error");
print_error("Poll returned error");
break;
} else if (ret > 0) {
/* Regardless of requested events, poll() can always return these */
if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
print_debug("Error - poll indicated stdin error\n");
print_error("Poll indicated stdin error\n");
break;
}
if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
print_debug("Error - poll indicated socket error\n");
print_error("Poll indicated socket error\n");
break;
}
@ -1242,9 +1258,10 @@ int run_node(int sock_fd){
if (fds[0].revents & (POLLIN | POLLPRI)) {
bytes = read(0, input_buffer, sizeof(input_buffer));
if (bytes < 0) {
print_debug(">> Error - stdin error");
print_error("stdin error");
break;
}
// Remove trailing \n
input_buffer[strcspn(input_buffer, "\n")] = 0;
if (DEBUG_LEVEL > 0) {
printf("\x1b[31m[DEBUG]\x1b[0m >> Adding following message to the table : “%s”\n", input_buffer );
@ -1252,7 +1269,9 @@ int run_node(int sock_fd){
// Add message to the message table.
if (add_message(input_buffer, bytes) < 0) {
print_debug(">> Error while trying to add the message to the list of messages, please try again..");
}
// Reset buffer
memset(input_buffer, 0, sizeof(input_buffer));
}
}
// Read data from the socket ( incoming packet )
@ -1288,6 +1307,8 @@ int run_node(int sock_fd){
if (work_tlv_status < 0) {
print_debug(">> Error while treating the incoming packet.");
}
// Reset buffer
memset(output_buffer, 0, sizeof(output_buffer));
}
}
} else {
@ -1304,7 +1325,7 @@ int run_node(int sock_fd){
// This function runs once, and sets the sock_fd as well as the neighbourhood
int bootstrap_node(int * sock_fd){
int bootstrap_node(int * sock_fd, char * root_peer_ip, uint16_t root_peer_port){
print_debug(">> Boostraping node...");
struct sockaddr_in6 server_addr;
@ -1312,42 +1333,46 @@ int bootstrap_node(int * sock_fd){
/* Create UDP socket */
* sock_fd = socket(AF_INET6, SOCK_DGRAM, 0);
if ( * sock_fd < 0) {
print_debug(">> Error - failed to open socket");
return -1;
print_error("Failed to open socket");
perror("");
exit(-1);
}
/* Bind socket */
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sin6_family = AF_INET6;
// server_addr.sin6_addr.in6_addr = htonl(INADDR_ANY);
server_addr.sin6_port = htobe16(LISTEN_PORT);
server_addr.sin6_port = LISTEN_PORT;
if (bind( * sock_fd, (struct sockaddr *)(&server_addr), sizeof(server_addr)) < 0) {
print_debug(">> Error - failed to bind socket");
return -2;
print_error("Failed to bind socket");
perror("");
exit(-1);
}
/* Make the first peer*/
struct neighbour_peer * root_peer = (struct neighbour_peer *) malloc(sizeof(struct neighbour_peer));
time_t root_peer_seen = time(NULL);
int inet_p = inet_pton(AF_INET6, ROOT_PEER_ADDR, &root_peer->ip);
int inet_p = inet_pton(AF_INET6, root_peer_ip, &root_peer->ip);
if(inet_p < 1){
perror(">> Failed to create the root peer.");
return -3;
}
root_peer->port = 1212;
root_peer->port = root_peer_port;
root_peer->is_temporary = 0;
root_peer->last_seen = root_peer_seen;
// TODO: Add the first peer to the neighbourhood
print_debug(">> Adding the first root peer to the list...");
neighbour_list = malloc(sizeof(struct list));
memset(neighbour_list, 0, sizeof(struct list));
neighbour_list->data = (void *) root_peer;
neighbour_list->next = NULL;
print_debug(">> Initializing data list...");
data_list = (list*) malloc(sizeof(list));
memset(data_list, 0, sizeof(struct list));
data_list->data = malloc(sizeof(pub_data));
data_list->next = NULL;
@ -1363,11 +1388,27 @@ int bootstrap_node(int * sock_fd){
int main(int argc, const char *argv[]) {
if (argc != 3) {
print_error("Usage : ./dazibao <root peer IPv6> <port number>");
exit(-1);
}
char *end;
intmax_t val = strtoimax(argv[2], &end, 10);
if (errno == ERANGE || val < 0 || val > UINT16_MAX || end == argv[2] || *end != '\0'){
print_error("Conversion of port number failed, please choose a smaller number.");
}
uint16_t root_peer_port = (uint16_t) val;
char * root_peer_ip = (char *) argv[1];
setlocale(LC_ALL, "");
print_debug(">> Starting node");
int sock_fd;
bootstrap_node(&sock_fd);
bootstrap_node(&sock_fd, root_peer_ip, root_peer_port);
run_node(sock_fd);
close(sock_fd);

12
src/node.h
View File

@ -43,7 +43,7 @@ typedef struct pub_data {
unsigned char length;
uint64_t id;
uint16_t seqno;
char *data;
unsigned char *data;
} pub_data;
// General list
@ -62,14 +62,14 @@ typedef struct list {
// The node ID
// #define NODE_ID 42675882021843277
#define NODE_ID 42013376900101010
#define NODE_ID 13809235719890846928
// The number of neighbours
// The neighbour table has 15 entries
#define NEIGHBOUR_MAX 15
// The adress of the main peer
#define ROOT_PEER_ADDR "2001:660:3301:9200::51c2:1b9b"
#define ROOT_PEER_ADDR "::1"
// fonctions signatures
@ -124,7 +124,7 @@ int add_message(char * message, int message_len);
// This functions creates the structures needed for the rest of the project,
// creates the socket, and returns all of it.
int bootstrap_node(int * sock_fd);
int bootstrap_node(int * sock_fd, char * root_peer_ip, uint16_t root_peer_port);
// Helper functions
int len_list(list *l);
@ -141,9 +141,9 @@ int add_n_update_neighbour(struct in6_addr *ip, int16_t port);
pub_data *get_data(uint64_t id);
// Take data as args and create a pub_data structure in the heap
pub_data *copy_data(unsigned char len, uint64_t id, uint16_t seqno, char *data);
pub_data *copy_data(unsigned char len, uint64_t id, uint16_t seqno, unsigned char *data);
// add new data to data list
int add_data(unsigned char len, uint64_t id, uint16_t seqno, char *data, pub_data *found);
int add_data(unsigned char len, uint64_t id, uint16_t seqno, unsigned char *data, pub_data *found);
#endif

8
src/tlv.c
View File

@ -144,7 +144,7 @@ int build_network_state_req(tlv *tlv) {
return 0;
}
int build_node_hash(tlv *tlv, uint64_t node_id, uint16_t seqno, char *data) {
int build_node_hash(tlv *tlv, uint64_t node_id, uint16_t seqno, unsigned char *data) {
// Free the previously allocated memory
free(tlv->pad1);
@ -187,7 +187,7 @@ int build_node_state_req(tlv *tlv, uint64_t node_id) {
return 0;
}
int build_node_state(tlv *tlv, uint64_t node_id, uint16_t seqno, char *data, size_t data_len) {
int build_node_state(tlv *tlv, uint64_t node_id, uint16_t seqno, unsigned char *data, size_t data_len) {
// Free the previously allocated memory
free(tlv->pad1);
@ -219,13 +219,13 @@ int build_node_state(tlv *tlv, uint64_t node_id, uint16_t seqno, char *data, siz
return 0;
}
int build_warning(tlv *tlv, char *message, size_t message_len) {
int build_warning(tlv *tlv, unsigned char *message, size_t message_len) {
// Free the previously allocated memory
free(tlv->pad1);
warning *new = (warning*) malloc(sizeof(warning));
memset(new, 0, sizeof(warning));
int len = message_len;
if(new == NULL)

16
src/tlv.h
View File

@ -53,7 +53,7 @@ typedef struct neighbour {
typedef struct network_hash {
unsigned char type;
unsigned char length;
char network_hash[16];
unsigned char network_hash[16];
} network_hash;
// 2 octets
@ -68,7 +68,7 @@ typedef struct node_hash {
unsigned char length;
uint64_t node_id;
uint16_t seqno;
char node_hash[16];
unsigned char node_hash[16];
} node_hash;
// 10 octets
@ -84,15 +84,15 @@ typedef struct node_state {
unsigned char length;
uint64_t node_id;
uint16_t seqno;
char node_hash[16];
char data[192];
unsigned char node_hash[16];
unsigned char data[192];
} node_state;
// 2 octets min, 258 ocets max (unsigned char 0 -> 255)
typedef struct warning {
unsigned char type;
unsigned char length;
char message[256];
unsigned char message[256];
} warning;
typedef union tlv {
@ -122,9 +122,9 @@ int build_neighbour_req(union tlv *tlv);
int build_neighbour(tlv *tlv, struct in6_addr ip, int16_t port);
int build_network_hash(tlv *tlv, list *data_list);
int build_network_state_req(tlv *tlv);
int build_node_hash(tlv *tlv, uint64_t node_id, uint16_t seqno, char *data);
int build_node_hash(tlv *tlv, uint64_t node_id, uint16_t seqno, unsigned char *data);
int build_node_state_req(tlv *tlv, uint64_t node_id);
int build_node_state(tlv *tlv, uint64_t node_id, uint16_t seqno, char *data, size_t data_len);
int build_warning(tlv *tlv, char *message, size_t message_len);
int build_node_state(tlv *tlv, uint64_t node_id, uint16_t seqno, unsigned char *data, size_t data_len);
int build_warning(tlv *tlv, unsigned char *message, size_t message_len);
#endif