From 1295a91f42dfd238a6cd2d61ac4ad17f7655def7 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Tue, 31 Mar 2020 22:35:56 +0200
Subject: [PATCH 01/18] =?UTF-8?q?Ajout=20d'une=20premi=C3=A8re=20makefile?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Makefile | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 Makefile

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..edf58ae
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,18 @@
+TARGET ?= dazibao
+SRC_DIRS ?= ./src/*
+CC := gcc -Wall
+SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c -or -name *.s)
+OBJS := $(addsuffix .o,$(basename $(SRCS)))
+DEPS := $(OBJS:.o=.d)
+
+INC_DIRS := $(shell find $(SRC_DIRS) -type d)
+INC_FLAGS := $(addprefix -I,$(INC_DIRS))
+
+$(TARGET): $(OBJS)
+	$(CC) $(LDFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS)
+
+.PHONY: clean
+clean:
+	$(RM) $(TARGET) $(OBJS) $(DEPS)
+
+-include $(DEPS)

From f90caceeb4f2956e0099e42bbffc892bedfe7115 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Tue, 31 Mar 2020 22:47:48 +0200
Subject: [PATCH 02/18] Ajouts des flags pour openSSL

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index edf58ae..b8b2f19 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 TARGET ?= dazibao
 SRC_DIRS ?= ./src/*
-CC := gcc -Wall
+CC := gcc -Wall -lssl -lcrypto
 SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c -or -name *.s)
 OBJS := $(addsuffix .o,$(basename $(SRCS)))
 DEPS := $(OBJS:.o=.d)

From 4a616dbfe05a8f637e69b5b75ed50b625db43155 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 17:51:25 +0200
Subject: [PATCH 03/18] Ajout de la signature de la fonction d'envoie de paquet

---
 src/node.h | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/node.h b/src/node.h
index d4ba94b..0b709b4 100644
--- a/src/node.h
+++ b/src/node.h
@@ -77,6 +77,12 @@ void add_tlv(packet *packet, tlv *tlv, char type);
 
 int send_packet(struct tlv_list tlvs_to_send, );
 
+/* Prend un tlv, et construit un paquet pour ensuite l'envoyer à la liste
+ * des paires.
+ * Retourne -1 en cas d'échec, 0 en cas de succès.
+ */
+int send_tlv(struct tlv, struct sockaddr_in6 * sender_list[], int sender_list_size);
+
 // threaded functions
 
 void t_ask_for_more_peers();

From d637d8c1ef3eb62e1b131aeae6d670c9c26fbd4e Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 17:51:54 +0200
Subject: [PATCH 04/18] Suppression temporaire de la fonction send_paquet.

---
 src/node.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node.h b/src/node.h
