client-network/src/data.rs

@@ -473,8 +473,15 @@ pub fn big_or_chunk_to_file(tree: &MerkleTree, node: &MerkleNode, file: &mut Fil
             }
         }
         MerkleNode::Chunk(chunk) => {
-            println!("wrote data");
-            let _ = file.write_all(&chunk.data);
+            if !chunk.data.is_empty() {
+                // Enlève le premier élément
+                let mut data = chunk.data.clone(); // Clone pour éviter de modifier l'original
+                data.remove(0); // Enlève le premier élément
+                println!("wrote data {:?}", data);
+                let _ = file.write(&data);
+            } else {
+                println!("chunk.data is empty, nothing to write");
+            }
         }
         _ => {
             println!("invalid type of file");

client-network/src/datum_parsing.rs

@@ -11,15 +11,19 @@ pub fn parse_received_datum(
     datum_length: usize,
 ) -> Option<([u8; 32], MerkleNode)> {
     let hash_name: [u8; 32] = recevied_datum[..32].try_into().expect("error");
-    let value = &recevied_datum[32..recevied_datum.len()];
+    let value = &recevied_datum[32..datum_length];
     let value_slice = value.to_vec();
-    //println!("valueslice: {:?}, {}", value_slice, value_slice.len());
+    println!("valueslice: {:?}, {}", value_slice, value_slice.len());
 
+    println!(
+        "((value_slice.len() - 1) / 32) {} ",
+        ((value_slice.len() - 1) / 32)
+    );
     // Créer une instance de Sha256
     let mut hasher = Sha256::new();
 
     // Alimenter le hasher avec les données
-    hasher.update(value);
+    hasher.update(value_slice.clone());
 
     // Obtention du résultat
     let result = hasher.finalize();
@@ -27,6 +31,7 @@ pub fn parse_received_datum(
         println!("{:?},{:?}", result.to_vec(), hash_name.to_vec());
         None
     } else {
+        println!("hashes equals!");
         let datum_type = value_slice[0];
         match datum_type {
             CHUNK => Some((

client-network/src/lib.rs

@@ -73,7 +73,7 @@ impl P2PSharedData {
 
         let mut threads = Vec::new();
 
-        let senders = MultipleSenders::new(1, &shared_socket, cmd_tx, &mut threads);
+        let senders = MultipleSenders::new(5, &shared_socket, cmd_tx, &mut threads);
         let shared_senders = Arc::new(senders);
         let server_name = Arc::new(Mutex::new("".to_string()));
         let server_address = Arc::new(Mutex::new("".to_string()));

client-network/src/message_handling.rs

@@ -370,14 +370,11 @@ pub fn parse_message(
                             // envoyer la root request
                             let _ = &guard.remove_entry(&id);
                             println!("message {} retiré de la liste", id);
-
-                            let rootrequest = construct_message(
-                                ROOTREQUEST,
-                                Vec::new(),
-                                generate_id(),
-                                crypto_pair,
-                            );
-                            //&guard.insert(, v)
+                            let new_id = generate_id();
+                            let rootrequest =
+                                construct_message(ROOTREQUEST, Vec::new(), new_id, crypto_pair);
+                            let _ = &guard.insert(new_id, EventType::RootRequest);
+                            println!("root requesst sent");
                             return rootrequest;
                         }
                         EventType::Hello => {
@@ -392,6 +389,7 @@ pub fn parse_message(
         }
         ROOTREPLY => {
             // recuperer le pseudo du peers ayant repondu
+            println!("root reply received");
             let peers_exist = handhsake_history.get_peer_info_ip(ip.to_string());
             match peers_exist {
                 Some(peerinfo) => {
@@ -429,7 +427,9 @@ pub fn parse_message(
                                     constructed_message = datumreqest;
                                     guard.insert(new_id, EventType::DatumRequest);
                                 }
-                                _ => {}
+                                _ => {
+                                    println!("event not prensent");
+                                }
                             }
                         }
                         None => {}

client-network/src/messages_channels.rs

@@ -273,13 +273,13 @@ pub fn start_receving_thread(
     let messages_received_clone = shared_data.messages_received();
     let servername_clone = shared_data.servername();
     let thread = thread::spawn(move || {
-        let mut buf = [0u8; 1024];
+        let mut buf = [0u8; 1500];
         loop {
             match sock_clone.recv_from(&mut buf) {
                 Ok((amt, src)) => {
                     let received_data = buf[..amt].to_vec();
 
-                    println!("Reçu {} octets de {}", amt, src);
+                    println!("Reçu {} octets de {}: {:?}", amt, src, received_data);
                     handle_recevied_message(
                         &messages_clone,
                         &messages_received_clone,

client-network/src/registration.rs

@@ -75,6 +75,7 @@ pub async fn perform_handshake(
                 sd.add_message(id, EventType::Hello);
                 sd.set_serveraddress(sockaddr_bytes.to_string());
             } else {
+                println!("hello the nroot");
                 sd.add_message(id, EventType::HelloThenRootRequest);
             }