Merge pull request 'bigfix' (#5) from bigfix into master

Reviewed-on: #5

client-gui/src/gui_app.rs

@@ -102,6 +102,14 @@ impl P2PClientApp {
     pub fn clear_success(&mut self) {
         self.success_message = None;
     }
+
+    fn set_current_total_chunks(&mut self, len: Option<usize>) {
+        self.current_total_chunks = len
+    }
+
+    fn set_current_received_chunks(&mut self, arg: usize) {
+        self.current_received_chunks = arg
+    }
 }
 
 impl eframe::App for P2PClientApp {
@@ -232,6 +240,7 @@ impl eframe::App for P2PClientApp {
                     if let Some(addr) = &self.active_peer {
                         if let Some(roottree) = self.loaded_fs.get(addr) {
                             if let Some(root) = roottree.data.get(&hash) {
+                                self.current_downloading_file_map.root = hash;
                                 self.root_downloading_file = name;
                                 let _ = self
                                     .current_downloading_file_map
@@ -270,17 +279,46 @@ impl eframe::App for P2PClientApp {
                         }
                         _ => {}
                     }
-
+                    println!("remaining chunks size: {}", self.remaining_chunks.len());
-                    if let Some(total) = self.current_total_chunks {
-                        // recompute received (safer than incrementing)
-                        let received = total.saturating_sub(self.remaining_chunks.len());
-                        self.current_received_chunks = received;
-                    }
-
                     if self.remaining_chunks.is_empty() {
-                        self.current_total_chunks = None;
+                        let file = OpenOptions::new().append(true).create(true).open(
-                        self.current_received_chunks = 0;
+                            "./Download/".to_string()
-                        println!("bigfile téléchargé");
+                                + &remove_null_bytes(&self.root_downloading_file.clone()),
+                        );
+
+                        if let Some(current) = self
+                            .current_downloading_file_map
+                            .data
+                            .get(&self.current_downloading_file_map.root)
+                        {
+                            match file {
+                                Ok(mut fileok) => {
+                                    big_or_chunk_to_file(
+                                        &self.current_downloading_file_map,
+                                        current,
+                                        &mut fileok,
+                                    );
+                                }
+                                Err(e) => {
+                                    eprintln!("error creaation file: {}", e);
+                                }
+                            }
+                        } else {
+                            eprintln!("error root absent");
+                        }
+                        println!("bigfile téléchargé {}", self.root_downloading_file);
+
+                        if let Some(total) = self.current_total_chunks {
+                            // recompute received (safer than incrementing)
+                            let received = total.saturating_sub(self.remaining_chunks.len());
+                            self.current_received_chunks = received;
+                        }
+
+                        if self.remaining_chunks.is_empty() {
+                            self.current_total_chunks = None;
+                            self.current_received_chunks = 0;
+                            println!("bigfile téléchargé");
+                        }
                     }
                 }
                 NetworkEvent::Success(msg, peer_username) => {

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");
+            if !chunk.data.is_empty() {
-            let _ = file.write_all(&chunk.data);
+                // 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,84 +11,103 @@ 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());
-    let datum_type = value_slice[0];
-    match datum_type {
-        CHUNK => Some((
-            hash_name,
-            MerkleNode::Chunk(crate::ChunkNode { data: value_slice }),
-        )),
-        DIRECTORY => {
-            let mut dir_entries = Vec::new();
-            let mut offset = 1 as usize;
-            for i in 0..((value_slice.len() - 1) / 64) as u8 {
-                offset = (1 + 64 * i as usize) as usize;
-                println!("offset:{}, i:{}", offset, i);
-                let name = &value_slice[offset..offset + 32];
-                let mut hash = [0u8; 32];
-                hash.copy_from_slice(&value_slice[offset + 32..offset + 64]);
-                let dp_name = String::from_utf8(name.to_vec()).expect("err");
-                println!("name:{}", dp_name);
 
-                // envoyer un datum request
+    println!(
-                dir_entries.push(DirectoryEntry {
+        "((value_slice.len() - 1) / 32) {} ",
-                    filename: name.try_into().expect("incorrect size"),
+        ((value_slice.len() - 1) / 32)
-                    content_hash: hash,
+    );
-                });
+    // Créer une instance de Sha256
-            }
+    let mut hasher = Sha256::new();
 
-            let current = DirectoryNode::new(dir_entries);
+    // Alimenter le hasher avec les données
-            match current {
+    hasher.update(value_slice.clone());
-                Ok(current_node) => Some((hash_name, MerkleNode::Directory(current_node))),
-                Err(e) => {
-                    println!("{}", e);
-                    None
-                }
-            }
-        }
-        BIG => {
-            let mut bigdir_entries: Vec<NodeHash> = Vec::new();
-            let mut offset = 1 as usize;
-            for i in 0..((value_slice.len() - 1) / 32) as u8 {
-                offset = (1 + 32 * i as usize) as usize;
-                println!("offset:{}, i:{}", offset, i);
-                let hash = &value_slice[offset..offset + 32];
 
-                // envoyer un datum request
+    // Obtention du résultat
-                bigdir_entries.push(hash.try_into().expect("incorrect size"));
+    let result = hasher.finalize();
-            }
+    if result.to_vec() != hash_name.to_vec() {
-
+        println!("{:?},{:?}", result.to_vec(), hash_name.to_vec());
-            println!("its a BIG bro");
+        None
-            Some((
+    } else {
+        println!("hashes equals!");
+        let datum_type = value_slice[0];
+        match datum_type {
+            CHUNK => Some((
                 hash_name,
-                MerkleNode::Big(crate::BigNode {
+                MerkleNode::Chunk(crate::ChunkNode { data: value_slice }),
-                    children_hashes: bigdir_entries,
+            )),
-                }),
+            DIRECTORY => {
-            ))
+                let mut dir_entries = Vec::new();
-        }
+                let mut offset = 1 as usize;
-        BIGDIRECTORY => {
+                for i in 0..((value_slice.len() - 1) / 64) as u8 {
-            let mut bigdir_entries: Vec<NodeHash> = Vec::new();
+                    offset = (1 + 64 * i as usize) as usize;
-            let mut offset = 1 as usize;
+                    println!("offset:{}, i:{}", offset, i);
-            for i in 0..((value_slice.len() - 1) / 32) as u8 {
+                    let name = &value_slice[offset..offset + 32];
-                offset = (1 + 32 * i as usize) as usize;
+                    let mut hash = [0u8; 32];
-                println!("offset:{}, i:{}", offset, i);
+                    hash.copy_from_slice(&value_slice[offset + 32..offset + 64]);
-                let hash = &value_slice[offset..offset + 32];
+                    let dp_name = String::from_utf8(name.to_vec()).expect("err");
+                    println!("name:{}", dp_name);
 
-                // envoyer un datum request
+                    // envoyer un datum request
-                bigdir_entries.push(hash.try_into().expect("incorrect size"));
+                    dir_entries.push(DirectoryEntry {
-            }
+                        filename: name.try_into().expect("incorrect size"),
+                        content_hash: hash,
+                    });
+                }
 
-            let current = BigDirectoryNode::new(bigdir_entries);
+                let current = DirectoryNode::new(dir_entries);
-            match current {
+                match current {
-                Ok(current_node) => Some((hash_name, MerkleNode::BigDirectory(current_node))),
+                    Ok(current_node) => Some((hash_name, MerkleNode::Directory(current_node))),
-                Err(e) => {
+                    Err(e) => {
-                    println!("{}", e);
+                        println!("{}", e);
-                    None
+                        None
+                    }
                 }
             }
+            BIG => {
+                let mut bigdir_entries: Vec<NodeHash> = Vec::new();
+                let mut offset = 1 as usize;
+                for i in 0..((value_slice.len() - 1) / 32) as u8 {
+                    offset = (1 + 32 * i as usize) as usize;
+                    println!("offset:{}, i:{}", offset, i);
+                    let hash = &value_slice[offset..offset + 32];
+
+                    // envoyer un datum request
+                    bigdir_entries.push(hash.try_into().expect("incorrect size"));
+                }
+
+                println!("its a BIG bro");
+                Some((
+                    hash_name,
+                    MerkleNode::Big(crate::BigNode {
+                        children_hashes: bigdir_entries,
+                    }),
+                ))
+            }
+            BIGDIRECTORY => {
+                let mut bigdir_entries: Vec<NodeHash> = Vec::new();
+                let mut offset = 1 as usize;
+                for i in 0..((value_slice.len() - 1) / 32) as u8 {
+                    offset = (1 + 32 * i as usize) as usize;
+                    println!("offset:{}, i:{}", offset, i);
+                    let hash = &value_slice[offset..offset + 32];
+
+                    // envoyer un datum request
+                    bigdir_entries.push(hash.try_into().expect("incorrect size"));
+                }
+
+                let current = BigDirectoryNode::new(bigdir_entries);
+                match current {
+                    Ok(current_node) => Some((hash_name, MerkleNode::BigDirectory(current_node))),
+                    Err(e) => {
+                        println!("{}", e);
+                        None
+                    }
+                }
+            }
+            _ => None,
         }
-        _ => None,
     }
 }

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 new_id = generate_id();
-                            let rootrequest = construct_message(
+                            let rootrequest =
-                                ROOTREQUEST,
+                                construct_message(ROOTREQUEST, Vec::new(), new_id, crypto_pair);
-                                Vec::new(),
+                            let _ = &guard.insert(new_id, EventType::RootRequest);
-                                generate_id(),
+                            println!("root requesst sent");
-                                crypto_pair,
-                            );
-                            //&guard.insert(, v)
                             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 => {}
@@ -468,7 +468,6 @@ pub fn parse_message(
                         }
                     }
                     EventType::DatumRequestBig => {
-                        let _ = &guard.remove_entry(&id);
                         println!("message {} retiré de la liste", id);
                         let received_length = u16::from_be_bytes(
                             received_message[TYPE..LENGTH]
@@ -481,6 +480,7 @@ pub fn parse_message(
                             parse_received_datum(received_datum.to_vec(), received_length as usize);
                         match parsed_node {
                             Some(tuple) => {
+                                let _ = &guard.remove_entry(&id);
                                 let _ = cmd_tx.send(NetworkEvent::DataReceived(
                                     tuple.0,
                                     tuple.1,
@@ -488,7 +488,9 @@ pub fn parse_message(
                                 ));
                                 println!("datareceived event sent");
                             }
-                            None => {}
+                            None => {
+                                println!("message corrompu, nouvelle tentative");
+                            }
                         }
                     }
                     _ => {}

client-network/src/messages_channels.rs

@@ -234,7 +234,8 @@ pub fn start_retry_thread(
                             );
                             let base: u64 = 2;
 
-                            let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds
+                            // let backoff = base.saturating_pow(attempt as u32); // 2^1 == 2 seconds
+                            let backoff = 1;
                             let newretry = RetryMessage {
                                 next_try: SystemTime::now()
                                     .duration_since(UNIX_EPOCH)
@@ -272,7 +273,7 @@ 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)) => {

client-network/src/registration.rs

@@ -51,6 +51,7 @@ pub fn parse_addresses(input: &String) -> Vec<SocketAddr> {
 ///
 /// registers the IP addresses by sending a Hello request to the server.
 ///
+
 pub async fn perform_handshake(
     sd: &P2PSharedData,
     username: String,
@@ -139,36 +140,3 @@ pub async fn perform_handshake(
     //TODO
     return true;
 }
-
-#[cfg(test)]
-mod tests {
-
-    /*///
-    /// does the procedure to register with the server
-    ///
-    #[tokio::test]
-    async fn registering_with_server() {
-        let username = String::from("gameixtreize");
-        let server_uri = String::from("https://jch.irif.fr:8443");
-        let crypto_pair = CryptographicSignature::new(username);
-        if let Err(e) = register_with_the_server(crypto_pair, server_uri).await {
-            eprintln!("Error during registration: {}", e);
-        }
-    }*/
-
-    /*///
-    /// retreives the socket address of a given peer
-    ///
-    #[tokio::test]
-    async fn retreive_socket_addr() {
-        let username = String::from("ipjkndqfshjldfsjlbsdfjhhj");
-        match get_socket_address(username).await {
-            Ok(body) => {
-                println!("{:?}", body);
-            }
-            Err(e) => {
-                eprintln!("Erreur HTTP: {}", e);
-            }
-        }
-    }*/
-}