working

client-gui/src/gui_app.rs

@@ -4,8 +4,9 @@ use client_network::{
 };
 use crossbeam_channel::{Receiver, Sender};
 use egui::{
-    Align, Align2, Button, CentralPanel, CollapsingHeader, Context, Id, LayerId, Layout, Order,
+    Align, Align2, Button, CentralPanel, CollapsingHeader, Color32, Context, CornerRadius, Frame,
-    Popup, ScrollArea, SidePanel, TextStyle, TopBottomPanel, Ui, ViewportCommand,
+    Id, LayerId, Layout, Order, Popup, Response, ScrollArea, SidePanel, Stroke, TextStyle,
+    TopBottomPanel, Ui, ViewportCommand,
 };
 use std::{collections::HashMap, fmt::format};
 
@@ -43,6 +44,7 @@ pub struct P2PClientApp {
     show_network_popup: bool, // gérer selon besoin
 
     error_message: Option<String>, // Some(message) -> afficher, None -> rien
+    success_message: Option<String>, // Some(message) -> afficher, None -> rien
     //
     active_server: String,
 }
@@ -62,7 +64,7 @@ impl P2PClientApp {
             network_cmd_tx: cmd_tx,
             network_event_rx: event_rx,
             status_message: "Client Initialized. Awaiting network status...".to_string(),
-            known_peers: vec![("bob".to_string(), true)],
+            known_peers: Vec::new(),
             connect_address_input: "https://jch.irif.fr:8443".to_string(),
             connected_address: "".to_string(),
             loaded_fs,
@@ -70,6 +72,7 @@ impl P2PClientApp {
             server_status: ServerStatus::NotConnected,
             show_network_popup: false,
             error_message: None,
+            success_message: None,
             connect_name_input: "bob".to_string(),
             active_server: "".to_string(),
         }
@@ -77,9 +80,15 @@ impl P2PClientApp {
     pub fn show_error(&mut self, msg: impl Into<String>) {
         self.error_message = Some(msg.into());
     }
+    pub fn show_success(&mut self, msg: impl Into<String>) {
+        self.success_message = Some(msg.into());
+    }
     pub fn clear_error(&mut self) {
         self.error_message = None;
     }
+    pub fn clear_success(&mut self) {
+        self.success_message = None;
+    }
 }
 
 // --- eframe::App Trait Implementation ---
@@ -175,6 +184,9 @@ impl eframe::App for P2PClientApp {
                 NetworkEvent::Error(err) => {
                     self.show_error(err);
                 }
+                NetworkEvent::Success(msg) => {
+                    self.show_success(msg);
+                }
                 NetworkEvent::DataReceived(_, merkle_node) => todo!(),
                 NetworkEvent::HandshakeFailed() => {}
                 NetworkEvent::ServerHandshakeFailed(err) => {
@@ -360,13 +372,24 @@ impl eframe::App for P2PClientApp {
                             let is_active =
                                 self.active_peer.as_ref().map_or(false, |id| id == &peer.0); // if peer.id == self.active_peer_id
 
-                            let selectable;
+                            let selectable: Response;
                             if &self.active_server == &peer.0 {
-                                selectable =
+                                // Create a frame with green background and render the selectable inside it.
-                                    ui.selectable_label(is_active, format!("{} 📡 🌀", peer.0))
+                                // Adjust rounding, padding and stroke as desired.
+                                let frame = Frame {
+                                    fill: Color32::DARK_BLUE,
+                                    stroke: Stroke::default(),
+                                    corner_radius: CornerRadius::from(0.5),
+                                    ..Default::default()
+                                };
+                                let internal = frame.show(ui, |ui| {
+                                    ui.selectable_label(is_active, format!("{}", peer.0))
+                                });
+                                selectable = internal.response;
                             } else {
                                 selectable = ui.selectable_label(is_active, format!("{}", peer.0));
                             }
+
                             if selectable.clicked() {
                                 // switch to displaying this peer's tree
                                 self.active_peer = Some(peer.0.clone());
@@ -476,6 +499,20 @@ impl eframe::App for P2PClientApp {
                 });
             ctx.request_repaint();
         }
+        if let Some(msg) = &self.success_message {
+            let msg = msg.clone();
+            egui::Window::new("Success")
+                .collapsible(false)
+                .resizable(false)
+                .anchor(egui::Align2::CENTER_CENTER, [0.0, 0.0])
+                .show(ctx, |ui| {
+                    ui.label(&msg);
+                    if ui.button("OK").clicked() {
+                        self.clear_success();
+                    }
+                });
+            ctx.request_repaint();
+        }
 
         ctx.request_repaint_after(std::time::Duration::from_millis(10));
     }

client-network/src/fetchsocketaddresserror.rs

@@ -0,0 +1,26 @@
+use std::fmt;
+
+#[derive(Debug)]
+pub enum FetchSocketAddressError {
+    NoIPV4Address,
+    NoRegisteredAddresses,
+    NoResponseFromUser,
+    ClientError(String),
+}
+
+impl fmt::Display for FetchSocketAddressError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FetchSocketAddressError::NoIPV4Address => write!(f, "No IPv4 Address registered."),
+            FetchSocketAddressError::NoRegisteredAddresses => {
+                write!(f, "No Registered Addresses found.")
+            }
+            FetchSocketAddressError::NoResponseFromUser => {
+                write!(f, "No Response from user after contact.")
+            }
+            FetchSocketAddressError::ClientError(error) => {
+                write!(f, "Client error : {}", error)
+            }
+        }
+    }
+}

