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

Added work_with_tlvs

Browse Source
This commit is contained in:
n07070 2020-03-24 19:39:16 +01:00
parent 882b75433a
commit 8adf0d2bec
2 changed files with 138 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

205
src/node.c
View File

@ -6,20 +6,124 @@
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <time.h>
#include "tlv.h"
#include "node.h"
// We then look at the differents TLVs in the packet.
int work_with_tlvs(struct packet received_packet, char * data_from_packet[], struct sockaddr_in6 sender){
// For every TLV,
// We make sure the TLV is legal.
int number_of_good_tlvs = 0;
int padding_to_next_tlv = 0;
int end_analysis = 0;
while (!end_analysis) {
// Switch
switch (data_from_packet[4 + padding_to_next_tlv]) {
case 0:
// Padding tlv, we can ignore, pass to next tlv.
padding_to_next_tlv++;
number_of_good_tlvs++;
break;
case 1:
// PadN TLV, we can ignore, pass to next tlv.
// Add the length to get to next TLV
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
break;
case 2:
// Neighbour Request TLV
padding_to_next_tlv += 2;
number_of_good_tlvs++;
break;
case 3:
// Neighbour TLV
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
break;
case 4:
// Network hash TLV
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
// TLV Network Hash
// We calculate a network hash,
// We compare both,
// If they differ, we send a TLV Network State Request
// back to the sender.$
break;
case 5:
// Network State Request
padding_to_next_tlv += 2;
number_of_good_tlvs++;
// TLV Network State Request
// We check our neighbourhood, and for each peer, we send back
// to the sender a TLV Node Hash
break;
case 6:
// Node Hash
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
// TLV Node hash
// We get a hash _h_ for the node _l_
// If we don't have an entry for _l_, or if we have the same one as the
// on we just receivied, we send out a TLV Node State Request back.
break;
case 7:
// Node State Request
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
break;
case 8:
// Node State
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
// TLV Node State
// We get a hash _h_, sequence number _s_, data _d_ for node _l_.
// We compute a network hash,
// We compare the hash, if they differ, then with l',s',d' our data and
// h' the corresponding hash,
// if _l_ is our own node id, then
// if s >> s' then we update our sequence number to s ⊕ 1 mod 2^16
// If it's another's node id, then
// If there is no entry for the sender,
// we store the entry in our data table.
break;
case 9:
// Warning
padding_to_next_tlv += data_from_packet[4 + padding_to_next_tlv + 1];
number_of_good_tlvs++;
break;
default:
return -number_of_good_tlvs;
// We have a faulty TLV, thus we ignore and return.
}
// If we arrived at the end of the packet
// or if the length is not possible
if (received_packet.length <= padding_to_next_tlv + 4) {
end_analysis = 1;
}
}
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.
tlv_list validate_tlvs(packet packet_to_validate){
int validate_tlvs(struct packet packet_to_validate){
}
// For every packet recivied,
// then we make sure it's conform
// We then extract the data from it to make it easy to work with
int check_header(char * req[], int buffer_size, packet * packet_to_return){
int check_header(char * req[], int buffer_size, struct packet * packet_to_return){
packet * packet_to_return = (packet*) req;
@ -44,6 +148,13 @@ int check_header(char * req[], int buffer_size, packet * packet_to_return){
return 0;
}
// If the sender is not in the neighbourhood, and we have 15 neighbours, we
// ignore the packet. Otherwise, we add him to the neighbourhood, marked as
// temporary.
int update_neighbours(){
return 0;
};
// We listen forever for new paquets;
void listen_for_packets(){
@ -52,7 +163,7 @@ void listen_for_packets(){
if(s < 0) {
perror(">> Error, cannot create socket.");
perror(">> Exiting...")
perror(">> Exiting...");
exit(1);
}
@ -64,36 +175,35 @@ void listen_for_packets(){
int rc = bind(s, (struct sockaddr*)&server, sizeof(server));
if(rc < 0) {
perror(">> Error, cannot bind socket to choosen port.");
perror(">> Exiting...")
perror(">> Exiting...");
exit(1);
}
// A paquet has at most a length of 1024 bytes
char req[1024];
struct sockaddr_in6 client;
struct sockaddr_in6 sender;
struct iovec io = { .iov_len = 1024, .iov_base = req };
struct msghdr msg_to_receive = {
.msg_name = &client,
.msg_namelen = sizeof(client),
.msg_name = &sender,
.msg_namelen = sizeof(sender),
.msg_iov = &io,
.msg_iovlen = 1
};
while(1){
memset(req, '\0', 1024);
struct sockaddr_in6 client;
unsigned int client_len = sizeof(client);
rc = recvmsg(s, &msg_to_receive, 0);
if(rc < 0) {
perror(">> Error while receiving a new datagram.");
perror(">> Ignoring, continuing...")
perror(">> Ignoring, continuing...");
continue;
}
printf(">> New paquet received :\n");
printf("%s\n", req);
// TODO : Here, we need to fork.
// We verify the received packet is well formated,
// and we return it in the struct designed to work with it.
struct packet * formated_rec_datagram;
@ -102,74 +212,25 @@ void listen_for_packets(){
continue;
}
struct tlv_list received_tlvs;
if (validate_tlvs(formated_rec_datagram) < 0) {
// TODO : Add the neighbour check here.
/* code */
// struct tlv_list received_tlvs;
// if (validate_tlvs(formated_rec_datagram) < 0)
int nbr_success_tlv = work_with_tlvs(formated_rec_datagram, &req, sender);
if (nbr_success_tlv < 0){
perror(">> Error while treating the TLVs of the packet.");
printf(">> Managed to deal with %i TLVs\n", -nbr_success_tlv );
} else {
printf(">> Done working with the TLVs of the packet, listenin for new packets.\n");
}
}
}
// If the sender is not in the neighbourhood, and we have 15 neighbours, we
// ignore the packet. Otherwise, we add him to the neighbourhood, marked as
// temporary.
int update_neighbours(){
};
// We then look at the differents TLVs in the packet.
void work_with_tlvs(){
};
void work_with_tlvs(struct tlvs_list receivied_tlvs){
// For every TLV,
// We make sure the TLV is legal.
if(!validate_tlvs(tlv)){
perror(">> Invalid TLV receivied, it will be ignored.");
}
// Switch
// TLV Network Hash
// We calculate a network hash,
// We compare both,
// If they differ, we send a TLV Network State Request
// back to the sender.
// TLV Network State Request
// We check our neighbourhood, and for each peer, we send back
// to the sender a TLV Node Hash
// TLV Node hash
// We get a hash _h_ for the node _l_
// If we don't have an entry for _l_, or if we have the same one as the
// on we just receivied, we send out a TLV Node State Request back.
// TLV Node State
// We get a hash _h_, sequence number _s_, data _d_ for node _l_.
// We compute a network hash,
// We compare the hash, if they differ, then with l',s',d' our data and
// h' the corresponding hash,
// if _l_ is our own node id, then
// if s >> s' then we update our sequence number to s ⊕ 1 mod 2^16
// If it's another's node id, then
// If there is no entry for the sender,
// we store the entry in our data table.
}
int main(int argc, char const *argv[]) {
int continue = 1;
while(continue){
while(continue != 0){
// We create the neighbourhood table
neighbour_peer neighbour_list[NEIGHBOUR_MAX];
@ -182,7 +243,7 @@ int main(int argc, char const *argv[]) {
// This is in it's own fork.
time_t delay = time(NULL) + 20;
while(! (delay < time(NULL)){
while(! (delay < time(NULL))) {
// Theses functions are there for general book-keeping,and run in there own
// thread, being run every 20 seconds.
// Every 20 sec, if we have less than 5 neighbours, we ask for more peers

8
src/node.h
View File

@ -3,6 +3,8 @@
#ifndef NODE_H
#define NODE_H
#include <sys/socket.h>
#include <netinet/in.h>
#include "tlv.h"
// On which port do we listen to
@ -45,13 +47,13 @@ typedef struct message {
// fonctions signatures
void listen_for_packets();
int check_header(char * received_datagram[], int len, packet pack);
int check_header(char * received_datagram[], int len, struct packet pack);
int validate_tlvs(packet * pack, tlv_list * tlv_l);
int validate_tlvs(struct packet * pack, struct tlv_list * tlv_l);
int update_neighbours();
void work_with_tlvs();
int work_with_tlvs(struct packet received_packet, char * data_from_packet[], struct sockaddr_in6 sender);
// threaded functions