index 0b709b4..fbed67f 100644
--- a/src/node.h
+++ b/src/node.h
@@ -75,7 +75,7 @@ int work_with_tlvs(struct packet received_packet, char * data_from_packet[], str
 
 void add_tlv(packet *packet, tlv *tlv, char type);
 
-int send_packet(struct tlv_list tlvs_to_send, );
+int send_packet();
 
 /* Prend un tlv, et construit un paquet pour ensuite l'envoyer à la liste
  * des paires.

From b7478364abe752d3fce3bd7d34f86e7f77868efe Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 17:54:01 +0200
Subject: [PATCH 05/18] Ajout de la signature de la fonction envoyant plusieurs
 TLV

---
 src/node.h | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/node.h b/src/node.h
index fbed67f..006f803 100644
--- a/src/node.h
+++ b/src/node.h
@@ -83,8 +83,14 @@ int send_packet();
  */
 int send_tlv(struct tlv, struct sockaddr_in6 * sender_list[], int sender_list_size);
 
-// threaded functions
 
+/* Prend une liste de tlv, et construit un paquet pour ensuite les envoyer à la liste
+ * des paires. Chaque pair recevera la même liste de TLV.
+ * Retourne -1 en cas d'échec, 0 en cas de succès.
+ */
+int send_tlvs(struct list * tlv_list, struct sockaddr_in6 * sender_list[], int sender_list_size);
+
+// threaded functions
 void t_ask_for_more_peers();
 
 void t_update_neighbours();

From e1276448f1a0a3428ed83843f2d79d7288237fe6 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 17:56:17 +0200
Subject: [PATCH 06/18] Traduction des commentaires en anglais, Modification de
 la signature des deux fonctions

---
 src/node.c | 5 +++++
 src/node.h | 6 +++---
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/node.c b/src/node.c
index 499651d..dff0c29 100644
--- a/src/node.c
+++ b/src/node.c
@@ -45,6 +45,11 @@ neighbour_peer *get_random_neighbour() {
 
 /* ---- Fin fonctions utilitaires ---- */
 
+// This function 
+int send_tlv(struct tlv, struct sockaddr_in6 * sender_list[], int sender_list_size){
+
+}
+
 // We need to make sure the TLV announces a length that will no go onto
 // another tlv, as we might end up reading bullshit.
 int validate_tlv(char *data, int pos, short packet_len){
diff --git a/src/node.h b/src/node.h
index 006f803..38fbc1b 100644
--- a/src/node.h
+++ b/src/node.h
@@ -77,18 +77,18 @@ void add_tlv(packet *packet, tlv *tlv, char type);
 
 int send_packet();
 
-/* Prend un tlv, et construit un paquet pour ensuite l'envoyer à la liste
+/* Takes a TLV and sends it over to everyone in the list of addresses.
  * des paires.
  * Retourne -1 en cas d'échec, 0 en cas de succès.
  */
-int send_tlv(struct tlv, struct sockaddr_in6 * sender_list[], int sender_list_size);
+int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size);
 
 
 /* Prend une liste de tlv, et construit un paquet pour ensuite les envoyer à la liste
  * des paires. Chaque pair recevera la même liste de TLV.
  * Retourne -1 en cas d'échec, 0 en cas de succès.
  */
-int send_tlvs(struct list * tlv_list, struct sockaddr_in6 * sender_list[], int sender_list_size);
+int send_tlvs(struct list * tlv_list, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size);
 
 // threaded functions
 void t_ask_for_more_peers();

From b96655da72587cc738883c319e2c7f37281c2d3c Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 18:43:53 +0200
Subject: [PATCH 07/18] Ajout de la fonction d'envoie de tlv

---
 src/node.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
 src/node.h |  4 ++--
 src/tlv.c  |  4 ++--
 3 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/src/node.c b/src/node.c
index dff0c29..fbe2830 100644
--- a/src/node.c
+++ b/src/node.c
@@ -45,9 +45,63 @@ neighbour_peer *get_random_neighbour() {
 
 /* ---- Fin fonctions utilitaires ---- */
 
-// This function 
-int send_tlv(struct tlv, struct sockaddr_in6 * sender_list[], int sender_list_size){
+int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int sock_num){
+	debug_print("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(sizeof(tlv_to_send) > 1020){
+		debug_print("Unable to send TLV, the size is bigger than 1020 bits.");
+		return -1;
+	} else {
+		pack.length = sizeof(tlv_to_send);
+		strcpy(pack.body, (char) tlv_to_send);
+	}
+
+	// Casting the struct to a buffer.
+	packet_buff = (char *) pack;
+
+	debug_print("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.
+		};
+
+		response_code = sendmsg((int) sock_num, &packet_tlv_send_out, 0);
+		if (response_code < 0) {
+			debug_print("Unable to send out the packet to peer %i", i);
+			error_while_sending = 1;
+			continue;
+		} else if (response_code < sizeof(packet_tlv_send_out)) {
+			debug_print("Sent out only part of the packet.");
+			error_while_sending = 1;
+			continue;
+		} else {
+			debug_print("Send out packet to peer %i", i);
+		}
+	}
+
+	if (error_while_sending == 1) {
+		debug_print("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
diff --git a/src/node.h b/src/node.h
index 38fbc1b..87fe047 100644
--- a/src/node.h
+++ b/src/node.h
@@ -81,14 +81,14 @@ int send_packet();
  * des paires.
  * Retourne -1 en cas d'échec, 0 en cas de succès.
  */
-int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size);
+int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 
 
 /* Prend une liste de tlv, et construit un paquet pour ensuite les envoyer à la liste
  * des paires. Chaque pair recevera la même liste de TLV.
  * Retourne -1 en cas d'échec, 0 en cas de succès.
  */
-int send_tlvs(struct list * tlv_list, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size);
+int send_tlvs(struct list * tlv_list, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 
 // threaded functions
 void t_ask_for_more_peers();
diff --git a/src/tlv.c b/src/tlv.c
index 2284815..e19cfd9 100644
--- a/src/tlv.c
+++ b/src/tlv.c
@@ -180,9 +180,9 @@ int build_warning(tlv *tlv, char *message) {
 
 	new->type = 9;
 	new->length = len;
-	memcpy(new->message, message, len); 
+	memcpy(new->message, message, len);
 
 	tlv->warning = new;
 
 	return 0;
-}
\ No newline at end of file
+}

From 05e934672654a8cc3121148e352acab2b693bd37 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 1 Apr 2020 18:47:38 +0200
Subject: [PATCH 08/18] Traduction des commentaires vers l'anglais

---
 src/node.h | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/node.h b/src/node.h
index 87fe047..0f7e2c6 100644
--- a/src/node.h
+++ b/src/node.h
@@ -78,15 +78,12 @@ void add_tlv(packet *packet, tlv *tlv, char type);
 int send_packet();
 
 /* Takes a TLV and sends it over to everyone in the list of addresses.
- * des paires.
- * Retourne -1 en cas d'échec, 0 en cas de succès.
+ * Returns -1 in case of error, 0 otherwise.
  */
 int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 
-
-/* Prend une liste de tlv, et construit un paquet pour ensuite les envoyer à la liste
- * des paires. Chaque pair recevera la même liste de TLV.
- * Retourne -1 en cas d'échec, 0 en cas de succès.
+/* Takes a list of TLV and sends them over to everyone in the list of addresses.
+ * Returns -1 in case of error, 0 otherwise.
  */
 int send_tlvs(struct list * tlv_list, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 

From 9c93785ca634e67a4e74cb942f66dd5079e522cf Mon Sep 17 00:00:00 2001
From: gonzalef <kneesbrah@gmail.com>
Date: Tue, 7 Apr 2020 19:05:30 +0200
Subject: [PATCH 09/18] work with tlvs

---
 src/node.c | 266 ++++++++++++++++++++++++++++++++++++++++++++++-------
 src/node.h |   9 ++
 src/tlv.c  |  22 +++--
 src/tlv.h  |  11 ++-
 4 files changed, 259 insertions(+), 49 deletions(-)

diff --git a/src/node.c b/src/node.c
index 499651d..689ce52 100644
--- a/src/node.c
+++ b/src/node.c
@@ -43,6 +43,121 @@ neighbour_peer *get_random_neighbour() {
     return (neighbour_peer*) tmp->data;
 }
 
+// get data associated with id, if it doesn't exist return NULL
+pub_data *get_data(long id) {
+	list *tmp = data_list;
+	pub_data *data;
+
+	while(tmp != NULL) {
+		data = (pub_data*) tmp->data;
+
+		if(data->id == id)
+			return data;
+	}
+
+	return NULL;
+}
+
+// Take data as args and create a pub_data structure in the heap
+pub_data *copy_data(unsigned char len, long id, short seqno, char *data) {
+	pub_data *new_data = (pub_data*) malloc(sizeof(pub_data));
+	char *_data = (char*) malloc(len); 
+	new_data->length = len;
+	new_data->id = id;
+	new_data->seqno = seqno;
+	new_data->data = _data;
+	memcpy(_data, data, len);
+
+	return new_data;
+}
+
+// Add new data to data list
+void add_data(unsigned char len, long id, short seqno, char *data) {
+	// If id is the same as this node's id then we only update seqno
+	if(id == NODE_ID) {
+		pub_data *node_data = get_data(NODE_ID);
+
+		if(seqno >= node_data->seqno) {
+			node_data->seqno = seqno ^ 1;
+		}
+
+		return;
+	}
+
+	// Copy data
+	pub_data *new_data = copy_data(len, id, seqno, data);
+
+	if(data_list == NULL) {
+		// Update list
+		data_list = (list*) malloc(sizeof(list));
+		data_list->data = (void*) new_data;
+		data_list->next = NULL;
+
+		return;
+	}
+
+	// Find correct position for new data
+	list *tmp = data_list;
+	list *last = NULL;
+	list *new_node;
+	long cur_id;
+
+	while(tmp != NULL) {
+		cur_id = ((pub_data*) tmp->data)->id;
+
+		// If id is smaller than cur_id then the new data has to be added at this position
+		if(id < cur_id) {
+			// If last hasn't been set then the new data becomes the head of the list
+			if(last == NULL) {
+				// Update list
+				data_list = (list*) malloc(sizeof(list));
+				data_list->data = (void*) new_data;
+				data_list->next = tmp;
+
+				return;
+			}
+
+			// Else, we update the last node
+			new_node = (list*) malloc(sizeof(list));
+			new_node->data = (void*) new_data;
+			new_node->next = tmp; 
+			last->next = new_node;
+
+			return;
+		} else if(id == cur_id) {
+			// If data already exists for this id then we update it if it's seqno is greater than the one stored
+			pub_data *cur_data = (pub_data*) tmp->data;
+
+			if(seqno > cur_data->seqno) {
+				// Updata data
+				tmp->data = (void*) new_data;
+
+				// Free old data
+				free(cur_data);
+
+				return;
+			}
+
+			// seqno is smaller so the new data allocated is freed and nothing else is done
+			free(new_data);
+
+			return;
+		}
+
+		// Get next node in list
+		last = tmp;
+		tmp = tmp->next;
+	}
+
+	// If no correct position was found then the new data has to be added at the end of the list
+
+	// Update list
+	new_node = (list*) malloc(sizeof(list));
+	new_node->data = (void*) new_data;
+	new_node->next = NULL; 
+	last->next = new_node;
+}
+
 /* ---- Fin fonctions utilitaires ---- */
 
 // We need to make sure the TLV announces a length that will no go onto
@@ -61,7 +176,7 @@ int validate_tlv(char *data, int pos, short packet_len){
     unsigned char tlv_len = data[pos+1];
 
     // Check that the tlv does not exceed the packet length
-    if(pos + length >= packet_len)
+    if(pos + tlv_len >= packet_len)
         return -1;
 
     // Returns the type of the tlv or -1 if something went wrong
@@ -132,91 +247,172 @@ int update_neighbours(){
 };
 
 // We then look at the differents TLVs in the packet.
-void work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
+int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
     int pos = 0;
-    unsigned char tlv_len;
-    tlv tmp_tlv;
+    unsigned char tlv_len, hash[16], warn[32];
+    tlv new_tlv, cur_tlv;
+    list *tmp_list;
+    pub_data *pdata;
 
     while(pos < packet_len) {
         switch(validate_tlv(data, pos, packet_len)) {
             case 0:
                 // We received a padding tlv so it is ignored
                 pos += 1;
+
                 break;
             case 1:
                 // We received a padding tlv so it is ignored
                 tlv_len = data[pos+1];
                 pos += tlv_len + 2;
+
                 break;
             case 2:
                 // We received a neighbour request so a random neighbor tlv has to be sent
-                tlv_len = data[pos+1];
-                pos += tlv_len + 2;
 
                 // Send a neighbour tlv
                 neighbour_peer *random = get_random_neighbour();
-                build_neighbour(&tmp_tlv, random->ip, random->port);
+                build_neighbour(&new_tlv, random->ip, random->port);
 
                 // NOT FINISHED - What packet is it added to?
-                add_tlv(packet, &tmp_tlv, 3);
-                break;
-            case 3:
-                // We received a neighbour tlv so a tlv network hash is sent to that address
-            	neighbour* cur_tlv = ((neighbour*) data) + pos;
-            	struct in6_addr ip = cur_tlv->ip;
-				short port = cur_tlv->port;
+                add_tlv(packet, &new_tlv, 3);
 
+                // The position is updated
                 tlv_len = data[pos+1];
                 pos += tlv_len + 2;
 
+                break;
+            case 3:
+                // We received a neighbour tlv so a tlv network hash is sent to that address
+            	cur_tlv.neighbour = (neighbour*) (data + pos);
+
                 // Build network hash
-                unsigned char hash[16];
-                hash_network(neighbour_list, hash);
-                build_network_hash(&tmp_tlv, hash);
+                build_network_hash(&new_tlv, data_list);
 
                 // NOT FINISHED - What packet is it added to?
-                add_tlv(packet, &tmp_tlv, 4);
+                add_tlv(packet, &new_tlv, 4);
+
+                // The position is updated
+                tlv_len = data[pos+1];
+                pos += tlv_len + 2;
+
                 break;
             case 4:
-                // We reveived a network hash tlv so
-                tlv_len = data[pos+1];
-                pos += tlv_len +2;
+                // We reveived a network hash tlv so we compare the hash with our own, if they differ we send a network state request tlv
+            	cur_tlv.network_hash = (network_hash*) (data + pos);
+            	hash_network(data_list, hash);
+
+            	if(memcmp(hash, cur_tlv.network_hash->network_hash, 16) == 0) {
+                	build_network_state_req(&new_tlv);
+                	// NOT FINISHED - What packet is it added to?
+                	add_tlv(packet, &new_tlv, 5);
+            	}
+
+                // The position is updated
+                tlv_len = data[pos+1];
+                pos += tlv_len + 2;
 
-                // NOT FINISHED - Where is network_hash?
-                build_neighbour(&tmp_tlv, network_hash);
-                // NOT FINISHED - What packet is it added to?
-                add_tlv(packet, &tmp_tlv, 4);
                 break;
             case 5:
                 // We received a network state request tlv so a series of tlv node hash have to be sent for each data known
-                pos += 2;
 
-                // NOT FINISHED - for each known data
-                list *tmp_list = data_list;
-                pub_data *tmp_data;
+                // for each known data build a node hash and add to packet
+                tmp_list = data_list;
 
                 while(tmp_list != NULL) {
-                	tmp_data = (pub_data*) tmp_list->data;
-                	build_node_hash(&tmp_tlv, tmp_data->id, tmp_data->seqno);
+                	pdata = (pub_data*) tmp_list->data;
+                	build_node_hash(&new_tlv, pdata->id, pdata->seqno, pdata->data);
+                	// NOT FINISHED - What packet is it added to?
+                	add_tlv(packet, &new_tlv, 4);
                 }
 
+                // The position is updated
+                pos += 2;
+
                 break;
             case 6:
-                // We received a node hash tlv
+                // We received a node hash tlv so if there is no entry for node_id in the data list or the hashes differ we send a node state request, if the hashes are identical nothing has to be done
+            	cur_tlv.node_hash = (node_hash*) (data + pos);
+            	pdata = get_data(cur_tlv.node_hash->node_id);
+
+            	// If data is found for this id then we check that both hashes are the same
+            	if(pdata != NULL) {
+            		// We hash the data stored in the data list
+            		hash_data(pdata, hash);
+
+            		// If both hashes are the same then nothing has to be done
+            		if(memcmp(hash, cur_tlv.node_hash->node_hash, 16) != 0) {
+            			// The position is updated
+            			tlv_len = data[pos+1];
+               			pos += 2;
+
+               			break;
+            		}
+
+            	}
+
+            	// If no pub_data was found or the hashes differ then we send a node state request
+            	build_node_state_req(&new_tlv, cur_tlv.node_hash->node_id);
+            	// NOT FINISHED - What packet is it added to?
+            	add_tlv(packet, &new_tlv, 7);
+
+            	// The position is updated
+            	tlv_len = data[pos+1];
+                pos += tlv_len + 2;
+
                 break;
             case 7:
-                // We received a node state request tlv
+                // We received a node state request tlv so a node state tlv for this node id has to be sent, if no pub_data exists for this id nothing is sent
+            	cur_tlv.node_state_req = (node_state_req*) (data + pos);
+            	pdata = get_data(cur_tlv.node_state_req->node_id);
+
+            	if(pdata != NULL) {
+            		build_node_state(&new_tlv, pdata->id, pdata->seqno, pdata->data, pdata->length);
+            		// NOT FINISHED - What packet is it added to?
+            		add_tlv(packet, &new_tlv, 8);
+            	}
+
+            	// The position is updated
+            	tlv_len = data[pos+1];
+                pos += tlv_len + 2;
+
                 break;
             case 8:
-                // We received a node state tlv
+                // We received a node state tlv so we add it to the data list or update the data stored
+            	cur_tlv.node_state = (node_state*) (data + pos);
+
+            	add_data(cur_tlv.node_state->length - 26, cur_tlv.node_state->node_id, cur_tlv.node_state->seqno, cur_tlv.node_state->data);
+
+            	// The position is updated
+            	tlv_len = data[pos+1];
+                pos += tlv_len + 2;
+
                 break;
             case 9:
                 // We received a warning tlv so it's message is printed
+            	cur_tlv.warning = (warning*) (data + pos);
+            	
+            	// Print exactly new_tlv.length characters from new_tlv.message
+            	sprintf(warn, ">> WARNING:\n%%.%ds", cur_tlv.warning->length + 1);
+            	printf(warn, cur_tlv.warning->message);
+
+            	// The position is updated
+            	tlv_len = data[pos+1];
+                pos += tlv_len + 2;
+
                 break;
             default:
-                return ;
+            	// A malformed packet was found so we stop looking for more packets and send a warning tlv
+            	strcpy(warn, "Packet is malformed.");
+            	build_warning(&new_tlv, warn, strlen(warn));
+            	// NOT FINISHED - What packet is it added to?
+            	add_tlv(packet, &new_tlv, 9);
+
+                return -1;
         }
     }
+
+    return 0;
 }
 
 // We listen forever for new paquets;
diff --git a/src/node.h b/src/node.h
index d4ba94b..630a93e 100644
--- a/src/node.h
+++ b/src/node.h
@@ -90,4 +90,13 @@ int len_list(list *l);
 
 neighbour_peer *get_random_neighbour();
 
+// get data associated with id, if it doesn't exist return NULL
+pub_data *get_data(long id);
+
+// Take data as args and create a pub_data structure in the heap
+pub_data *copy_data(unsigned char len, long id, short seqno, char *data);
+
+// add new data to data list
+void add_data(unsigned char len, long id, short seqno, char *data);
+
 #endif
diff --git a/src/tlv.c b/src/tlv.c
index 2284815..c93436a 100644
--- a/src/tlv.c
+++ b/src/tlv.c
@@ -79,7 +79,7 @@ int build_neighbour(tlv *tlv, struct in6_addr ip, short port) {
 	return 0;
 }
 
-int build_network_hash(tlv *tlv, char *hash) {
+int build_network_hash(tlv *tlv, list *data_list) {
 	network_hash *new = (network_hash*) malloc(sizeof(network_hash));
 
 	if(new == NULL)
@@ -87,7 +87,7 @@ int build_network_hash(tlv *tlv, char *hash) {
 
 	new->type = 4;
 	new->length = 16;
-	memcpy(new->network_hash, hash, 16);
+	hash_network(data_list, new->network_hash);
 
 	tlv->network_hash = new;
 
@@ -108,7 +108,7 @@ int build_network_state_req(tlv *tlv) {
 	return 0;
 }
 
-int build_node_hash(tlv *tlv, long node_id, short seqno, char *hash) {
+int build_node_hash(tlv *tlv, long node_id, short seqno, char *data) {
 	node_hash *new = (node_hash*) malloc(sizeof(node_hash));
 
 	if(new == NULL)
@@ -118,7 +118,9 @@ int build_node_hash(tlv *tlv, long node_id, short seqno, char *hash) {
 	new->length = 26;
 	new->node_id = node_id;
 	new->seqno = seqno;
-	memcpy(new->node_hash, hash, 16);
+
+	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
+	hash_data(&pdata, new->node_hash);
 
 	tlv->node_hash = new;
 
@@ -140,9 +142,9 @@ int build_node_state_req(tlv *tlv, long node_id) {
 	return 0;
 }
 
-int build_node_state(tlv *tlv, long node_id, short seqno, char *node_hash, char *data) {
+int build_node_state(tlv *tlv, long node_id, short seqno, char *data, size_t data_len) {
 	node_state *new = (node_state*) malloc(sizeof(node_state));
-	int len = strlen(data);
+	int len = data_len + 26;
 
 	if(new == NULL)
 		return -1;
@@ -157,17 +159,19 @@ int build_node_state(tlv *tlv, long node_id, short seqno, char *node_hash, char
 	new->length = 26 + len;
 	new->node_id = node_id;
 	new->seqno = seqno;
-	memcpy(new->node_hash, node_hash, 16);
 	memcpy(new->data, data, len);
 
+	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
+	hash_data(&pdata, new->node_hash);
+
 	tlv->node_state = new;
 
 	return 0;
 }
 
-int build_warning(tlv *tlv, char *message) {
+int build_warning(tlv *tlv, char *message, size_t message_len) {
 	warning *new = (warning*) malloc(sizeof(warning));
-	int len = strlen(message);
+	int len = message_len;
 
 	if(new == NULL)
 		return -1;
diff --git a/src/tlv.h b/src/tlv.h
index c9a3d00..33bbaf5 100644
--- a/src/tlv.h
+++ b/src/tlv.h
@@ -6,6 +6,7 @@
 #include <stdlib.h>
 #include "parser.h"
 #include "hash.h"
+#include "node.h"
 
 #define LEN_NEIGHBOUR_REQ 0
 #define LEN_NEIGHBOUR 18
@@ -33,7 +34,7 @@ typedef struct pad1 {
 typedef struct padn {
 	unsigned char type;
 	unsigned char length;
-	char mbz[256];
+	char *mbz;
 } padn;
 
 // 2 octets
@@ -117,11 +118,11 @@ int build_pad1(tlv *tlv);
 int build_padn(tlv *tlv, size_t len);
 int build_neighbour_req(tlv *tlv);
 int build_neighbour(tlv *tlv, struct in6_addr ip, short port);
-int build_network_hash(tlv *tlv, char *network_hash);
+int build_network_hash(tlv *tlv, list *data_list);
 int build_network_state_req(tlv *tlv);
-int build_node_hash(tlv *tlv, long node_id, short seqno, char *node_hash);
+int build_node_hash(tlv *tlv, long node_id, short seqno, char *data);
 int build_node_state_req(tlv *tlv, long node_id);
-int build_node_state(tlv *tlv, long node_id, short seqno, char *node_hash, char *data);
-int build_warning(tlv *tlv, char *message);
+int build_node_state(tlv *tlv, long node_id, short seqno, char *data, size_t data_len);
+int build_warning(tlv *tlv, char *message, size_t message_len);
 
 #endif

From 53528ff666c9c5b299b92626106c36725f819c3e Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Tue, 14 Apr 2020 16:59:49 +0200
Subject: [PATCH 10/18] Removed useless lines, added flags in seperate part

---
 Makefile | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/Makefile b/Makefile
index b8b2f19..a365c52 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,8 @@
 TARGET ?= dazibao
 SRC_DIRS ?= ./src/*
-CC := gcc -Wall -lssl -lcrypto
-SRCS := $(shell find $(SRC_DIRS) -name *.cpp -or -name *.c -or -name *.s)
+CC := gcc
+CFLAGS= -O2 -Wall -lssl -lcrypto
+SRCS := $(shell find $(SRC_DIRS) -name *.c -or -name *.s)
 OBJS := $(addsuffix .o,$(basename $(SRCS)))
 DEPS := $(OBJS:.o=.d)
 
@@ -9,7 +10,7 @@ INC_DIRS := $(shell find $(SRC_DIRS) -type d)
 INC_FLAGS := $(addprefix -I,$(INC_DIRS))
 
 $(TARGET): $(OBJS)
-	$(CC) $(LDFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS)
+	$(CC) $(CFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS)
 
 .PHONY: clean
 clean:

From 9f6e8875fda676b76e0f644375f31c54c5aae992 Mon Sep 17 00:00:00 2001
From: PERDRIAU nelson <administratif@n07070.xyz>
Date: Tue, 14 Apr 2020 17:55:55 +0200
Subject: [PATCH 11/18] =?UTF-8?q?:=20Ajout=20d'une=20premi=C3=A8re=20makef?=
 =?UTF-8?q?ile?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Makefile | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/Makefile b/Makefile
index e69de29..a365c52 100644
--- a/Makefile
+++ b/Makefile
@@ -0,0 +1,19 @@
+TARGET ?= dazibao
+SRC_DIRS ?= ./src/*
+CC := gcc
+CFLAGS= -O2 -Wall -lssl -lcrypto
+SRCS := $(shell find $(SRC_DIRS) -name *.c -or -name *.s)
+OBJS := $(addsuffix .o,$(basename $(SRCS)))
+DEPS := $(OBJS:.o=.d)
+
+INC_DIRS := $(shell find $(SRC_DIRS) -type d)
+INC_FLAGS := $(addprefix -I,$(INC_DIRS))
+
+$(TARGET): $(OBJS)
+	$(CC) $(CFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS)
+
+.PHONY: clean
+clean:
+	$(RM) $(TARGET) $(OBJS) $(DEPS)
+
+-include $(DEPS)

From f294be3ba2e9bbeb6c672d86221a82711e91db25 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Tue, 14 Apr 2020 19:32:15 +0200
Subject: [PATCH 12/18] Fixed sending messages Fixed return types Fixed
 signatures Fixed *some* warnings

---
 src/hash.c   |  6 ++---
 src/hash.h   | 12 +++++----
 src/node.c   | 76 ++++++++++++++++++++++++++++------------------------
 src/node.h   | 13 ++++-----
 src/parser.h |  2 +-
 src/tlv.c    |  5 ++++
 src/tlv.h    | 11 ++++----
 7 files changed, 70 insertions(+), 55 deletions(-)

diff --git a/src/hash.c b/src/hash.c
index 287e2c4..44e3827 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -11,7 +11,7 @@ void hash_data(pub_data *data, unsigned char *buf) {
 	unsigned char hash[SHA256_DIGEST_LENGTH];
 	SHA256(concat, totlen, hash);
 
-	// Put truncated hash into buf 
+	// Put truncated hash into buf
 	hash_trunc(hash, buf);
 }
 
@@ -33,7 +33,7 @@ void hash_network(list *data_list, unsigned char *buf) {
 	// Hash all of concat to obtain the network hash
 	SHA256(concat, totlen, hash);
 
-	// Put truncated hash into buf 
+	// Put truncated hash into buf
 	hash_trunc(hash, buf);
 
 	// Get rid of concat
@@ -57,4 +57,4 @@ void concat_data(pub_data *data, unsigned char *buf) {
 void concat_hash(unsigned char *hash1, unsigned char *hash2, size_t size) {
 	hash1 = (unsigned char*) realloc(hash1, size + 16);
 	memcpy(hash1+size, hash2, 16);
-}
\ No newline at end of file
+}
diff --git a/src/hash.h b/src/hash.h
index 358c7b5..4f16809 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -2,22 +2,24 @@
 #define HASH_H
 
 #include <openssl/sha.h>
-#include "node.h"
+
 #include "tlv.h"
+#include "parser.h"
+#include "node.h"
 
 // Hash a single data
-void hash_data(pub_data *data, unsigned char *buf);
+void hash_data(struct pub_data *data, unsigned char *buf);
 
 // Hash every data contained in data_list then return a network hash
-void hash_network(list *data_list, unsigned char *buf);
+void hash_network(struct list *data_list, unsigned char *buf);
 
 // Truncate 32 octet hash to 16 octets
 void hash_trunc(unsigned char *hash256bit, unsigned char *buf);
 
 // Concat all fields of data and put them in buf
-void concat_data(pub_data *data, unsigned char *buf);
+void concat_data(struct pub_data *data, unsigned char *buf);
 
 // Concat hash2 to hash1 (hash1 is modified)
 void concat_hash(unsigned char *hash1, unsigned char *hash2, size_t size);
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/node.c b/src/node.c
index fbf462d..4b5d8f3 100644
--- a/src/node.c
+++ b/src/node.c
@@ -8,8 +8,11 @@
 #include <string.h>
 #include <time.h>
 
-#include "tlv.h"
 #include "node.h"
+#include "tlv.h"
+#include "hash.h"
+#include "parser.h"
+
 
 /* ----  Fonctions utilitaires  ---- */
 
@@ -61,7 +64,7 @@ pub_data *get_data(long id) {
 // Take data as args and create a pub_data structure in the heap
 pub_data *copy_data(unsigned char len, long id, short seqno, char *data) {
 	pub_data *new_data = (pub_data*) malloc(sizeof(pub_data));
-	char *_data = (char*) malloc(len); 
+	char *_data = (char*) malloc(len);
 	new_data->length = len;
 	new_data->id = id;
 	new_data->seqno = seqno;
@@ -120,7 +123,7 @@ void add_data(unsigned char len, long id, short seqno, char *data) {
 			// Else, we update the last node
 			new_node = (list*) malloc(sizeof(list));
 			new_node->data = (void*) new_data;
-			new_node->next = tmp; 
+			new_node->next = tmp;
 			last->next = new_node;
 
 			return;
@@ -154,33 +157,33 @@ void add_data(unsigned char len, long id, short seqno, char *data) {
 	// Update list
 	new_node = (list*) malloc(sizeof(list));
 	new_node->data = (void*) new_data;
-	new_node->next = NULL; 
+	new_node->next = NULL;
 	last->next = new_node;
 }
 
 /* ---- Fin fonctions utilitaires ---- */
 
-int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int sock_num){
-	debug_print("Building packet to send a TLV.");
+int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num){
+	// debug_print("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(sizeof(tlv_to_send) > 1020){
-		debug_print("Unable to send TLV, the size is bigger than 1020 bits.");
+	if (tlv_size > 1020) {
+		perror(">> Unable to send the tlv, it's size if above 1020 bytes.");
 		return -1;
 	} else {
-		pack.length = sizeof(tlv_to_send);
-		strcpy(pack.body, (char) tlv_to_send);
+		memcpy((void *) pack.body, tlv_to_send, tlv_size);
 	}
 
-	// Casting the struct to a buffer.
-	packet_buff = (char *) pack;
+	// 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);
 
-	debug_print("Packet has been built.");
+	// debug_print("Packet has been built.");
 
     // Vectorized buffer
     struct iovec vec_buff = { .iov_len = sizeof(packet_buff), .iov_base = packet_buff };
@@ -197,22 +200,22 @@ int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_li
 			.msg_iovlen = 1 // We have only one iovec buffer. But if we had 2, we would write 2.
 		};
 
-		response_code = sendmsg((int) sock_num, &packet_tlv_send_out, 0);
+		int response_code = sendmsg((int) socket_num, &packet_tlv_send_out, 0);
 		if (response_code < 0) {
-			debug_print("Unable to send out the packet to peer %i", i);
+			// debug_print("Unable to send out the packet to peer %i", i);
 			error_while_sending = 1;
 			continue;
 		} else if (response_code < sizeof(packet_tlv_send_out)) {
-			debug_print("Sent out only part of the packet.");
+			// debug_print("Sent out only part of the packet.");
 			error_while_sending = 1;
 			continue;
 		} else {
-			debug_print("Send out packet to peer %i", i);
+			// debug_print("Send out packet to peer %i", i);
 		}
 	}
 
 	if (error_while_sending == 1) {
-		debug_print("Error occured while sending out a packet.");
+		// debug_print("Error occured while sending out a packet.");
 		return -1;
 	} else {
 		return 0;
@@ -273,9 +276,9 @@ int validate_tlv(char *data, int pos, short packet_len){
 // 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, struct packet * packet_to_return){
+int check_header(char * received_datagram[], int buffer_len, struct packet * packet_to_return){
 
-    packet * packet_to_return = (packet*) req;
+    packet_to_return = (packet*) received_datagram;
 
     // We need to check a few things ;
     // The first byte must be worth 95,
@@ -290,7 +293,7 @@ int check_header(char * req[], int buffer_size, struct packet * packet_to_return
         return -1;
     }
 
-    if (packet_to_return.length + 4 > buffer_size  ) {
+    if (packet_to_return->length + 4 > buffer_len  ) {
         perror(">> The packet length is bigger than the UDP datagram, which is not possible with the current laws of physics.");
         return -1;
     }
@@ -306,13 +309,16 @@ int update_neighbours(){
 };
 
 // We then look at the differents TLVs in the packet.
-int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
+int work_with_tlvs(char * data[], short packet_len, struct sockaddr_in6 sender){
     int pos = 0;
     unsigned char tlv_len, hash[16], warn[32];
     tlv new_tlv, cur_tlv;
     list *tmp_list;
     pub_data *pdata;
 
+	struct neighbour_peer * random_neighbour;
+
+
     while(pos < packet_len) {
         switch(validate_tlv(data, pos, packet_len)) {
             case 0:
@@ -330,11 +336,11 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
                 // We received a neighbour request so a random neighbor tlv has to be sent
 
                 // Send a neighbour tlv
-                neighbour_peer *random = get_random_neighbour();
-                build_neighbour(&new_tlv, random->ip, random->port);
+				random_neighbour = get_random_neighbour();
+                build_neighbour(&new_tlv, random_neighbour->ip, random_neighbour->port);
 
                 // NOT FINISHED - What packet is it added to?
-                add_tlv(packet, &new_tlv, 3);
+                // add_tlv(packet, &new_tlv, 3);
 
                 // The position is updated
                 tlv_len = data[pos+1];
@@ -349,7 +355,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
                 build_network_hash(&new_tlv, data_list);
 
                 // NOT FINISHED - What packet is it added to?
-                add_tlv(packet, &new_tlv, 4);
+                // add_tlv(packet, &new_tlv, 4);
 
                 // The position is updated
                 tlv_len = data[pos+1];
@@ -364,7 +370,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
             	if(memcmp(hash, cur_tlv.network_hash->network_hash, 16) == 0) {
                 	build_network_state_req(&new_tlv);
                 	// NOT FINISHED - What packet is it added to?
-                	add_tlv(packet, &new_tlv, 5);
+                	// add_tlv(packet, &new_tlv, 5);
             	}
 
                 // The position is updated
@@ -382,7 +388,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
                 	pdata = (pub_data*) tmp_list->data;
                 	build_node_hash(&new_tlv, pdata->id, pdata->seqno, pdata->data);
                 	// NOT FINISHED - What packet is it added to?
-                	add_tlv(packet, &new_tlv, 4);
+                	// add_tlv(packet, &new_tlv, 4);
                 }
 
                 // The position is updated
@@ -413,7 +419,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
             	// If no pub_data was found or the hashes differ then we send a node state request
             	build_node_state_req(&new_tlv, cur_tlv.node_hash->node_id);
             	// NOT FINISHED - What packet is it added to?
-            	add_tlv(packet, &new_tlv, 7);
+            	// add_tlv(packet, &new_tlv, 7);
 
             	// The position is updated
             	tlv_len = data[pos+1];
@@ -428,7 +434,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
             	if(pdata != NULL) {
             		build_node_state(&new_tlv, pdata->id, pdata->seqno, pdata->data, pdata->length);
             		// NOT FINISHED - What packet is it added to?
-            		add_tlv(packet, &new_tlv, 8);
+            		// add_tlv(packet, &new_tlv, 8);
             	}
 
             	// The position is updated
@@ -450,7 +456,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
             case 9:
                 // We received a warning tlv so it's message is printed
             	cur_tlv.warning = (warning*) (data + pos);
-            	
+
             	// Print exactly new_tlv.length characters from new_tlv.message
             	sprintf(warn, ">> WARNING:\n%%.%ds", cur_tlv.warning->length + 1);
             	printf(warn, cur_tlv.warning->message);
@@ -465,7 +471,7 @@ int work_with_tlvs(char *data, short packet_len, struct sockaddr_in6 sender){
             	strcpy(warn, "Packet is malformed.");
             	build_warning(&new_tlv, warn, strlen(warn));
             	// NOT FINISHED - What packet is it added to?
-            	add_tlv(packet, &new_tlv, 9);
+            	// add_tlv(packet, &new_tlv, 9);
 
                 return -1;
         }
@@ -535,7 +541,7 @@ void listen_for_packets(){
 
         // struct tlv_list received_tlvs;
         // if (validate_tlvs(formated_rec_datagram) < 0)
-        int nbr_success_tlv = work_with_tlvs(formated_rec_datagram, &req, sender);
+        int nbr_success_tlv = work_with_tlvs(&req, 1024, 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 );
@@ -551,7 +557,7 @@ int main(int argc, const char *argv[]) {
     while(cont){
 
         // We create the neighbourhood table
-        neighbour_peer neighbour_list[NEIGHBOUR_MAX];
+        // neighbour_peer neighbour_list[NEIGHBOUR_MAX];
         // We create the message table
 
         // We create our own message.
diff --git a/src/node.h b/src/node.h
index 54141df..7daef54 100644
--- a/src/node.h
+++ b/src/node.h
@@ -13,6 +13,7 @@
 
 #include "tlv.h"
 #include "hash.h"
+#include "parser.h"
 
 // On which port do we listen to
 #define LISTEN_PORT 1212
@@ -65,27 +66,27 @@ static list *neighbour_list;
 // fonctions signatures
 void listen_for_packets();
 
-int check_header(char * received_datagram[], int len, struct packet pack);
+int check_header(char * received_datagram[], int buffer_len, struct packet * packet_to_return);
 
 int validate_tlvs(struct packet * pack, struct tlv_list * tlv_l);
 
 int update_neighbours();
 
-int work_with_tlvs(struct packet received_packet, char * data_from_packet[], struct sockaddr_in6 sender);
+int work_with_tlvs(char * data[], short packet_len, struct sockaddr_in6 sender);
 
-void add_tlv(packet *packet, tlv *tlv, char type);
+void add_tlv(struct packet *packet, union tlv *tlv, char type);
 
-int send_packet();
+// int send_packet();
 
 /* Takes a TLV and sends it over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlv(struct tlv tlv_to_send, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
+int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 
 /* Takes a list of TLV and sends them over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlvs(struct list * tlv_list, int tlv_type, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
+int send_tlvs(struct list * tlv_list, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
 
 // threaded functions
 void t_ask_for_more_peers();
diff --git a/src/parser.h b/src/parser.h
index b373a0d..15b5fcb 100644
--- a/src/parser.h
+++ b/src/parser.h
@@ -16,4 +16,4 @@ typedef struct cmd_token {
 // retourne le type de commande à exécuter
 cmd_token parse_cmd();
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/tlv.c b/src/tlv.c
index 390352a..5fe7dbf 100644
--- a/src/tlv.c
+++ b/src/tlv.c
@@ -18,7 +18,12 @@ int build_tlv(tlv *tlv, cmd_token token) {
 		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) {
diff --git a/src/tlv.h b/src/tlv.h
index 33bbaf5..b548ca0 100644
--- a/src/tlv.h
+++ b/src/tlv.h
@@ -4,9 +4,10 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <stdlib.h>
-#include "parser.h"
-#include "hash.h"
+
 #include "node.h"
+#include "hash.h"
+#include "parser.h"
 
 #define LEN_NEIGHBOUR_REQ 0
 #define LEN_NEIGHBOUR 18
@@ -111,14 +112,14 @@ typedef union tlv {
 } tlv;
 
 // build tlv from token
-int build_tlv(tlv *tlv, cmd_token token);
+int build_tlv(tlv *tlv, struct cmd_token token);
 
 // build specific tlv
 int build_pad1(tlv *tlv);
 int build_padn(tlv *tlv, size_t len);
-int build_neighbour_req(tlv *tlv);
+int build_neighbour_req(union tlv *tlv);
 int build_neighbour(tlv *tlv, struct in6_addr ip, short port);
-int build_network_hash(tlv *tlv, list *data_list);
+int build_network_hash(tlv *tlv, struct list *data_list);
 int build_network_state_req(tlv *tlv);
 int build_node_hash(tlv *tlv, long node_id, short seqno, char *data);
 int build_node_state_req(tlv *tlv, long node_id);

From 45cdc1409c23ff62afa26d79b858d5a1c976415a Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 15 Apr 2020 12:46:34 +0200
Subject: [PATCH 13/18] Ajout d'un log

---
 src/node.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/node.c b/src/node.c
index 4b5d8f3..0c33abb 100644
--- a/src/node.c
+++ b/src/node.c
@@ -552,6 +552,7 @@ void listen_for_packets(){
 }
 
 int main(int argc, const char *argv[]) {
+	printf(">> Starting node\n");
     int cont = 1;
 
     while(cont){

From db3875205e313fbee4b9e698ffde260d81ddfa51 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Wed, 15 Apr 2020 19:28:28 +0200
Subject: [PATCH 14/18] =?UTF-8?q?Impl=C3=A9mentation=20de=20poll()=20termi?=
 =?UTF-8?q?n=C3=A9,=20ajouter=20les=20nouvelles=20fonctions=20et=20leurs?=
 =?UTF-8?q?=20signtaure=20=C3=A0=20faire?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/node.c | 203 +++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 182 insertions(+), 21 deletions(-)

diff --git a/src/node.c b/src/node.c
index 0c33abb..6cfb721 100644
--- a/src/node.c
+++ b/src/node.c
@@ -7,6 +7,11 @@
 #include <netinet/in.h>
 #include <string.h>
 #include <time.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <unistd.h>
 
 #include "node.h"
 #include "tlv.h"
@@ -551,35 +556,191 @@ void listen_for_packets(){
     }
 }
 
+int run_node(int sock_fd, struct sockaddr_in6 * peer){
+	printf(">> Boostrapping node...\n");
+
+	int ret;
+	ssize_t bytes;
+	char input_buffer[1024];
+	char output_buffer[1024];
+	struct pollfd fds[2];
+
+	/* Descriptor zero is stdin */
+	fds[0].fd = 0;
+	fds[1].fd = sock_fd;
+	fds[0].events = POLLIN | POLLPRI;
+	fds[1].events = POLLIN | POLLPRI;
+
+	/* Normally we'd check an exit condition, but for this example
+	 * we loop endlessly.
+	 */
+	while (1) {
+	  /* Call poll() */
+	  ret = poll(fds, 2, -1);
+
+	  if (ret < 0) {
+		printf("Error - poll returned error: %s\n", strerror(errno));
+		break;
+	  }
+	  if (ret > 0) {
+
+		/* Regardless of requested events, poll() can always return these */
+		if (fds[0].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+		  printf("Error - poll indicated stdin error\n");
+		  break;
+		}
+		if (fds[1].revents & (POLLERR | POLLHUP | POLLNVAL)) {
+		  printf("Error - poll indicated socket error\n");
+		  break;
+		}
+
+		/* Check if data to read from stdin */
+		printf(">> ");
+		if (fds[0].revents & (POLLIN | POLLPRI)) {
+		  bytes = read(0, output_buffer, sizeof(output_buffer));
+		  if (bytes < 0) {
+			printf("Error - stdin error: %s\n", strerror(errno));
+			break;
+		  }
+
+		  // // Reset buffer
+		  // // memset(&output_buffer, '\0', 1024);
+		  //
+		  // // Build packet
+		  // struct packet message;
+		  // message.magic = 95;
+		  // message.version = 1;
+		  // message.body = malloc(20);
+		  //
+		  // // Build TLV
+		  // struct neighbour_req *neigh_req = (neighbour_req*) malloc(sizeof(neighbour_req));
+		  //
+		  // neigh_req->type = 2;
+		  // neigh_req->length = 0;
+		  //
+		  // message.length = 2 * sizeof(unsigned char);
+		  // printf("(%i)\n", message.length );
+		  // // message.body = (char *) neigh_req;
+		  //
+		  // memcpy(message.body, &neigh_req, sizeof(struct neighbour_req));
+		  // memcpy(&output_buffer, &message, sizeof(struct packet));
+
+		  struct iovec vec_buff_reply = {.iov_len = sizeof(output_buffer), .iov_base = output_buffer};
+
+		  struct sockaddr_in6 ntp_server_adress;
+		  memset(&ntp_server_adress, 0, sizeof(ntp_server_adress));
+
+          int inet_p = inet_pton(AF_INET6, "2a00:1080:800::6:1", &ntp_server_adress.sin6_addr);
+          if(inet_p < 1){
+              perror(">> Failed inet_pton.");
+              exit(1);
+          }
+          ntp_server_adress.sin6_family = AF_INET6;
+          ntp_server_adress.sin6_port = htons(1212); // NTP port number.
+
+		  const struct msghdr reply = {
+			  .msg_name = &ntp_server_adress,
+			  .msg_namelen = sizeof(ntp_server_adress),
+			  .msg_iov = &vec_buff_reply,
+			  .msg_iovlen = 1
+		  };
+
+		  printf("Sending: %li bytes as : %s\n", sizeof(output_buffer), output_buffer);
+		  // bytes = sendto(sock_fd, output_buffer, sizeof(output_buffer), 0, (struct sockaddr *)peer, sizeof(struct sockaddr_in));
+		  bytes = sendmsg((int) sock_fd, &reply, 0);
+		  if (bytes < 0) {
+			  perror("deded");
+			printf("Error - sendto error: %s\n", strerror(errno));
+			break;
+		  }
+		}
+
+		/* Check if data to read from socket */
+		if (fds[1].revents & (POLLIN | POLLPRI)) {
+		  bytes = recvfrom(sock_fd, input_buffer, sizeof(input_buffer),
+						   0, NULL, NULL);
+		  if (bytes < 0) {
+			printf("Error - recvfrom error: %s\n", strerror(errno));
+			break;
+		  }
+		  if (bytes > 0) {
+			printf("Received: %.*s\r", (int)bytes, input_buffer);
+		  }
+		}
+	  }
+	}
+	return 0;
+}
+
 int main(int argc, const char *argv[]) {
 	printf(">> Starting node\n");
     int cont = 1;
 
-    while(cont){
+	unsigned long local_port = 1212;
+	unsigned long remote_port = 1212;
 
-        // We create the neighbourhood table
-        // neighbour_peer neighbour_list[NEIGHBOUR_MAX];
-        // We create the message table
+	int sock_fd;
 
-        // We create our own message.
+	struct sockaddr_in6 server_addr;
+	struct sockaddr_in6 peer_addr;
 
-        // Listen for incoming packets
-        listen_for_packets();
+	memset(&peer_addr, 0, sizeof(peer_addr));
 
-        // This is in it's own fork.
-        time_t delay = time(NULL) + 20;
-        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
-            // by sending out a TLV neighbour Request at a random peer.
-            t_ask_for_more_peers();
-            // Every 20 sec, we also check for a peer that didn't emit a new message for
-            // the past 70 sec, if he's temporary, we delete him from the neighbourhood.
-            t_update_neighbours();
-            // We send out a TLV Network hash to get an ideal of the network state.
-            t_get_network_state();
-        }
+	peer_addr.sin6_family = AF_INET6;
+    peer_addr.sin6_port = htons(remote_port);
+    if (inet_pton(AF_INET6, "2001:660:3301:9200::51c2:1b9b", &peer_addr.sin6_addr) < 0) {
+      printf("Error - invalid remote address '%s'\n", "2001:660:3301:9200::51c2:1b9b");
+      return 1;
     }
+
+    /* Create UDP socket */
+    sock_fd = socket(AF_INET6, SOCK_DGRAM, 0);
+    if (sock_fd < 0) {
+      printf("Error - failed to open socket: %s\n", strerror(errno));
+      return 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 = htons(local_port);
+    if (bind(sock_fd, (struct sockaddr *)(&server_addr), sizeof(server_addr)) < 0) {
+      printf("Error - failed to bind socket: %s\n", strerror(errno));
+      return 1;
+    }
+
+	run_node(sock_fd, &peer_addr);
+
+
+	close(sock_fd);
+	//
+    // while(cont){
+	//
+    //     // We create the neighbourhood table
+    //     // neighbour_peer neighbour_list[NEIGHBOUR_MAX];
+    //     // We create the message table
+	//
+    //     // We create our own message.
+	//
+    //     // Listen for incoming packets
+    //     // listen_for_packets();
+	// 	//
+    //     // // This is in it's own fork.
+    //     // time_t delay = time(NULL) + 20;
+    //     // 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
+    //     //     // by sending out a TLV neighbour Request at a random peer.
+    //     //     t_ask_for_more_peers();
+    //     //     // Every 20 sec, we also check for a peer that didn't emit a new message for
+    //     //     // the past 70 sec, if he's temporary, we delete him from the neighbourhood.
+    //     //     t_update_neighbours();
+    //     //     // We send out a TLV Network hash to get an ideal of the network state.
+    //     //     t_get_network_state();
+    //     }
+    // }
+
     return 0;
 }

From cdef7ee0ac0488798adaa0635f4bed2333a4f12d Mon Sep 17 00:00:00 2001
From: gonzalef <kneesbrah@gmail.com>
Date: Thu, 16 Apr 2020 15:08:22 +0200
Subject: [PATCH 15/18] solved compilation errors | changed header includes,
 makefile flags, pointers to arrays

---
 Makefile     |   5 +++--
 src/hash.h   |   6 +++---
 src/hash.o   | Bin 0 -> 2648 bytes
 src/node.c   |  15 ++++++++-------
 src/node.h   |  44 ++++++++++++++++++++++----------------------
 src/node.o   | Bin 0 -> 10576 bytes
 src/parser.o | Bin 0 -> 2752 bytes
 src/tlv.h    |  10 +++++-----
 src/tlv.o    | Bin 0 -> 4744 bytes
 9 files changed, 41 insertions(+), 39 deletions(-)
 create mode 100644 src/hash.o
 create mode 100644 src/node.o
 create mode 100644 src/parser.o
 create mode 100644 src/tlv.o

diff --git a/Makefile b/Makefile
index a365c52..3d676e4 100644
--- a/Makefile
+++ b/Makefile
@@ -1,16 +1,17 @@
 TARGET ?= dazibao
 SRC_DIRS ?= ./src/*
 CC := gcc
-CFLAGS= -O2 -Wall -lssl -lcrypto
+CFLAGS= -O2 -Wall 
 SRCS := $(shell find $(SRC_DIRS) -name *.c -or -name *.s)
 OBJS := $(addsuffix .o,$(basename $(SRCS)))
 DEPS := $(OBJS:.o=.d)
+SSLFLAGS = -lssl -lcrypto
 
 INC_DIRS := $(shell find $(SRC_DIRS) -type d)
 INC_FLAGS := $(addprefix -I,$(INC_DIRS))
 
 $(TARGET): $(OBJS)
-	$(CC) $(CFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS)
+	$(CC) $(CFLAGS) $(OBJS) -o $@ $(LOADLIBES) $(LDLIBS) $(SSLFLAGS)
 
 .PHONY: clean
 clean:
diff --git a/src/hash.h b/src/hash.h
index 4f16809..748b6b1 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -8,16 +8,16 @@
 #include "node.h"
 
 // Hash a single data
-void hash_data(struct pub_data *data, unsigned char *buf);
+void hash_data(pub_data *data, unsigned char *buf);
 
 // Hash every data contained in data_list then return a network hash
-void hash_network(struct list *data_list, unsigned char *buf);
+void hash_network(list *data_list, unsigned char *buf);
 
 // Truncate 32 octet hash to 16 octets
 void hash_trunc(unsigned char *hash256bit, unsigned char *buf);
 
 // Concat all fields of data and put them in buf
-void concat_data(struct pub_data *data, unsigned char *buf);
+void concat_data(pub_data *data, unsigned char *buf);
 
 // Concat hash2 to hash1 (hash1 is modified)
 void concat_hash(unsigned char *hash1, unsigned char *hash2, size_t size);
diff --git a/src/hash.o b/src/hash.o
new file mode 100644
index 0000000000000000000000000000000000000000..920c6ac2f74eb242bea0fe66f497943b0cf91af1
GIT binary patch
literal 2648
zcmbtU&2Jk;6d$i$XK~V9C*|O(Nbw;-4x%fYwonxbyh-eg(W*g>O+jf`9LL5eiH+=C
zHK3}E<fdY^80CQAFX){EN>4}$X{GdnkdWZeTLm=bL!^p`jEEZEjAxS3){ziAY4*MO
z&F_8en~!TLBQ5!Sh>H)sf(~XJMd;1013O90B<exkXj`pzslCB<wf{Oru{$Ok&2$Jm
zLG{*Hxa6c|bw$PQ#Yp2Xxqf_SEnpi<cdc%9McP@DK1zq|+%`BP>`K^4hnx-UUXfZE
z=L%}!=G8vjc+koWwTz*!M}2G9`F`!8e;eOiFKIlVD^V{uEA8q|7VSc;MN){fq29_$
zk4pr6Ebw#K`Dp?>+qm)D*%|Bx24g_RPHHo;s;+byO&r3F)#HO(en5wAW9R2h5)C(V
ztA_Ipb{^1aNv)<<v76eQ!Kd00)Ly?G#O_q<?mA<ze&it8pSW2IW9K`_DbrPGS_-MX
zfe3EgmM5pymk<6&e?!k@oE<$&9RE)2flpkhb95k<SZ$ZIbT8xFu`VZm&p1CG_+$5F
zgBR`m0;b{o(dN68a?=ju#+@);x@Z4@3p<8$pRd9n1qQGS;rD+@hi$d{p~5(jCa3gE
z`jr0mL(&bkKZz1MkoMQFXlOJxGIA~&%T3!A%Z|RJozdbaPuX;qxSBYt#ZM2lQSg15
z1OV}Ucmeqq!oCwdUGg#<xG-SP&=rJarU@2j_Ge5-L60)~U7~d*d_x*J8q^zp=~4)y
z>D>bWml<bppQ9_0hX1@0y`V(EM^|K&gtcYH`;zEkCH#prtVEjrloI_opewN(M|36L
z2xgRbq{WaDA5~(y5(Ne@hZQ-~&Agvf<PHVUqrE3r5b}4tVFZU$*FpRcsgw9ouoDbX
zgv%;0{OE`<Yn!CkeL_9F_s1Ac_J9cQe?QoS{{=-6qI&@L5Dd;`OH{pj2%bI!zX&*q
zA7zga-9Nwzhwx_^|8>Tv`v};=A^dBH;HaFhm$d>_rd6{m1yrb33VF+%$y@n0Of7TF
z7$4RRb3C1%NM+5eK5V2+G=cRO&b)|Bvu@=Jvu2?@YnJlw&G8r{II0!%b8}UeqEfUj
zS8KCqzKxY?#UfOO(0%$vNCN#7jNQGqJYqOG2|WUSjQuykj|zA~z*Paa1-w_lKW8|}
z8xruF0<H-7x)4XKhZYVzZ#`QAzfXu01)B)TO9q$I%-}dbTiAp1b2#V0`T6<OgY$EO
zwE740R(=|^Rcq@qw`#??yk->_ETqvb*QV=rq!p_3^Ti5am8w<L#?I$X(!E9+r5DR)
zsg|E_Zz9Y2e^eBlNz1%9JP8<)fY>aU^Zw99_?#dd7)cnSEVCzIi-F{fkv#m~M;QJr
z!@V!ks3$L@(-_<)`gs^6=7051fG?>l4nq{4|2Yu^n;oxxeNMncYUN+nKhFHU^!FL?
ztr!$+-aih%21cj;FR~3K?-LQyfAU&$f8KxcKi=E`p(JbQ2K!-hSBbCJpTza{9v~#M
a{l88og7E%vh`bG*{9CO4w>Xh$um3+O42qfn

literal 0
HcmV?d00001

diff --git a/src/node.c b/src/node.c
index 0c33abb..b4dd698 100644
--- a/src/node.c
+++ b/src/node.c
@@ -163,7 +163,7 @@ void add_data(unsigned char len, long id, short seqno, char *data) {
 
 /* ---- Fin fonctions utilitaires ---- */
 
-int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num){
+int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num){
 	// debug_print("Building packet to send a TLV.");
 
 	// We first need to build the packet,
@@ -276,7 +276,7 @@ int validate_tlv(char *data, int pos, short packet_len){
 // 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 * received_datagram[], int buffer_len, struct packet * packet_to_return){
+int check_header(char * received_datagram, int buffer_len, struct packet * packet_to_return){
 
     packet_to_return = (packet*) received_datagram;
 
@@ -309,9 +309,10 @@ int update_neighbours(){
 };
 
 // We then look at the differents TLVs in the packet.
-int work_with_tlvs(char * data[], short packet_len, struct sockaddr_in6 sender){
+int work_with_tlvs(char * data, short packet_len, struct sockaddr_in6 sender){
     int pos = 0;
-    unsigned char tlv_len, hash[16], warn[32];
+    unsigned char tlv_len, hash[16];
+    char warn[32];
     tlv new_tlv, cur_tlv;
     list *tmp_list;
     pub_data *pdata;
@@ -531,8 +532,8 @@ void listen_for_packets(){
 
         // 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;
-        if(check_header(&req, 1024, formated_rec_datagram) < 0){
+        struct packet formated_rec_datagram;
+        if(check_header(req, 1024, &formated_rec_datagram) < 0){
             perror(">> Error while checking the header, aborting this packet, by choice, and conviction.");
             continue;
         }
@@ -541,7 +542,7 @@ void listen_for_packets(){
 
         // struct tlv_list received_tlvs;
         // if (validate_tlvs(formated_rec_datagram) < 0)
-        int nbr_success_tlv = work_with_tlvs(&req, 1024, sender);
+        int nbr_success_tlv = work_with_tlvs(req, 1024, 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 );
diff --git a/src/node.h b/src/node.h
index 7daef54..d84971b 100644
--- a/src/node.h
+++ b/src/node.h
@@ -11,20 +11,6 @@
 #include <netinet/in.h>
 #include <string.h>
 
-#include "tlv.h"
-#include "hash.h"
-#include "parser.h"
-
-// On which port do we listen to
-#define LISTEN_PORT 1212
-
-// The node ID
-#define NODE_ID 42675882021843277
-
-// The number of neighbours
-// The neighbour table has 15 entries
-#define NEIGHBOUR_MAX 15
-
 /* la table de voisins, qui est indexée par adresses de socket (des paires (IP, Port)),
  * et dont chaque entrée contient un booléen indiquant si le pair est permanent
  * (configuré au lancement) ou transitoire, et la date de dernière réception d’un
@@ -45,7 +31,7 @@ typedef struct neighbour_peer {
 */
 
 typedef struct pub_data {
-	unsigned char length;
+    unsigned char length;
     long id;
     short seqno;
     char *data;
@@ -53,10 +39,24 @@ typedef struct pub_data {
 
 // General list
 typedef struct list {
-	void *data;
-	void *next;
+    void *data;
+    void *next;
 } list;
 
+#include "tlv.h"
+#include "hash.h"
+#include "parser.h"
+
+// On which port do we listen to
+#define LISTEN_PORT 1212
+
+// The node ID
+#define NODE_ID 42675882021843277
+
+// The number of neighbours
+// The neighbour table has 15 entries
+#define NEIGHBOUR_MAX 15
+
 // Static variables
 static list *data_list;
 static list *neighbour_list;
@@ -66,13 +66,13 @@ static list *neighbour_list;
 // fonctions signatures
 void listen_for_packets();
 
-int check_header(char * received_datagram[], int buffer_len, struct packet * packet_to_return);
+int check_header(char * received_datagram, int buffer_len, packet * packet_to_return);
 
-int validate_tlvs(struct packet * pack, struct tlv_list * tlv_l);
+int validate_tlv(char *data, int pos, short packet_len);
 
 int update_neighbours();
 
-int work_with_tlvs(char * data[], short packet_len, struct sockaddr_in6 sender);
+int work_with_tlvs(char * data, short packet_len, struct sockaddr_in6 sender);
 
 void add_tlv(struct packet *packet, union tlv *tlv, char type);
 
@@ -81,12 +81,12 @@ void add_tlv(struct packet *packet, union tlv *tlv, char type);
 /* Takes a TLV and sends it over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
+int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
 
 /* Takes a list of TLV and sends them over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlvs(struct list * tlv_list, int tlv_size, struct sockaddr_in6 * dest_list[], int dest_list_size, int socket_num);
+int send_tlvs(struct list * tlv_list, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
 
 // threaded functions
 void t_ask_for_more_peers();
diff --git a/src/node.o b/src/node.o
new file mode 100644
index 0000000000000000000000000000000000000000..96e7e6c9a2de0ea806aa8ebc7842069b36c667f3
GIT binary patch
literal 10576
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
KUgf7<{(k^FM#4J)

literal 0
HcmV?d00001

diff --git a/src/parser.o b/src/parser.o
new file mode 100644
index 0000000000000000000000000000000000000000..0cdd296b3e6d45a1381d4f89dc493d8414779b6b
GIT binary patch
literal 2752
zcmbtV&2Jl35FclqHVvuQDMbouA(n7Zis;I28fZBnZ$1~aYAYHem6B{6dtHarAN8)G
z1qmABfL6h%NFc;5NQes@dT0;jfE*PO2@dqge^88&qNq}71tQG6eXm~DwuE3JzxmB?
zKHl4TA9-g|pXv$(Ku7?dho&W1fXlm^IKf~7_Cg=1FRRIKzehryNuJi6KeXlFN?ib&
zb9*xw4I-~?PB0Bxtr*l+Hhc8i7twW`BBQMZhlVM_sYY{{6R&GdL)(1+IxCO-q5I1l
z8)$4aq&wPIx^r7wdxU(y(4ei>?U-J>7QKarUi&)wBayXH^2O^ItUKGf^DB#8xz{CE
ze?Ui8E(W98S~XfnL++QfwU61<8Es@gTMGtEM8lf1LIIldv)n%(W?TeOgrOLs7()p}
z35HG~I>pdDqIrf&h)Rg6(aTs%?q4Cr>?^KKirMR~O^Vr9U7M-ZEi|;{@2II~XVq8L
zS#|EFJSe{O2DMmsw(fi>e_B5X)p|wYJ-E@!Jij+RGq@wjLF4XUJ3I1VmGFZ)-H5$)
z<kedk^$oROckXJ=7A8w*uzohKp)V^BPBimFEU-D7{a_sr`8@LK>zIw@@Qa}F8e2;O
z(57S8cm-`X$B-2nIy<+gcNWU#1t^${=W+|hN*R&;MzOpUvFwy>LZO&3IV=?|8(?~T
z{JF?*a-mYNE0JfFQ6+YGq{6KD+wo&c?C2qv#krX5=Q{A_OAxpi4jky)-E#$3f}aKl
zx$g|EbSxD9uxl(dP?M%Zkq?4uX!yNuH56Of^<rqfTS^9cLowvkPy}Nzb}ZC0L0{fU
z=wpMhz0=MwwY`A=68^Ol2`jY|320YaMFP)d_P8bJ@mMaTQv_}5$eefm%wU7t&u*ae
z;FU+2(G77giTH8O5BT^eIRB)NCsTr5E$lEd`#gPPdxqQ*{DoVh0giRxPjujCI`Eke
z{DlrYlu~8OEGubH^zj%CaT<=$FiOJ+4M*KDBc0EHWoH%(U`*>L$5h=oIW={9a>kfZ
z$Mi`9vgb_O0>fCeis|FW4a-WW3R$!*yPPgvGSayvW~9<fgpF)!@jR}Jq~t1~qfPz!
zbH|km=jlZ4^Y9;Wp5p10i1^PrPw@|X__yeQqfq=F{E7HaJUpEp!Qb@obZ-Q|&3UR%
zXG`!B6-FV|hd;qT=Hd5x_$2444*e4m@e#x%<mMsF2F1FRw^IwK?Xs(L0+r44DaAG~
z+Mr}ob_$dQ%L1ibB!j}^3hrsTn9rL93@H?CQ<*-IJd7_^dI{qw+sql+aw>1SbN!Do
zg1OWp|BXl>M<VWlYqj2m1L&ZhBt!t$_xRJ%!~0KrMNqsD;=a=TB;NlrefE!LVgMIj
zPMGjCBC7dc^XWaInsm>-BIbX_OClEY3!UIx%oq0)U;k4+UgQb=0?+q_!To>v{c}9O
zC7d^8-d9-kU(ja|wA(-N#EX5R{i9rwFL?TnmbsCe=ktfTlkOzF`Tl&m+y1>n3QGL^
ayi0~hMBfC}kDy)t0RI=26M<a&^Zy1snwt{<

literal 0
HcmV?d00001

diff --git a/src/tlv.h b/src/tlv.h
index b548ca0..c86cdc5 100644
--- a/src/tlv.h
+++ b/src/tlv.h
@@ -5,10 +5,6 @@
 #include <netinet/in.h>
 #include <stdlib.h>
 
-#include "node.h"
-#include "hash.h"
-#include "parser.h"
-
 #define LEN_NEIGHBOUR_REQ 0
 #define LEN_NEIGHBOUR 18
 #define LEN_NETWORK_HASH 16
@@ -111,6 +107,10 @@ typedef union tlv {
 	warning *warning;
 } tlv;
 
+#include "node.h"
+#include "hash.h"
+#include "parser.h"
+
 // build tlv from token
 int build_tlv(tlv *tlv, struct cmd_token token);
 
@@ -119,7 +119,7 @@ int build_pad1(tlv *tlv);
 int build_padn(tlv *tlv, size_t len);
 int build_neighbour_req(union tlv *tlv);
 int build_neighbour(tlv *tlv, struct in6_addr ip, short port);
-int build_network_hash(tlv *tlv, struct list *data_list);
+int build_network_hash(tlv *tlv, list *data_list);
 int build_network_state_req(tlv *tlv);
 int build_node_hash(tlv *tlv, long node_id, short seqno, char *data);
 int build_node_state_req(tlv *tlv, long node_id);
diff --git a/src/tlv.o b/src/tlv.o
new file mode 100644
index 0000000000000000000000000000000000000000..4bdf7c2702f6b770320093b5f1edd1e33912cf54
GIT binary patch
literal 4744
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

literal 0
HcmV?d00001


From 50bb64059bc7002de83430400bc0d61399ccc487 Mon Sep 17 00:00:00 2001
From: gonzalef <kneesbrah@gmail.com>
Date: Thu, 16 Apr 2020 15:27:32 +0200
Subject: [PATCH 16/18] change data types

---
 src/hash.h |  1 +
 src/node.c | 25 +++++++++----------------
 src/node.h | 23 ++++++++++-------------
 src/tlv.c  | 14 +++++++-------
 src/tlv.h  | 13 +++++++------
 5 files changed, 34 insertions(+), 42 deletions(-)

diff --git a/src/hash.h b/src/hash.h
index 748b6b1..5258a7e 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -2,6 +2,7 @@
 #define HASH_H
 
 #include <openssl/sha.h>
+#include <stdint.h>
 
 #include "tlv.h"
 #include "parser.h"
diff --git a/src/node.c b/src/node.c
index b4dd698..c32b546 100644
--- a/src/node.c
+++ b/src/node.c
@@ -1,18 +1,11 @@
 // This is the main file of the Dazibao project. It represents the node, and
 // handles all of the main logic, including the network connexions.
-#include <stdlib.h>
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <time.h>
 
 #include "node.h"
-#include "tlv.h"
-#include "hash.h"
-#include "parser.h"
 
+// Static variables
+static list *data_list;
+static list *neighbour_list;
 
 /* ----  Fonctions utilitaires  ---- */
 
@@ -47,7 +40,7 @@ neighbour_peer *get_random_neighbour() {
 }
 
 // get data associated with id, if it doesn't exist return NULL
-pub_data *get_data(long id) {
+pub_data *get_data(int64_t id) {
 	list *tmp = data_list;
 	pub_data *data;
 
@@ -62,7 +55,7 @@ pub_data *get_data(long id) {
 }
 
 // Take data as args and create a pub_data structure in the heap
-pub_data *copy_data(unsigned char len, long id, short seqno, char *data) {
+pub_data *copy_data(unsigned char len, int64_t id, int16_t seqno, char *data) {
 	pub_data *new_data = (pub_data*) malloc(sizeof(pub_data));
 	char *_data = (char*) malloc(len);
 	new_data->length = len;
@@ -75,7 +68,7 @@ pub_data *copy_data(unsigned char len, long id, short seqno, char *data) {
 }
 
 // Add new data to data list
-void add_data(unsigned char len, long id, short seqno, char *data) {
+void add_data(unsigned char len, int64_t id, int16_t seqno, char *data) {
 	// If id is the same as this node's id then we only update seqno
 	if(id == NODE_ID) {
 		pub_data *node_data = get_data(NODE_ID);
@@ -103,7 +96,7 @@ void add_data(unsigned char len, long id, short seqno, char *data) {
 	list *tmp = data_list;
 	list *last = NULL;
 	list *new_node;
-	long cur_id;
+	int64_t cur_id;
 
 	while(tmp != NULL) {
 		cur_id = ((pub_data*) tmp->data)->id;
@@ -224,7 +217,7 @@ int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_l
 
 // We need to make sure the TLV announces a length that will no go onto
 // another tlv, as we might end up reading bullshit.
-int validate_tlv(char *data, int pos, short packet_len){
+int validate_tlv(char *data, int pos, int16_t packet_len){
     char type = data[pos];
 
     // Nothing to do in this case
@@ -309,7 +302,7 @@ int update_neighbours(){
 };
 
 // We then look at the differents TLVs in the packet.
-int work_with_tlvs(char * data, short packet_len, struct sockaddr_in6 sender){
+int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
     int pos = 0;
     unsigned char tlv_len, hash[16];
     char warn[32];
diff --git a/src/node.h b/src/node.h
index d84971b..709331c 100644
--- a/src/node.h
+++ b/src/node.h
@@ -4,12 +4,13 @@
 #define NODE_H
 
 #include <stdlib.h>
-#include <time.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <string.h>
+#include <time.h>
+#include <stdint.h>
 
 /* la table de voisins, qui est indexée par adresses de socket (des paires (IP, Port)),
  * et dont chaque entrée contient un booléen indiquant si le pair est permanent
@@ -18,7 +19,7 @@
 */
 typedef struct neighbour_peer {
     struct in6_addr ip;
-    short port;
+    int16_t port;
     char is_temporary;
     struct timeval last_seen;
 } neighbour_peer;
@@ -32,8 +33,8 @@ typedef struct neighbour_peer {
 
 typedef struct pub_data {
     unsigned char length;
-    long id;
-    short seqno;
+    int64_t id;
+    int16_t seqno;
     char *data;
 } pub_data;
 
@@ -57,10 +58,6 @@ typedef struct list {
 // The neighbour table has 15 entries
 #define NEIGHBOUR_MAX 15
 
-// Static variables
-static list *data_list;
-static list *neighbour_list;
-
 // TODO
 
 // fonctions signatures
@@ -68,11 +65,11 @@ void listen_for_packets();
 
 int check_header(char * received_datagram, int buffer_len, packet * packet_to_return);
 
-int validate_tlv(char *data, int pos, short packet_len);
+int validate_tlv(char *data, int pos, int16_t packet_len);
 
 int update_neighbours();
 
-int work_with_tlvs(char * data, short packet_len, struct sockaddr_in6 sender);
+int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender);
 
 void add_tlv(struct packet *packet, union tlv *tlv, char type);
 
@@ -101,12 +98,12 @@ int len_list(list *l);
 neighbour_peer *get_random_neighbour();
 
 // get data associated with id, if it doesn't exist return NULL
-pub_data *get_data(long id);
+pub_data *get_data(int64_t id);
 
 // Take data as args and create a pub_data structure in the heap
-pub_data *copy_data(unsigned char len, long id, short seqno, char *data);
+pub_data *copy_data(unsigned char len, int64_t id, int16_t seqno, char *data);
 
 // add new data to data list
-void add_data(unsigned char len, long id, short seqno, char *data);
+void add_data(unsigned char len, int64_t id, int16_t seqno, char *data);
 
 #endif
diff --git a/src/tlv.c b/src/tlv.c
index 5fe7dbf..339e8b5 100644
--- a/src/tlv.c
+++ b/src/tlv.c
@@ -68,7 +68,7 @@ int build_neighbour_req(tlv *tlv) {
 	return 0;
 }
 
-int build_neighbour(tlv *tlv, struct in6_addr ip, short port) {
+int build_neighbour(tlv *tlv, struct in6_addr ip, int16_t port) {
 	neighbour *new = (neighbour*) malloc(sizeof(neighbour));
 
 	if(new == NULL)
@@ -92,7 +92,7 @@ int build_network_hash(tlv *tlv, list *data_list) {
 
 	new->type = 4;
 	new->length = 16;
-	hash_network(data_list, new->network_hash);
+	hash_network(data_list, (unsigned char*) new->network_hash);
 
 	tlv->network_hash = new;
 
@@ -113,7 +113,7 @@ int build_network_state_req(tlv *tlv) {
 	return 0;
 }
 
-int build_node_hash(tlv *tlv, long node_id, short seqno, char *data) {
+int build_node_hash(tlv *tlv, int64_t node_id, int16_t seqno, char *data) {
 	node_hash *new = (node_hash*) malloc(sizeof(node_hash));
 
 	if(new == NULL)
@@ -125,14 +125,14 @@ int build_node_hash(tlv *tlv, long node_id, short seqno, char *data) {
 	new->seqno = seqno;
 
 	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
-	hash_data(&pdata, new->node_hash);
+	hash_data(&pdata, (unsigned char*) new->node_hash);
 
 	tlv->node_hash = new;
 
 	return 0;
 }
 
-int build_node_state_req(tlv *tlv, long node_id) {
+int build_node_state_req(tlv *tlv, int64_t node_id) {
 	node_state_req *new = (node_state_req*) malloc(sizeof(node_state_req));
 
 	if(new == NULL)
@@ -147,7 +147,7 @@ int build_node_state_req(tlv *tlv, long node_id) {
 	return 0;
 }
 
-int build_node_state(tlv *tlv, long node_id, short seqno, char *data, size_t data_len) {
+int build_node_state(tlv *tlv, int64_t node_id, int16_t seqno, char *data, size_t data_len) {
 	node_state *new = (node_state*) malloc(sizeof(node_state));
 	int len = data_len + 26;
 
@@ -167,7 +167,7 @@ int build_node_state(tlv *tlv, long node_id, short seqno, char *data, size_t dat
 	memcpy(new->data, data, len);
 
 	pub_data pdata = (pub_data) {.id = node_id, .seqno = seqno, .data = data};
-	hash_data(&pdata, new->node_hash);
+	hash_data(&pdata, (unsigned char*) new->node_hash);
 
 	tlv->node_state = new;
 
diff --git a/src/tlv.h b/src/tlv.h
index c86cdc5..def4788 100644
--- a/src/tlv.h
+++ b/src/tlv.h
@@ -4,6 +4,7 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <stdlib.h>
+#include <stdint.h>
 
 #define LEN_NEIGHBOUR_REQ 0
 #define LEN_NEIGHBOUR 18
@@ -65,7 +66,7 @@ typedef struct network_state_req {
 typedef struct node_hash {
 	unsigned char type;
 	unsigned char length;
-	long node_id;
+	int64_t node_id;
 	short seqno;
 	char node_hash[16];
 } node_hash;
@@ -74,14 +75,14 @@ typedef struct node_hash {
 typedef struct node_state_req {
 	unsigned char type;
 	unsigned char length;
-	long node_id;
+	int64_t node_id;
 } node_state_req;
 
 // 28 octets min, 220 octets max (data 0 -> 192)
 typedef struct node_state {
 	unsigned char type;
 	unsigned char length;
-	long node_id;
+	int64_t node_id;
 	short seqno;
 	char node_hash[16];
 	char data[192];
@@ -121,9 +122,9 @@ int build_neighbour_req(union tlv *tlv);
 int build_neighbour(tlv *tlv, struct in6_addr ip, short port);
 int build_network_hash(tlv *tlv, list *data_list);
 int build_network_state_req(tlv *tlv);
-int build_node_hash(tlv *tlv, long node_id, short seqno, char *data);
-int build_node_state_req(tlv *tlv, long node_id);
-int build_node_state(tlv *tlv, long node_id, short seqno, char *data, size_t data_len);
+int build_node_hash(tlv *tlv, int64_t node_id, short seqno, char *data);
+int build_node_state_req(tlv *tlv, int64_t node_id);
+int build_node_state(tlv *tlv, int64_t node_id, short seqno, char *data, size_t data_len);
 int build_warning(tlv *tlv, char *message, size_t message_len);
 
 #endif

From e4e585121e12286dc94ef207cbebecb2d4b510a1 Mon Sep 17 00:00:00 2001
From: gonzalef <kneesbrah@gmail.com>
Date: Thu, 16 Apr 2020 18:52:19 +0200
Subject: [PATCH 17/18] send packets v1

---
 src/node.c | 243 ++++++++++++++++++++++++++++++++++++++++++++++++-----
 src/node.h |  13 ++-
 src/node.o | Bin 10576 -> 13344 bytes
 src/tlv.c  |  32 ++++++-
 src/tlv.h  |  18 ++--
 src/tlv.o  | Bin 4744 -> 5064 bytes
 6 files changed, 272 insertions(+), 34 deletions(-)

diff --git a/src/node.c b/src/node.c
index c32b546..4e2c357 100644
--- a/src/node.c
+++ b/src/node.c
@@ -156,7 +156,194 @@ void add_data(unsigned char len, int64_t id, int16_t seqno, char *data) {
 
 /* ---- Fin fonctions utilitaires ---- */
 
-int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num){
+// Add TLV to packet, if it does not fit then send the packet and reset the packet buff to be able to add more TLVs that will be sent afterwards
+int add_tlv(packet *pack, tlv *tlv, struct sockaddr_in6 *dest, int socket_num) {
+    char type = tlv->pad1->type, sent = 0, errval = 0;
+    unsigned char len;
+
+    // Check if TLV fits in the packet, if not then send the packet and reset it
+    if(type != 1) {
+        len = tlv->padn->length + 2;
+
+        if(pack->length + len > 1020) {
+            errval = send_packet((char*) pack, pack->length, dest, socket_num);
+            *pack = (packet) {.magic = 95, .version = 1, .length = 0};
+            memset(pack->body, 0, 1020);
+            sent = 1;
+        }
+    } else {
+        if(pack->length >= 1020) {
+            errval = send_packet((char*) pack, pack->length, dest, socket_num);
+            *pack = (packet) {.magic = 95, .version = 1, .length = 0};
+            memset(pack->body, 0, 1020);
+            sent = 1;
+        }
+    }
+
+    // Copy data from tlv into body 
+    switch(type) {
+        case 1:
+            memcpy(pack->body + pack->length, tlv->pad1, 1);
+            pack->length += 1;
+
+            break;
+        case 2:
+            memcpy(pack->body + pack->length, tlv->padn, len);
+            pack->length += len;
+
+            break;
+        case 3:
+            memcpy(pack->body + pack->length, tlv->neighbour, len);
+            pack->length += len;
+
+            break;
+        case 4:
+            memcpy(pack->body + pack->length, tlv->network_hash, len);
+            pack->length += len;
+
+            break;
+        case 5:
+            memcpy(pack->body + pack->length, tlv->network_state_req, len);
+            pack->length += len;
+
+            break;
+        case 6:
+            memcpy(pack->body + pack->length, tlv->node_hash, len);
+            pack->length += len;
+
+            break;
+        case 7:
+            memcpy(pack->body + pack->length, tlv->node_state_req, len);
+            pack->length += len;
+
+            break;
+        case 8:
+            memcpy(pack->body + pack->length, tlv->node_state, len);
+            pack->length += len;
+
+            break;
+        case 9:
+            memcpy(pack->body + pack->length, tlv->warning, len);
+            pack->length += len;
+
+            break;
+        default:
+            return -1;
+    }
+
+    // If the previous packet was went return 1 or -1 if there was an error sending it 
+    if(sent)
+        return errval? -1:1;
+
+    // Return 0 if the TLV was added to the packet
+    return 0;
+}
+
+// Send length bytes from packet
+int send_packet(char *packet_buff, int16_t length, struct sockaddr_in6 *dest, int socket_num) {
+    // Vectorized buffer
+    struct iovec vec_buff = {.iov_len = length, .iov_base = packet_buff};
+
+    int error_while_sending = 0;
+
+    // Creating the struct to send out with sendmsg
+    struct msghdr packet_tlv_send_out = {
+        .msg_name = dest,
+        .msg_namelen = sizeof(struct sockaddr_in6),
+        .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(socket_num, &packet_tlv_send_out, 0);
+    if (response_code < 0) {
+        // debug_print("Unable to send out the packet to peer %i", i);
+        error_while_sending = 1;
+    } else if (response_code < length) {
+        // debug_print("Sent out only part of the packet.");
+        error_while_sending = 1;
+    } else {
+        // debug_print("Send out packet to peer %i", i);
+    }
+
+    if (error_while_sending == 1) {
+        // debug_print("Error occured while sending out a packet.");
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+// Send a single TLV to the specified addresses, return -1 if an error was encountered, 0 otherwise
+int send_single_tlv(tlv *tlv, struct sockaddr_in6 *dest, int socket_num) {
+    char type = tlv->pad1->type;
+    unsigned char len;
+    packet pack = (packet) {.magic = 95, .version = 1, .length = 4};
+    memset(pack.body, 0, 1020);
+
+    // Copy data from tlv into body 
+    switch(type) {
+        case 1:
+            memcpy(pack.body, tlv->pad1, 1);
+            pack.length += 1;
+
+            break;
+        case 2:
+            len = tlv->padn->length + 2;
+            memcpy(pack.body, tlv->padn, len);
+            pack.length += len;
+
+            break;
+        case 3:
+            len = tlv->neighbour->length + 2;
+            memcpy(pack.body, tlv->neighbour, len);
+            pack.length += len;
+
+            break;
+        case 4:
+            len = tlv->network_hash->length + 2;
+            memcpy(pack.body, tlv->network_hash, len);
+            pack.length += len;
+
+            break;
+        case 5:
+            len = tlv->network_state_req->length + 2;
+            memcpy(pack.body, tlv->network_state_req, len);
+            pack.length += len;
+
+            break;
+        case 6:
+            len = tlv->node_hash->length + 2;
+            memcpy(pack.body, tlv->node_hash, len);
+            pack.length += len;
+
+            break;
+        case 7:
+            len = tlv->node_state_req->length + 2;
+            memcpy(pack.body, tlv->node_state_req, len);
+            pack.length += len;
+
+            break;
+        case 8:
+            len = tlv->node_state->length + 2;
+            memcpy(pack.body, tlv->node_state, len);
+            pack.length += len;
+
+            break;
+        case 9:
+            len = tlv->warning->length + 2;
+            memcpy(pack.body, tlv->warning, len);
+            pack.length += len;
+
+            break;
+        default:
+            return -1;
+    }
+
+    // Send the packet
+    return send_packet((char*) &pack, pack.length, dest, socket_num);
+}
+
+int send_tlv(tlv *tlv_to_send, int16_t tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num){
 	// debug_print("Building packet to send a TLV.");
 
 	// We first need to build the packet,
@@ -302,16 +489,27 @@ int update_neighbours(){
 };
 
 // We then look at the differents TLVs in the packet.
-int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
+int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 *sender, int socket_num){
     int pos = 0;
     unsigned char tlv_len, hash[16];
     char warn[32];
     tlv new_tlv, cur_tlv;
+    new_tlv.pad1 = NULL;
+    cur_tlv.pad1 = NULL;
     list *tmp_list;
     pub_data *pdata;
+	struct neighbour_peer *random_neighbour;
+    struct sockaddr_in6 new_neighbour;
 
-	struct neighbour_peer * random_neighbour;
+    packet pack = (packet) {.magic = 95, .version = 1, .length = 0};
+    memset(pack.body, 0, 1020);
 
+    int ifindex = if_nametoindex("eth0");
+
+    if(ifindex == 0) {
+        perror("if_nametoindex failed");
+        return -1;
+    }
 
     while(pos < packet_len) {
         switch(validate_tlv(data, pos, packet_len)) {
@@ -332,9 +530,7 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
                 // Send a neighbour tlv
 				random_neighbour = get_random_neighbour();
                 build_neighbour(&new_tlv, random_neighbour->ip, random_neighbour->port);
-
-                // NOT FINISHED - What packet is it added to?
-                // add_tlv(packet, &new_tlv, 3);
+                add_tlv(&pack, &new_tlv, sender, socket_num);
 
                 // The position is updated
                 tlv_len = data[pos+1];
@@ -345,11 +541,16 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
                 // We received a neighbour tlv so a tlv network hash is sent to that address
             	cur_tlv.neighbour = (neighbour*) (data + pos);
 
+                // Init dest socket
+                memset(&new_neighbour, 0, sizeof(new_neighbour));
+                new_neighbour.sin6_family = AF_INET6;
+                memcpy(&new_neighbour.sin6_addr, &cur_tlv.neighbour->ip, 16);
+                new_neighbour.sin6_port = htons(LISTEN_PORT);
+                new_neighbour.sin6_scope_id = ifindex;
+
                 // Build network hash
                 build_network_hash(&new_tlv, data_list);
-
-                // NOT FINISHED - What packet is it added to?
-                // add_tlv(packet, &new_tlv, 4);
+                send_single_tlv(&new_tlv, &new_neighbour, socket_num);
 
                 // The position is updated
                 tlv_len = data[pos+1];
@@ -363,8 +564,7 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
 
             	if(memcmp(hash, cur_tlv.network_hash->network_hash, 16) == 0) {
                 	build_network_state_req(&new_tlv);
-                	// NOT FINISHED - What packet is it added to?
-                	// add_tlv(packet, &new_tlv, 5);
+                	add_tlv(&pack, &new_tlv, sender, socket_num);
             	}
 
                 // The position is updated
@@ -381,8 +581,7 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
                 while(tmp_list != NULL) {
                 	pdata = (pub_data*) tmp_list->data;
                 	build_node_hash(&new_tlv, pdata->id, pdata->seqno, pdata->data);
-                	// NOT FINISHED - What packet is it added to?
-                	// add_tlv(packet, &new_tlv, 4);
+                	add_tlv(&pack, &new_tlv, sender, socket_num);
                 }
 
                 // The position is updated
@@ -412,8 +611,7 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
 
             	// If no pub_data was found or the hashes differ then we send a node state request
             	build_node_state_req(&new_tlv, cur_tlv.node_hash->node_id);
-            	// NOT FINISHED - What packet is it added to?
-            	// add_tlv(packet, &new_tlv, 7);
+            	add_tlv(&pack, &new_tlv, sender, socket_num);
 
             	// The position is updated
             	tlv_len = data[pos+1];
@@ -427,8 +625,7 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
 
             	if(pdata != NULL) {
             		build_node_state(&new_tlv, pdata->id, pdata->seqno, pdata->data, pdata->length);
-            		// NOT FINISHED - What packet is it added to?
-            		// add_tlv(packet, &new_tlv, 8);
+            		add_tlv(&pack, &new_tlv, sender, socket_num);
             	}
 
             	// The position is updated
@@ -464,13 +661,19 @@ int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender){
             	// A malformed packet was found so we stop looking for more packets and send a warning tlv
             	strcpy(warn, "Packet is malformed.");
             	build_warning(&new_tlv, warn, strlen(warn));
-            	// NOT FINISHED - What packet is it added to?
-            	// add_tlv(packet, &new_tlv, 9);
+            	add_tlv(&pack, &new_tlv, sender, socket_num);
 
                 return -1;
         }
     }
 
+    // Free the previously allocated memory
+    free(new_tlv.pad1);
+
+    // If the packet still has data in it then send it
+    if(pack.length > 0) 
+        send_packet((char*) &pack, pack.length, sender, socket_num);
+
     return 0;
 }
 
@@ -535,7 +738,7 @@ void listen_for_packets(){
 
         // struct tlv_list received_tlvs;
         // if (validate_tlvs(formated_rec_datagram) < 0)
-        int nbr_success_tlv = work_with_tlvs(req, 1024, sender);
+        int nbr_success_tlv = work_with_tlvs(req, 1024, &sender, s);
         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 );
diff --git a/src/node.h b/src/node.h
index 709331c..b59b5b9 100644
--- a/src/node.h
+++ b/src/node.h
@@ -11,6 +11,7 @@
 #include <string.h>
 #include <time.h>
 #include <stdint.h>
+#include <net/if.h>
 
 /* la table de voisins, qui est indexée par adresses de socket (des paires (IP, Port)),
  * et dont chaque entrée contient un booléen indiquant si le pair est permanent
@@ -69,21 +70,25 @@ int validate_tlv(char *data, int pos, int16_t packet_len);
 
 int update_neighbours();
 
-int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 sender);
+int work_with_tlvs(char * data, int16_t packet_len, struct sockaddr_in6 *sender, int socket_num);
 
-void add_tlv(struct packet *packet, union tlv *tlv, char type);
+int add_tlv(packet *pack, tlv *tlv, struct sockaddr_in6 *dest, int socket_num);
+
+int send_packet(char *packet_buff, int16_t length, struct sockaddr_in6 *dest, int socket_num);
+
+int send_single_tlv(tlv *tlv, struct sockaddr_in6 *dest, int socket_num);
 
 // int send_packet();
 
 /* Takes a TLV and sends it over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlv(union tlv * tlv_to_send, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
+int send_tlv(tlv *tlv_to_send, int16_t length, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
 
 /* Takes a list of TLV and sends them over to everyone in the list of addresses.
  * Returns -1 in case of error, 0 otherwise.
  */
-int send_tlvs(struct list * tlv_list, int tlv_size, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
+int send_tlvs(struct list * tlv_list, int16_t length, struct sockaddr_in6 * dest_list, int dest_list_size, int socket_num);
 
 // threaded functions
 void t_ask_for_more_peers();
diff --git a/src/node.o b/src/node.o
index 96e7e6c9a2de0ea806aa8ebc7842069b36c667f3..bace0293010b5317d87cb6e2832d40e120e68ebb 100644
GIT binary patch
literal 13344
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
OviZMnze>MO{{IGpZc&c_

literal 10576
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
KUgf7<{(k^FM#4J)

diff --git a/src/tlv.c b/src/tlv.c
index 339e8b5..1f5b4e8 100644
--- a/src/tlv.c
+++ b/src/tlv.c
@@ -27,6 +27,9 @@ int build_tlv(tlv *tlv, cmd_token token) {
 }
 
 int build_pad1(tlv *tlv) {
+	// Free the previously allocated memory
+	free(tlv->pad1);
+
 	pad1 *new = (pad1*) malloc(sizeof(pad1));
 
 	if(new == NULL)
@@ -40,6 +43,9 @@ int build_pad1(tlv *tlv) {
 }
 
 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)
@@ -47,7 +53,7 @@ int build_padn(tlv *tlv, size_t len) {
 
 	new->type = 1;
 	new->length = len;
-	new->mbz = (char*) calloc(sizeof(char), len);
+	memset(new->mbz, 0, 256);
 
 	tlv->padn = new;
 
@@ -55,6 +61,9 @@ int build_padn(tlv *tlv, size_t len) {
 }
 
 int build_neighbour_req(tlv *tlv) {
+	// Free the previously allocated memory
+	free(tlv->pad1);
+
 	neighbour_req *new = (neighbour_req*) malloc(sizeof(neighbour_req));
 
 	if(new == NULL)
@@ -69,6 +78,9 @@ int build_neighbour_req(tlv *tlv) {
 }
 
 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)
@@ -85,6 +97,9 @@ int build_neighbour(tlv *tlv, struct in6_addr ip, int16_t port) {
 }
 
 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)
@@ -100,6 +115,9 @@ int build_network_hash(tlv *tlv, list *data_list) {
 }
 
 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)
@@ -114,6 +132,9 @@ int build_network_state_req(tlv *tlv) {
 }
 
 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)
@@ -133,6 +154,9 @@ int build_node_hash(tlv *tlv, int64_t node_id, int16_t seqno, char *data) {
 }
 
 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)
@@ -148,6 +172,9 @@ int build_node_state_req(tlv *tlv, int64_t node_id) {
 }
 
 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;
 
@@ -175,6 +202,9 @@ int build_node_state(tlv *tlv, int64_t node_id, int16_t seqno, char *data, size_
 }
 
 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;
 
diff --git a/src/tlv.h b/src/tlv.h
index def4788..d10d3c9 100644
--- a/src/tlv.h
+++ b/src/tlv.h
@@ -19,8 +19,8 @@
 typedef struct packet {
 	unsigned char magic; // 95 (si autre, ignorer)
 	unsigned char version; // 1 (si autre, ignorer)
-	short length; // 1020 max
-	char *body;
+	int16_t length; // 1020 max
+	char body[1020];
 } packet;
 
 // 1 octet
@@ -32,7 +32,7 @@ typedef struct pad1 {
 typedef struct padn {
 	unsigned char type;
 	unsigned char length;
-	char *mbz;
+	char mbz[256];
 } padn;
 
 // 2 octets
@@ -46,7 +46,7 @@ typedef struct neighbour {
 	unsigned char type;
 	unsigned char length;
 	struct in6_addr ip;
-	short port;
+	int16_t port;
 } neighbour;
 
 // 18 octets
@@ -67,7 +67,7 @@ typedef struct node_hash {
 	unsigned char type;
 	unsigned char length;
 	int64_t node_id;
-	short seqno;
+	int16_t seqno;
 	char node_hash[16];
 } node_hash;
 
@@ -83,7 +83,7 @@ typedef struct node_state {
 	unsigned char type;
 	unsigned char length;
 	int64_t node_id;
-	short seqno;
+	int16_t seqno;
 	char node_hash[16];
 	char data[192];
 } node_state;
@@ -119,12 +119,12 @@ int build_tlv(tlv *tlv, struct cmd_token token);
 int build_pad1(tlv *tlv);
 int build_padn(tlv *tlv, size_t len);
 int build_neighbour_req(union tlv *tlv);
-int build_neighbour(tlv *tlv, struct in6_addr ip, short port);
+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, int64_t node_id, short seqno, char *data);
+int build_node_hash(tlv *tlv, int64_t node_id, int16_t seqno, char *data);
 int build_node_state_req(tlv *tlv, int64_t node_id);
-int build_node_state(tlv *tlv, int64_t node_id, short seqno, char *data, size_t data_len);
+int build_node_state(tlv *tlv, int64_t node_id, int16_t seqno, char *data, size_t data_len);
 int build_warning(tlv *tlv, char *message, size_t message_len);
 
 #endif
diff --git a/src/tlv.o b/src/tlv.o
index 4bdf7c2702f6b770320093b5f1edd1e33912cf54..1e8ab96c956ad818a9ad859caa1441ac4b7f7b53 100644
GIT binary patch
literal 5064
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
R*`LPC7UYoqYm`p=zX1et=N|w7

delta 1762
zcmZ`(Z)jUp6o2m}%is0pCDkT%b!q1tO+`k6(`GW)yxMi|K}K7;tm0PtFGRalS6GKF
zI;>=tUR*KT`8Ec2;0GsD5x)$-B%`{@U{awK6q&dWZnCOnTR*v~=iIzkVws1$`|kby
z&Y#~o_mOWJr?(ekiYIX9$s=dZ*Z1cNxgCM%DTz!!kTLm#?xKo&gRkBu%y_pn)@bm#
ztCF0WepNR3A4M5q!I`{HGx!UhMCnkket52M`5&}9_i}c=ZiD{?yXD5{BxTYw`T>)#
zW(X}t5HR^7zi#B0J#bcjMlE1<gRgZLLxQ>wx8!8ie^WiBG&W2kE9nPyRJw){#TXvD
zO@5y*nfzN!7Kei4(Y>Vl2&&En{w!T~J%(+}91o@WkSE6-Iet_%_^m*bQ#0n<G-_5#
z^Q?y4h^D6bm=-B_2frwfG}jsVuj166-mAYnXLnZabW!*PqA97|lr=Ze(k@3+4Ar-x
z*dG0$$^WMIixiMSxvM%~H2C%Xd>);XBpE()Bwa^6xi&rozdN=ivzkf@)2PWK$|OoA
z-)g*<)?!)X>CM|?nCV0u#U*WVdLPP5!9M5X&z9DORa~wZ|5~QIsNe<S#0<VfN`))U
zs}s&S8=n7FoK4;<B}$mxQ_hZq6s=r6rAc)CU(%W=-6@p^@jXIhu;TpbZH;z1Q}fCp
zAM@z`cIJ^t?P0>v_R-SH)YFR2B2$hwR-bo{`B(%)TA8QSUx)NG`Jgq?B69Vw=Sm{<
z5#eYZv|z3orIkfaQ?4m^-|cdCvG^;HaYgq(tk~#!v35~RrH;@ZRxE{h+~P066<6fN
zb{5aO(yU)O?qhMC#dKDWwNV3#H~pg1F)QFX%8KfzsMEZogVpzyOY1Zj{3wy0wS4bF
z!X4R($){X8OXl63Y*hKc$CA1z(pphuuV31Yfy-9l1e|n7oE<FwCY*Ec_+s8YA<G)*
z-e_$PdWG<!Ch<)sW`XZPkiB7Z7<a@j5QQeX$M;Em2&W&J7%{$Q@FBd@!tHFclr8az
z#m-u+o$YH2U$F2?cqUt-DEVg*yMkw-QxTLT#)jKX7(;l;!ta)8sRrKhg@aGntfLH1
zz(rqA<h6m3kz+&B;ECapY~ScW_H}7UAW-AK<|IeB;UAP=0)2B>F3?(QD<ZZUp9l0O
zhW4ZI*#h68XTMnAf<#qV{#fkSXsy*PWfY5lGV8J9aHT42o~>Ym73{tL!JDm4DBIQw
z|15N|aN^Snc1s2OLj_)0WfOePj>!wq5D3@WcX=D*$VdP^ozN8s588LO)4C&@weM_v
z13qc#|8N6t-_y!Q+yU1DH{@M#QEm2)<9AP{!f$G`JOK^C7F-8#orDX)7G=o^H-meW
wWhZP4?U8F>Ak-p9;6kWHnXZDH2&JH*y2YFFmD40(xVqU}VCB;r&=idR3sn=FLI3~&


From dd532dc58017dfff3acd5ef1f9485a3ab0172014 Mon Sep 17 00:00:00 2001
From: n07070 <social+gitgr@n07070.xyz>
Date: Fri, 17 Apr 2020 15:37:07 +0200
Subject: [PATCH 18/18] Added function to update messages, Added bootstrap
 function, Added time-delay for node update,

---
 src/node.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/node.c b/src/node.c
index e1d0f89..a5d39e7 100644
--- a/src/node.c
+++ b/src/node.c
@@ -874,6 +874,7 @@ int bootstrap_node(int * sock_fd){
 	return 0;
 }
 
+
 int main(int argc, const char *argv[]) {
 	printf(">> Starting node\n");