client-network/src/lib.rs

@@ -2,6 +2,7 @@ mod cryptographic_signature;
 mod data;
 mod datum_generation;
 mod datum_parsing;
+mod fetchsocketaddresserror;
 mod message_handling;
 mod messages_channels;
 mod messages_structure;
@@ -9,8 +10,11 @@ mod peers_refresh;
 mod registration;
 mod server_communication;
 mod threads_handling;
+mod timestamp;
 
+use crate::fetchsocketaddresserror::FetchSocketAddressError;
 use crate::peers_refresh::*;
+use crate::timestamp::Timestamp;
 use crate::{
     cryptographic_signature::CryptographicSignature,
     message_handling::EventType,
@@ -21,7 +25,6 @@ use crate::{
     server_communication::{generate_id, get_peer_list},
     threads_handling::Worker,
 };
-use std::str::FromStr;
 use std::{
     io::Error,
     net::{IpAddr, Ipv4Addr, UdpSocket},
@@ -36,6 +39,7 @@ pub struct P2PSharedData {
     shared_socket: Arc<UdpSocket>,
     shared_cryptopair: Arc<CryptographicSignature>,
     shared_messageslist: Arc<Mutex<HashMap<i32, EventType>>>,
+    shared_messagesreceived: Arc<Mutex<HashMap<String, (EventType, Timestamp)>>>,
     shared_senders: Arc<MultipleSenders>,
     server_name: Arc<Mutex<String>>,
     server_address: Arc<Mutex<String>>,
@@ -45,8 +49,7 @@ pub struct P2PSharedData {
 
 use bytes::Bytes;
 use reqwest::Client;
-use tokio::sync::oneshot;
+use tokio::time::sleep;
-use tokio::time::{sleep, timeout};
 
 impl P2PSharedData {
     pub fn new(
@@ -54,12 +57,14 @@ impl P2PSharedData {
         cmd_tx: crossbeam_channel::Sender<NetworkEvent>,
     ) -> Result<P2PSharedData, Error> {
         let messages_list = HashMap::<i32, EventType>::new();
+        let messagesrecv_list = HashMap::<String, (EventType, Timestamp)>::new();
         let username = String::from(username);
         let crypto_pair = CryptographicSignature::new(username);
         let socket = UdpSocket::bind("0.0.0.0:0")?;
         let shared_socket = Arc::new(socket);
         let shared_cryptopair = Arc::new(crypto_pair);
         let shared_messageslist = Arc::new(Mutex::new(messages_list));
+        let shared_messagesreceived = Arc::new(Mutex::new(messagesrecv_list));
 
         let mut threads = Vec::new();
 
@@ -73,6 +78,7 @@ impl P2PSharedData {
             shared_socket: shared_socket,
             shared_cryptopair: shared_cryptopair,
             shared_messageslist: shared_messageslist,
+            shared_messagesreceived: shared_messagesreceived,
             shared_senders: shared_senders,
             server_name: server_name,
             server_address: server_address,
@@ -90,12 +96,21 @@ impl P2PSharedData {
     pub fn messages_list(&self) -> Arc<Mutex<HashMap<i32, EventType>>> {
         self.shared_messageslist.clone()
     }
+    pub fn messages_received(&self) -> Arc<Mutex<HashMap<String, (EventType, Timestamp)>>> {
+        self.shared_messagesreceived.clone()
+    }
     pub fn servername(&self) -> String {
-        let guard = self.server_name.lock().unwrap();
+        let guard = {
+            let maybe_sn = self.server_name.lock().unwrap();
+            maybe_sn.clone()
+        };
         guard.to_string()
     }
     pub fn serveraddress(&self) -> String {
-        let guard = self.server_address.lock().unwrap();
+        let guard = {
+            let maybe_sn = self.server_address.lock().unwrap();
+            maybe_sn.clone()
+        };
         guard.to_string()
     }
     pub fn set_servername(&self, new: String) {
@@ -123,6 +138,10 @@ impl P2PSharedData {
         &*self.shared_messageslist
     }
 
+    pub fn messages_received_ref(&self) -> &Mutex<HashMap<String, (EventType, Timestamp)>> {
+        &*self.shared_messagesreceived
+    }
+
     pub fn senders_ref(&self) -> &MultipleSenders {
         &*self.shared_senders
     }
@@ -167,6 +186,7 @@ pub enum NetworkEvent {
     ConnectedHandshake(),
     Disconnected(),
     Error(String),
+    Success(String),
     PeerConnected(String),
     PeerListUpdated(Vec<(String, bool)>),
     FileTreeReceived([u8; 32], MerkleNode), // peer_id, content
@@ -348,6 +368,7 @@ pub fn start_p2p_executor(
                         }*/
                     }
                     NetworkCommand::FetchPeerList(ip) => {
+                        println!("[Network] FetchPeerList() called");
                         if ip == "" {
                             let res = event_tx.send(NetworkEvent::Error(
                                 "Not registered to any server".to_string(),
@@ -377,12 +398,12 @@ pub fn start_p2p_executor(
                                 Err(e) => println!("error"),
                             }
                         }
-                        println!("[Network] FetchPeerList() called");
                     }
                     NetworkCommand::RegisterAsPeer(_) => {
                         println!("[Network] RegisterAsPeer() called");
                     }
                     NetworkCommand::Ping(str, ip) => {
+                        println!("[Network] Ping({}) called", str);
                         if let Some(sd) = shared_data.as_ref() {
                             let id = generate_id();
                             sd.add_message(id, EventType::Ping);
@@ -391,35 +412,51 @@ pub fn start_p2p_executor(
                             let peer_address =
                                 get_socket_address(str, ip, shared_data.as_ref()).await;
                             match peer_address {
-                                Some(addr) => {
+                                Ok(addr) => {
-                                    if let Some(ping) = pingrequest {
+                                    //if let Some(ping) = pingrequest {
-                                        sd.senders_ref().add_message_to_retry_queue(
+                                    //    sd.senders_ref().add_message_to_retry_queue(
-                                            ping.clone(),
+                                    //        ping.clone(),
-                                            addr.to_string(),
+                                    //        addr.to_string(),
-                                            false,
+                                    //        false,
-                                        );
+                                    //    );
-                                        sd.senders_ref().send_dispatch(
+                                    //    sd.senders_ref().send_dispatch(
-                                            ping,
+                                    //        ping,
-                                            addr.to_string(),
+                                    //        addr.to_string(),
-                                            false,
+                                    //        false,
-                                            sd.messages_list(),
+                                    //        sd.messages_list(),
-                                        );
+                                    //    );
+                                    //}
+                                    match event_tx.send(NetworkEvent::Success(format!(
+                                        "Successfully sent ping message to {}.",
+                                        addr.to_string()
+                                    ))) {
+                                        Ok(_) => {}
+                                        Err(e) => {
+                                            eprintln!("NetworkEvent error : {}", e);
+                                        }
+                                    };
+                                }
+                                Err(err_msg) => {
+                                    match event_tx.send(NetworkEvent::Error(err_msg.to_string())) {
+                                        Ok(_) => {}
+                                        Err(e) => {
+                                            eprintln!("NetworkEvent error : {}", e);
                                         }
                                     }
-                                None => {
-                                    let err_msg =
-                                        format!("failed to retreive socket address:").to_string();
-                                    let res = event_tx.send(NetworkEvent::Error(err_msg));
                                 }
                             }
                         }
-                        println!("[Network] Ping() called");
                     }
                     NetworkCommand::Disconnect() => {
                         if let Some(sd) = shared_data.as_ref() {
                             println!("Disconnecting: {}", &sd.cryptopair().username);
                             shared_data = None;
-                            let res = event_tx.send(NetworkEvent::Disconnected());
+                            match event_tx.send(NetworkEvent::Disconnected()) {
+                                Ok(_) => {}
+                                Err(e) => {
+                                    eprintln!("NetworkEvent error : {}", e);
+                                }
+                            }
                         } else {
                             println!("no p2p data");
                         }
@@ -443,7 +480,7 @@ pub fn start_p2p_executor(
                             );
 
                             match peer_addr_query.await {
-                                Some(peer_addr) => {
+                                Ok(peer_addr) => {
                                     let payload = socket_addr_to_vec(peer_addr);
 
                                     print!("{:?}", payload.clone());
@@ -466,10 +503,13 @@ pub fn start_p2p_executor(
                                         sd.messages_list(),
                                     );
                                 }
-                                None => {
+                                Err(err_msg) => {
-                                    let err_msg =
+                                    match event_tx.send(NetworkEvent::Error(err_msg.to_string())) {
-                                        format!("failed to retreive socket address").to_string();
+                                        Ok(_) => {}
-                                    let res = event_tx.send(NetworkEvent::Error(err_msg));
+                                        Err(e) => {
+                                            eprintln!("NetworkEvent error : {}", e);
+                                        }
+                                    }
                                 }
                             }
                         }
@@ -483,7 +523,7 @@ pub fn start_p2p_executor(
             // event_tx.send(NetworkEvent::PeerConnected("NewPeerID".to_string())).unwrap();
 
             // Avoid spinning too fast
-            tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+            sleep(std::time::Duration::from_millis(50)).await;
         }
     })
 }
@@ -514,7 +554,7 @@ fn parse_pack(s: &str) -> Option<[u8; 6]> {
 }
 
 async fn quick_ping(addr: &SocketAddr, timeout_ms: u64, sd: &P2PSharedData) -> bool {
-    let id = 42069;
+    let id = generate_id();
     let pingreq = construct_message(PING, Vec::new(), id, &sd.shared_cryptopair);
 
     if let Some(ping) = pingreq {
@@ -525,7 +565,15 @@ async fn quick_ping(addr: &SocketAddr, timeout_ms: u64, sd: &P2PSharedData) -> b
 
     sleep(Duration::from_millis(timeout_ms)).await;
 
-    !sd.messages_list().lock().expect("yooo").contains_key(&id)
+    let msg_list = sd.messages_list_ref().lock().expect("yooo");
+    let res = !msg_list.contains_key(&id);
+
+    for (id, evt) in msg_list.iter() {
+        println!("id : {}, evt : {}", id, evt.to_string());
+    }
+    println!("message list doesnt contain key? {}", res);
+
+    res
 }
 
 ///
@@ -536,24 +584,20 @@ pub async fn get_socket_address(
     username: String,
     ip: String,
     shared_data: Option<&P2PSharedData>,
-) -> Option<SocketAddr> {
+) -> Result<SocketAddr, FetchSocketAddressError> {
     let sd = shared_data.expect("No shared data");
 
     let client = match Client::builder().timeout(Duration::from_secs(5)).build() {
         Ok(c) => c,
         Err(e) => {
-            eprintln!("Failed to build HTTP client: {}", e);
+            return Err(FetchSocketAddressError::ClientError(e.to_string()));
-            return None;
         }
     };
 
     let uri = format!("{}/peers/{}/addresses", ip, username);
     let res = match client.get(&uri).send().await {
         Ok(r) => r,
-        Err(e) => {
+        Err(e) => return Err(FetchSocketAddressError::ClientError(e.to_string())),
-            eprintln!("HTTP request error: {}", e);
-            return None;
-        }
     };
 
     if res.status().is_success() {
@@ -568,29 +612,30 @@ pub async fn get_socket_address(
     let body = match res.bytes().await {
         Ok(b) => b,
         Err(e) => {
-            eprintln!("Failed to read response body: {}", e);
+            return Err(FetchSocketAddressError::ClientError(e.to_string()));
-            return None;
         }
     };
 
     let s = match String::from_utf8(body.to_vec()) {
         Ok(st) => st,
         Err(e) => {
-            eprintln!("Response not valid UTF-8: {}", e);
+            return Err(FetchSocketAddressError::ClientError(e.to_string()));
-            return None;
         }
     };
 
     let addresses = parse_addresses(&s); // assumes parse_addresses: &str -> Vec<SocketAddr>
+    if addresses.is_empty() {
+        return Err(FetchSocketAddressError::NoRegisteredAddresses);
+    } else if !addresses.iter().any(|a| matches!(a, SocketAddr::V4(_))) {
+        return Err(FetchSocketAddressError::NoIPV4Address);
+    }
 
     for addr in addresses {
         println!("trying address : {}", addr);
-        if quick_ping(&addr, 10000, sd).await {
+        if quick_ping(&addr, 5000, sd).await {
-            return Some(addr);
+            return Ok(addr);
         }
 
-        // TODO: nat_traversal(&addr).await;
-        // after NAT traversal attempt, ping again
         let payload = socket_addr_to_vec(addr);
         let id = generate_id();
 
@@ -604,12 +649,27 @@ pub async fn get_socket_address(
             sd.messages_list(),
         );
 
-        if quick_ping(&addr, 15000, sd).await {
+        sleep(Duration::from_millis(5000)).await;
-            return Some(addr);
+
+        let maybe_entry = {
+            let guard = sd.messages_received_ref().lock().unwrap();
+            guard.clone()
+        }; // guard dropped
+
+        for (id, (evt, time)) in maybe_entry.iter() {
+            println!("{} : {} at {}", id, evt.to_string(), time.to_string());
+            if id.eq(&addr.to_string()) && Timestamp::now().diff(time) < 10 {
+                println!("received message from address, returning said address..");
+                return Ok(addr);
             }
         }
 
-    None
+        if quick_ping(&addr, 15000, sd).await {
+            return Ok(addr);
+        }
+    }
+
+    Err(FetchSocketAddressError::NoResponseFromUser)
 }
 
 pub async fn get_server_address(username: String, ip: String) -> Option<SocketAddr> {

client-network/src/message_handling.rs

@@ -11,9 +11,11 @@ use crate::{
     peers_refresh::HandshakeHistory,
     registration,
     server_communication::generate_id,
+    timestamp::Timestamp,
 };
 use std::{
     collections::HashMap,
+    default,
     net::{Ipv4Addr, SocketAddr},
 };
 use std::{
@@ -22,7 +24,7 @@ use std::{
 };
 
 // Types of messages that await for a response
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum EventType {
     HelloThenRootRequest,
     Hello,
@@ -30,6 +32,32 @@ pub enum EventType {
     Ping,
     NatTraversal,
     DatumRequest,
+    Unknown,
+}
+
+impl EventType {
+    pub fn to_string(&self) -> String {
+        match self {
+            EventType::HelloThenRootRequest => "HelloThenRootRequest".to_owned(),
+            EventType::Hello => "Hello".to_owned(),
+            EventType::RootRequest => "RootRequest".to_owned(),
+            EventType::Ping => "Ping".to_owned(),
+            EventType::NatTraversal => "NatTraversal".to_owned(),
+            EventType::DatumRequest => "DatumRequest".to_owned(),
+            EventType::Unknown => "Unknown".to_owned(),
+        }
+    }
+
+    pub fn from_msgtype(msgtype: u8) -> EventType {
+        match msgtype {
+            PING => EventType::Ping,
+            HELLO => EventType::Hello,
+            ROOTREQUEST => EventType::RootRequest,
+            NATTRAVERSALREQUEST => EventType::NatTraversal,
+            DATUMREQUEST => EventType::DatumRequest,
+            _ => EventType::Unknown,
+        }
+    }
 }
 
 const ID: usize = 4;
@@ -53,6 +81,7 @@ const NATTRAVERSALREQUEST2: u8 = 5;
 
 pub fn handle_recevied_message(
     messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
+    messages_received: &Arc<Mutex<HashMap<String, (EventType, Timestamp)>>>,
     recevied_message: &Vec<u8>,
     crypto_pair: &CryptographicSignature,
     //socket_addr: &SocketAddr,
@@ -91,6 +120,7 @@ pub fn handle_recevied_message(
         cmd_tx,
         ip,
         messages_list,
+        messages_received,
         handhsake_history,
         senders,
     );
@@ -116,6 +146,7 @@ pub fn parse_message(
     cmd_tx: crossbeam_channel::Sender<NetworkEvent>,
     ip: SocketAddr,
     messages_list: &Arc<Mutex<HashMap<i32, EventType>>>,
+    messages_received: &Arc<Mutex<HashMap<String, (EventType, Timestamp)>>>,
     handhsake_history: Arc<HandshakeHistory>,
     senders: &MultipleSenders,
 ) -> Option<Vec<u8>> {
@@ -127,6 +158,14 @@ pub fn parse_message(
 
     let msgtype = received_message[ID];
 
+    messages_received
+        .lock()
+        .expect("couldnt lock received map")
+        .insert(
+            ip.to_string(),
+            (EventType::from_msgtype(msgtype), Timestamp::now()),
+        );
+
     let length_bytes: [u8; 2] = received_message[TYPE..LENGTH]
         .try_into()
         .expect("Taille incorrecte");

client-network/src/messages_channels.rs

@@ -269,6 +269,7 @@ pub fn start_receving_thread(
     let cryptopair_clone = shared_data.cryptopair();
     let senders_clone = shared_data.senders();
     let messages_clone = shared_data.messages_list();
+    let messages_received_clone = shared_data.messages_received();
     let servername_clone = shared_data.servername();
     let thread = thread::spawn(move || {
         let mut buf = [0u8; 1024];
@@ -280,6 +281,7 @@ pub fn start_receving_thread(
                     println!("Reçu {} octets de {}: {:?}", amt, src, received_data);
                     handle_recevied_message(
                         &messages_clone,
+                        &messages_received_clone,
                         &received_data,
                         &cryptopair_clone,
                         &senders_clone,

client-network/src/timestamp.rs

@@ -0,0 +1,46 @@
+use std::time::{SystemTime, UNIX_EPOCH};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Timestamp {
+    secs: u64, // seconds since UNIX epoch
+}
+
+unsafe impl Send for Timestamp {}
+
+impl Timestamp {
+    // Create a Timestamp from current system time
+    pub fn now() -> Self {
+        let dur = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time before UNIX_EPOCH");
+        Self {
+            secs: dur.as_secs(),
+        }
+    }
+
+    // Create from explicit fields (optional helper)
+    pub fn from_secs(secs: u64) -> Self {
+        Self { secs }
+    }
+
+    // Return underlying seconds
+    pub fn as_secs(&self) -> u64 {
+        self.secs
+    }
+
+    // Return elapsed seconds between `self` and `other`.
+    // Panics if `other` is in the future relative to `self`.
+    // If you call `Timestamp::now().diff(past)`, it returns seconds since `past`.
+    pub fn diff(&self, earlier: &Timestamp) -> u64 {
+        assert!(earlier.secs <= self.secs, "given time is in the future");
+        self.secs - earlier.secs
+    }
+
+    pub fn to_string(&self) -> String {
+        let secs_of_day = self.secs % 86_400;
+        let hh = secs_of_day / 3600;
+        let mm = (secs_of_day % 3600) / 60;
+        let ss = secs_of_day % 60;
+        format!("{:02}:{:02}:{:02}", hh, mm, ss)
+    }
+}