big download fixed

client-gui/src/gui_app.rs

@@ -5,9 +5,8 @@ use client_network::{
 };
 use crossbeam_channel::{Receiver, Sender};
 use egui::{
-    Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Layout,
+    Align, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame, Layout, Response,
-    ProgressBar, Response, ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, Vec2,
+    ScrollArea, SidePanel, Stroke, TopBottomPanel, Ui, ViewportCommand,
-    ViewportCommand,
 };
 use std::collections::HashSet;
 use std::{collections::HashMap, fmt::format, io::Seek};
@@ -55,13 +54,6 @@ pub struct P2PClientApp {
 
     current_downloading_file_map: MerkleTree,
     remaining_chunks: HashSet<[u8; 32]>,
-
-    // total number of chunks expected for the current download (set when download starts)
-    current_total_chunks: Option<usize>,
-
-    // number of chunks received so far (count of removed remaining_chunks)
-    current_received_chunks: usize,
-
     root_downloading_file: String,
 }
 
@@ -95,8 +87,6 @@ impl P2PClientApp {
             active_server: "".to_string(),
             shared_tree: generate_base_tree(),
             current_downloading_file_map: current_downloading_file_map,
-            current_total_chunks: None,
-            current_received_chunks: 0,
             root_downloading_file: "".to_string(),
             remaining_chunks: HashSet::new(),
         }
@@ -113,14 +103,6 @@ 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
-    }
 }
 
 // --- eframe::App Trait Implementation ---
@@ -280,6 +262,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
@@ -309,7 +292,6 @@ impl eframe::App for P2PClientApp {
                                     true,
                                 ));
                                 self.remaining_chunks.insert(entry);
-                                self.set_current_total_chunks(Some(self.remaining_chunks.len()));
                             }
                             self.remaining_chunks.remove(&hash);
                         }
@@ -318,18 +300,12 @@ 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() {
-                        /*let file = OpenOptions::new()
+                        let file = OpenOptions::new().append(true).create(true).open(
-                            .append(true)
+                            "./Download/".to_string()
-                            .create(true)
+                                + &remove_null_bytes(&self.root_downloading_file.clone()),
-                            .open(self.root_downloading_file.clone());
+                        );
 
                         if let Some(current) = self
                             .current_downloading_file_map
@@ -348,10 +324,10 @@ impl eframe::App for P2PClientApp {
                                     eprintln!("error creaation file: {}", e);
                                 }
                             }
-                        }*/
+                        } else {
-                        self.current_total_chunks = None;
+                            eprintln!("error root absent");
-                        self.current_received_chunks = 0;
+                        }
-                        println!("bigfile téléchargé");
+                        println!("bigfile téléchargé {}", self.root_downloading_file);
                     }
                 }
                 NetworkEvent::Success(msg, peer_username) => {
@@ -431,35 +407,26 @@ impl eframe::App for P2PClientApp {
         TopBottomPanel::bottom("bottom_panel").show(ctx, |ui| {
             ui.horizontal(|ui| {
                 match self.server_status {
-                    ServerStatus::Loading => ui.spinner(),
+                    ServerStatus::Loading => {
-                    ServerStatus::Connected => ui.label("Registered but no server peer chosen..."),
+                        ui.spinner();
-                    ServerStatus::NotConnected => ui.label("No connection.."),
-                    ServerStatus::ConnectedHandshake => ui.label("📡"),
-                };
-
-                ui.add_space(8.0); // small gap
-
-                // desired progress bar width
-                let bar_width = 220.0f32;
-                // push it to the right by adding space equal to remaining width minus bar width
-                let push = (ui.available_width() - bar_width).max(0.0);
-                ui.add_space(push);
-
-                if let Some(total) = self.current_total_chunks {
-                    let received = self.current_received_chunks;
-                    let frac = if total == 0 {
-                        1.0
-                    } else {
-                        received as f32 / total as f32
-                    };
-
-                    ui.add(
-                        ProgressBar::new(frac)
-                            .show_percentage()
-                            .animate(true)
-                            .desired_height(10.0),
-                    );
                     }
+                    ServerStatus::Connected => {
+                        ui.label("Registered but no server peer chosen...");
+                    }
+                    ServerStatus::NotConnected => {
+                        ui.label("No connection..");
+                    }
+                    ServerStatus::ConnectedHandshake => {
+                        let str = format!("📡");
+                        ui.label(str);
+                    }
+                }
+                ui.add_space(ui.available_width() - 30.0);
+                // formater mm:ss
+                let secs = self.remaining.as_secs();
+                let minutes = secs / 60;
+                let seconds = secs % 60;
+                ui.label(format!("{:02}:{:02}", minutes, seconds));
             });
         });
 
@@ -490,11 +457,7 @@ impl eframe::App for P2PClientApp {
                 });
 
                 ui.separator();
-                ScrollArea::vertical()
+                ScrollArea::vertical().show(ui, |ui| {
-                    .auto_shrink([false; 2])
-                    .show(ui, |ui| {
-                        ui.style_mut().visuals.widgets.inactive.bg_fill =
-                            ui.style().visuals.widgets.inactive.bg_fill; // no-op to get mutable borrow
                     if self.known_peers.is_empty() {
                         ui.add_space(10.0);
                         ui.label("No active peers.");
@@ -546,10 +509,7 @@ impl eframe::App for P2PClientApp {
                                     };
                                     frame
                                         .show(ui, |ui| {
-                                                ui.selectable_label(
+                                            ui.selectable_label(is_active, format!("{}", peer.0))
-                                                    is_active,
-                                                    format!("{}", peer.0),
-                                                )
                                         })
                                         .inner
                                 } else {
@@ -560,12 +520,9 @@ impl eframe::App for P2PClientApp {
 
                                 if self.loading_peers.contains(&peer.0) {
                                     // push spinner to right by expanding a spacer before it
-                                        ui.with_layout(
+                                    ui.with_layout(Layout::right_to_left(Align::Center), |ui| {
-                                            Layout::right_to_left(Align::Center),
-                                            |ui| {
                                         ui.spinner();
-                                            },
+                                    });
-                                        );
                                 }
 
                                 // use resp (click handling etc.)
@@ -578,8 +535,7 @@ impl eframe::App for P2PClientApp {
                                         .contains_key(self.active_peer.as_ref().unwrap())
                                     {
                                         //todo!();
-                                            let _ =
+                                        let _ = self.network_cmd_tx.send(NetworkCommand::Discover(
-                                                self.network_cmd_tx.send(NetworkCommand::Discover(
                                             peer.0.clone(),
                                             "root".to_string(),
                                             self.connected_address.clone(),
@@ -722,17 +678,13 @@ impl eframe::App for P2PClientApp {
             ui.separator();
 
             if let Some(active_peer) = &self.active_peer {
-                if let Some(tree) = self.loaded_fs.clone().get(active_peer) {
+                if let Some(tree) = self.loaded_fs.get(active_peer) {
                     ScrollArea::vertical().show(ui, |ui| {
                         // Start drawing the tree from the root hash
                         self.draw_file_tree(ui, tree);
                     });
                 } else {
-                    ui.horizontal(|ui| {
                     ui.label(format!("Loading root for peer: {}", active_peer));
-                        ui.add_space(8.0);
-                        ui.spinner(); // or conditional: if is_loading { ui.spinner(); }
-                    });
                 }
             } else {
                 ui.label("Connect to a peer to view a file tree.");
@@ -782,7 +734,7 @@ impl eframe::App for P2PClientApp {
 // --- Helper for Drawing the Recursive File Tree ---
 
 impl P2PClientApp {
-    fn draw_file_tree(&mut self, ui: &mut Ui, tree: &MerkleTree) {
+    fn draw_file_tree(&self, ui: &mut Ui, tree: &MerkleTree) {
         assert!(self.active_peer.is_some());
         assert!(
             self.loaded_fs
@@ -799,7 +751,7 @@ impl P2PClientApp {
     }
 
     fn draw_file_node(
-        &mut self,
+        &self,
         ui: &mut Ui,
         to_draw: NodeHash,
         tree: &MerkleTree,

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,9 +11,27 @@ 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!(
+        "((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_slice.clone());
+
+    // Obtention du résultat
+    let result = hasher.finalize();
+    if result.to_vec() != hash_name.to_vec() {
+        println!("{:?},{:?}", result.to_vec(), hash_name.to_vec());
+        None
+    } else {
+        println!("hashes equals!");
         let datum_type = value_slice[0];
         match datum_type {
             CHUNK => Some((
@@ -91,4 +109,5 @@ pub fn parse_received_datum(
             }
             _ => 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()));
@@ -340,53 +340,9 @@ pub fn start_p2p_executor(
                                 sd.messages_list(),
                                 sd.handshake_peers.get_username_peerinfo_map(),
                             );
-                            let server_address = {
-                                match get_server_address(username.to_owned(), ip.to_owned()).await {
-                                    Some(addr) => addr.to_string(),
-                                    None => {
-                                        match event_tx.send(NetworkEvent::Error(
-                                            "Couldn't fetch server socket address.".to_owned(),
-                                            username.to_owned(),
-                                        )) {
-                                            Ok(_) => {}
-                                            Err(e) => {
-                                                println!("Network Event Error : {}", e.to_string());
-                                            }
-                                        }
-                                        "".to_owned()
-                                    }
-                                }
-                            };
-                            if server_address.to_owned().eq(&"".to_owned()) {
-                                continue;
-                            }
 
-                            sd.set_servername(username.to_owned());
+                            let res =
-                            sd.set_serveraddress(server_address.to_string());
+                                perform_handshake(&sd, username, ip, event_tx.clone(), true).await;
-                            println!("SET SERVERADDRESS");
-
-                            match perform_handshake(
-                                &sd,
-                                username.to_owned(),
-                                ip,
-                                event_tx.clone(),
-                                (true, server_address.to_string()),
-                            )
-                            .await
-                            {
-                                true => {
-                                    match event_tx.send(NetworkEvent::Success(
-                                        "Handshake established ✔️".to_string(),
-                                        username.to_owned(),
-                                    )) {
-                                        Ok(_) => {}
-                                        Err(err) => {
-                                            println!("Network Event Error : {}", err.to_string());
-                                        }
-                                    };
-                                }
-                                false => {}
-                            };
                         } else {
                             println!("no shared data");
                         }
@@ -404,9 +360,7 @@ pub fn start_p2p_executor(
                     NetworkCommand::Discover(username, hash, ip) => {
                         // envoie un handshake au peer, puis un root request
                         if let Some(sd) = shared_data.as_ref() {
-                            let res = sd
+                            let res = sd.handshake_peers.get_peer_info_username(username.clone());
-                                .handshake_peers
-                                .get_peer_info_username(username.to_owned());
                             match res {
                                 Some(peerinfo) => {
                                     let id = generate_id();
@@ -441,31 +395,14 @@ pub fn start_p2p_executor(
                                 }
                                 None => {
                                     // envoyer un handshake
-                                    match perform_handshake(
+                                    let res = perform_handshake(
                                         &sd,
-                                        username.to_owned(),
+                                        username,
                                         ip,
                                         event_tx.clone(),
-                                        (false, "".to_string()),
+                                        false,
                                     )
-                                    .await
+                                    .await;
-                                    {
-                                        true => {
-                                            match event_tx.send(NetworkEvent::Success(
-                                                "Handshake established ✔️".to_string(),
-                                                username.to_owned(),
-                                            )) {
-                                                Ok(_) => {}
-                                                Err(err) => {
-                                                    println!(
-                                                        "Network Event Error : {}",
-                                                        err.to_string()
-                                                    );
-                                                }
-                                            };
-                                        }
-                                        false => {}
-                                    }
                                 }
                             }
                         } else {
@@ -819,16 +756,7 @@ pub async fn get_socket_address(
         }
     };
 
-    let addresses: Vec<SocketAddr> = {
+    let addresses = parse_addresses(&s); // assumes parse_addresses: &str -> Vec<SocketAddr>
-        let temp = parse_addresses(&s);
-        temp.iter()
-            .filter_map(|a| match a {
-                SocketAddr::V4(_) => Some(*a),
-                SocketAddr::V6(_) => None,
-            })
-            .collect()
-    };
-
     if addresses.is_empty() {
         return Err(FetchSocketAddressError::NoRegisteredAddresses);
     } else if !addresses.iter().any(|a| matches!(a, SocketAddr::V4(_))) {

client-network/src/message_handling.rs

@@ -314,7 +314,7 @@ pub fn parse_message(
 
         ERROR => {
             if let Ok(err_received) =
-                String::from_utf8(received_message[LENGTH..(msg_length + LENGTH)].to_vec())
+                String::from_utf8(received_message[LENGTH..(msg_length + LENGTH + 4)].to_vec())
             {
                 let err_msg = format!("Error received from peer {} : {}", ip, err_received);
                 let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg, "".to_owned()));
@@ -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

@@ -2,7 +2,6 @@ use crate::NetworkEvent;
 use crate::P2PSharedData;
 use crate::cryptographic_signature::CryptographicSignature;
 use crate::get_server_address;
-use crate::get_socket_address;
 use crate::message_handling::EventType;
 use crate::messages_structure::construct_message;
 use crate::server_communication::generate_id;
@@ -56,50 +55,27 @@ pub async fn perform_handshake(
     username: String,
     ip: String,
     event_tx: Sender<NetworkEvent>,
-    is_server_handshake: (bool, String),
+    is_server_handshake: bool,
-) -> bool {
+) {
     println!("username: {}, ip: {}", username.clone(), ip.clone());
     let crypto_pair = sd.cryptopair_ref();
     let senders = sd.senders_ref();
 
     let id = generate_id();
-
+    let server_addr_query = get_server_address(username.clone(), ip.clone());
-    let address = {
+    match server_addr_query.await {
-        if is_server_handshake.0 {
+        Some(sockaddr_bytes) => {
-            is_server_handshake.1
+            sd.set_servername(username);
-        } else {
+            // first: &SocketAddr
-            let server_addr_query =
-                get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
-
-            match server_addr_query {
-                Ok(sockaddr_bytes) => sockaddr_bytes.to_string(),
-                Err(err_msg) => {
-                    match event_tx.send(NetworkEvent::Error(
-                        err_msg.to_string(),
-                        username.to_owned(),
-                    )) {
-                        Ok(_) => {}
-                        Err(err) => {
-                            println!("Network Event Error : {}", err.to_string());
-                        }
-                    }
-                    "".to_string()
-                }
-            }
-        }
-    };
-
-    if address.eq(&"".to_string()) {
-        return false;
-    }
-
             let mut payload = Vec::new();
             payload.extend_from_slice(&0u32.to_be_bytes());
             payload.extend_from_slice(&crypto_pair.username.clone().as_bytes());
             let hello_handshake = construct_message(1, payload, id, crypto_pair);
-    if is_server_handshake.0 {
+            if is_server_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);
             }
 
@@ -107,19 +83,19 @@ pub async fn perform_handshake(
                 Some(handshake_message) => {
                     senders.send_dispatch(
                         handshake_message,
-                address,
+                        sockaddr_bytes.to_string(),
-                is_server_handshake.0,
+                        is_server_handshake,
                         sd.messages_list(),
                     );
                 }
                 None => {}
             }
-
+        }
-    //let server_addr_query = get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
+        None => {
-    //match server_addr_query {
+            let err_msg = format!("failed to retreive socket address:").to_string();
-    //    Ok(sockaddr_bytes) => {}
+            let res = event_tx.send(NetworkEvent::Error(err_msg, "".to_owned()));
-    //    Err(err_msg) => {}
+        }
-    //}
+    }
 
     /*let mut list = messages_list.lock().expect("Failed to lock messages_list");
     match list.get(&id) {
@@ -137,7 +113,6 @@ pub async fn perform_handshake(
     let hello_handshake_received = UDPMessage::parse(buf.to_vec());
     hello_handshake_received.display();*/
     //TODO
-    return true;
 }
 
 #[cfg(test)]