From 8e279d9e247476345d3f60a1f7c77aa75e7b2df2 Mon Sep 17 00:00:00 2001 From: wikano Date: Sun, 11 Jan 2026 22:12:08 +0100 Subject: [PATCH 1/3] wip datum --- client-network/src/data.rs | 19 ++++-- client-network/src/datum_parsing.rs | 97 ++++++++++++++++++++++++++++- 2 files changed, 110 insertions(+), 6 deletions(-) diff --git a/client-network/src/data.rs b/client-network/src/data.rs index edf9400..b6c8f9b 100644 --- a/client-network/src/data.rs +++ b/client-network/src/data.rs @@ -208,7 +208,7 @@ impl ChunkNode { // Helper struct #[derive(Debug, Clone)] pub struct DirectoryEntry { - pub filename: [u8; FILENAME_HASH_SIZE], + pub filename: Vec, pub content_hash: NodeHash, } @@ -240,7 +240,7 @@ pub struct BigNode { } impl BigNode { - pub fn new(children_hashes: Vec) -> Result { + /*pub fn new(children_hashes: Vec) -> Result { let n = children_hashes.len(); if n < MIN_BIG_CHILDREN || n > MAX_BIG_CHILDREN { return Err(format!( @@ -249,16 +249,17 @@ impl BigNode { )); } Ok(BigNode { children_hashes }) - } + }*/ } #[derive(Debug, Clone)] pub struct BigDirectoryNode { - pub children_hashes: Vec, + //pub children_hashes: Vec, + pub children_hashes: Vec, } impl BigDirectoryNode { - pub fn new(children_hashes: Vec) -> Result { + /*pub fn new(children_hashes: Vec) -> Result { let n = children_hashes.len(); if n < MIN_BIG_CHILDREN || n > MAX_BIG_CHILDREN { return Err(format!( @@ -267,6 +268,14 @@ impl BigDirectoryNode { )); } Ok(BigDirectoryNode { children_hashes }) + }*/ + pub fn new(entries: Vec) -> Result { + if entries.len() > MAX_DIRECTORY_ENTRIES { + return Err(format!("Directory exceeds {} bytes", entries.len())); + } + Ok(BigDirectoryNode { + children_hashes: entries, + }) } } diff --git a/client-network/src/datum_parsing.rs b/client-network/src/datum_parsing.rs index 0ed934a..aff0dde 100644 --- a/client-network/src/datum_parsing.rs +++ b/client-network/src/datum_parsing.rs @@ -1 +1,96 @@ -fn parse_received_datum(recevied_datum: Vec) {} +use crate::{BigDirectoryNode, DirectoryEntry, DirectoryNode, MerkleNode, MerkleTree, NodeHash}; +use sha2::{Digest, Sha256}; + +const CHUNK: u8 = 0; +const DIRECTORY: u8 = 1; +const BIG: u8 = 2; +const BIGDIRECTORY: u8 = 3; + +fn parse_received_datum(recevied_datum: Vec, datum_length: usize, mut tree: MerkleTree) { + if datum_length > recevied_datum.len() { + return; + } + if datum_length < 32 + 64 { + return; + } + let hash_name: [u8; 32] = recevied_datum[..32].try_into().expect("error"); + let sigstart = datum_length - 64; + let value = &recevied_datum[32..sigstart]; + let value_slice = value.to_vec(); + let signature: [u8; 32] = recevied_datum[sigstart..datum_length] + .try_into() + .expect("Taille incorrecte"); + let datum_type = value_slice[0]; + match datum_type { + CHUNK => { + tree.data.insert( + hash_name, + MerkleNode::Chunk(crate::ChunkNode { data: value_slice }), + ); + } + DIRECTORY => { + let nb_entries = value_slice[1]; + let mut dir_entries = Vec::new(); + let mut offset = 1 as usize; + for i in 0..nb_entries { + offset = (offset as u8 + 64 * i) as usize; + let name = &recevied_datum[offset..offset + 32]; + let mut hash = [0u8; 32]; + hash.copy_from_slice(&recevied_datum[offset + 32..offset + 64]); + // envoyer un datum request + dir_entries.push(DirectoryEntry { + filename: name.to_vec(), + content_hash: hash, + }); + } + + let current = DirectoryNode::new(dir_entries); + match current { + Ok(current_node) => { + tree.data + .insert(hash_name, MerkleNode::Directory(current_node)); + } + Err(e) => { + println!("{}", e); + } + } + } + BIG => { + let chlidren: Vec = Vec::new(); + tree.data.insert( + hash_name, + MerkleNode::Big(crate::BigNode { + children_hashes: chlidren, + }), + ); + } + BIGDIRECTORY => { + let nb_entries = value_slice[1]; + let mut dir_entries = Vec::new(); + let mut offset = 1 as usize; + for i in 0..nb_entries { + offset = (offset as u8 + 64 * i) as usize; + let name = &recevied_datum[offset..offset + 32]; + let mut hash = [0u8; 32]; + hash.copy_from_slice(&recevied_datum[offset + 32..offset + 64]); + // envoyer un datum request + dir_entries.push(DirectoryEntry { + filename: name.to_vec(), + content_hash: hash, + }); + } + + let current = BigDirectoryNode::new(dir_entries); + match current { + Ok(current_node) => { + tree.data + .insert(hash_name, MerkleNode::BigDirectory(current_node)); + } + Err(e) => { + println!("{}", e); + } + } + } + _ => {} + } +} From 98fcc1a0b2da033e046fd5c66f58da1a095e03cb Mon Sep 17 00:00:00 2001 From: wikano Date: Tue, 13 Jan 2026 02:32:48 +0100 Subject: [PATCH 2/3] wip handling root request --- client-gui/src/gui_app.rs | 55 +++++---- client-network/src/data.rs | 18 +-- client-network/src/lib.rs | 78 ++++--------- client-network/src/message_handling.rs | 83 +++++++++++--- client-network/src/messages_channels.rs | 140 ++++++++++++----------- client-network/src/messages_structure.rs | 6 +- client-network/src/peers_refresh.rs | 120 +++++++++++++------ client-network/src/registration.rs | 75 +++++++++--- 8 files changed, 356 insertions(+), 219 deletions(-) diff --git a/client-gui/src/gui_app.rs b/client-gui/src/gui_app.rs index df02138..39bb3a5 100644 --- a/client-gui/src/gui_app.rs +++ b/client-gui/src/gui_app.rs @@ -49,11 +49,11 @@ pub struct P2PClientApp { impl P2PClientApp { pub fn new(cmd_tx: Sender, event_rx: Receiver) -> Self { - let (root_hash, tree_content) = MerkleNode::generate_base_tree(); + //let (root_hash, tree_content) = MerkleNode::generate_base_tree(); let mut loaded_fs = HashMap::new(); - let tree = MerkleTree::new(tree_content, root_hash); - loaded_fs.insert("bob".to_string(), tree); + //let tree = MerkleTree::new(tree_content, root_hash); + //loaded_fs.insert("bob".to_string(), tree); Self { remaining: std::time::Duration::from_secs(0), @@ -123,23 +123,24 @@ impl eframe::App for P2PClientApp { NetworkEvent::FileTreeReceived(_peer_id, _) => { todo!(); - // self.loaded_tree_nodes.insert(_peer_id, tree); - self.status_message = "🔄 File tree updated successfully.".to_string(); + //self.loaded_tree_nodes.insert(_peer_id, tree); + //self.status_message = "🔄 File tree updated successfully.".to_string(); } NetworkEvent::FileTreeRootReceived(peer_id, root_hash) => { - todo!(); + // todo!(); - // self.status_message = format!("🔄 Received Merkle Root from {}: {}", peer_id, &root_hash[..8]); - // - // - // self.active_peer_id = Some(peer_id.clone()); - // - // - // // Request the content of the root directory immediately - // let _ = self.network_cmd_tx.send(NetworkCommand::RequestDirectoryContent( - // peer_id, - // root_hash, - // )); + self.status_message = format!( + "🔄 Received Merkle Root from {}: {}", + peer_id, + &root_hash[..8] + ); + + //self.active_peer_id = Some(peer_id.clone()); + + // Request the content of the root directory immediately + /*let _ = self + .network_cmd_tx + .send(NetworkCommand::RequestDirectoryContent(peer_id, root_hash));*/ } NetworkEvent::Connected(ip) => { self.server_status = ServerStatus::Connected; @@ -360,11 +361,11 @@ impl eframe::App for P2PClientApp { .loaded_fs .contains_key(self.active_peer.as_ref().unwrap()) { - todo!(); - // let _ = self.network_cmd_tx.send(NetworkCommand::RequestDirectoryContent( - // peer.clone(), - // peer.clone(), - // )); + //todo!(); + let _ = self.network_cmd_tx.send(NetworkCommand::Discover( + peer.clone(), + "root".to_string(), + )); } } selectable.context_menu(|ui| { @@ -508,7 +509,13 @@ impl P2PClientApp { entry.content_hash, tree, depth + 1, - Some(entry.filename), + Some( + entry + .filename + .as_slice() + .try_into() + .expect("incorrect size"), + ), ); } }); @@ -529,7 +536,7 @@ impl P2PClientApp { .enabled(true) .show(ui, |ui| { for child in &node.children_hashes { - self.draw_file_node(ui, child.clone(), tree, depth + 1, None); + self.draw_file_node(ui, child.content_hash, tree, depth + 1, None); } }); } diff --git a/client-network/src/data.rs b/client-network/src/data.rs index b6c8f9b..c3c9ce1 100644 --- a/client-network/src/data.rs +++ b/client-network/src/data.rs @@ -80,7 +80,7 @@ impl MerkleTree { } } -fn generate_random_file_node( +/*fn generate_random_file_node( storage: &mut HashMap, ) -> Result { let mut rng = rng(); @@ -110,9 +110,9 @@ fn generate_random_file_node( storage.insert(hash, node); Ok(hash) } -} +}*/ -fn generate_random_directory_node( +/*fn generate_random_directory_node( depth: u32, max_depth: u32, storage: &mut HashMap, @@ -172,7 +172,7 @@ fn generate_random_directory_node( storage.insert(hash, node); Ok(hash) } -} +}*/ #[derive(Debug, Clone)] pub struct ChunkNode { @@ -310,14 +310,14 @@ impl MerkleNode { } MerkleNode::BigDirectory(node) => { for hash in &node.children_hashes { - bytes.extend_from_slice(hash); + bytes.extend_from_slice(&hash.content_hash); } } } bytes } - pub fn generate_random_tree( + /*pub fn generate_random_tree( max_depth: u32, ) -> Result<(NodeHash, HashMap), String> { let mut storage = HashMap::new(); @@ -326,9 +326,9 @@ impl MerkleNode { let root_hash = generate_random_directory_node(0, max_depth, &mut storage)?; Ok((root_hash, storage)) - } + }*/ - pub fn generate_base_tree() -> (NodeHash, HashMap) { + /*pub fn generate_base_tree() -> (NodeHash, HashMap) { let mut res = HashMap::new(); let node1 = MerkleNode::Chunk(ChunkNode::new_random()); @@ -378,5 +378,5 @@ impl MerkleNode { res.insert(root_hash, root); (root_hash, res) - } + }*/ } diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index 7fe4742..c0dd386 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -12,8 +12,10 @@ use crate::{ cryptographic_signature::CryptographicSignature, message_handling::EventType, messages_channels::{MultipleSenders, start_receving_thread}, + messages_structure::construct_message, + peers_refresh::HandshakeHistory, registration::{ - get_socket_address, parse_addresses, register_ip_addresses, register_with_the_server, + get_socket_address, parse_addresses, perform_handshake, register_with_the_server, }, server_communication::{generate_id, get_peer_list}, }; @@ -33,6 +35,7 @@ pub struct P2PSharedData { shared_messageslist: Arc>>, shared_senders: Arc, server_name: Arc>, + handshake_peers: Arc, } impl P2PSharedData { @@ -51,12 +54,14 @@ impl P2PSharedData { let senders = MultipleSenders::new(1, &shared_socket, cmd_tx); let shared_senders = Arc::new(senders); let server_name = Arc::new(Mutex::new("".to_string())); + let handhsake_peers = Arc::new(HandshakeHistory::new()); Ok(P2PSharedData { shared_socket: shared_socket, shared_cryptopair: shared_cryptopair, shared_messageslist: shared_messageslist, shared_senders: shared_senders, server_name: server_name, + handshake_peers: handhsake_peers, }) } pub fn socket(&self) -> Arc { @@ -87,6 +92,9 @@ impl P2PSharedData { pub fn cryptopair_ref(&self) -> &CryptographicSignature { &*self.shared_cryptopair } + pub fn handshake_ref(&self) -> &HandshakeHistory { + &*self.handshake_peers + } pub fn messages_list_ref(&self) -> &Mutex> { &*self.shared_messageslist @@ -115,6 +123,8 @@ pub enum NetworkCommand { RequestChunk(String, String), Disconnect(), ResetServerPeer(), + Discover(String, String), + GetChildren(String, String), // ... } @@ -173,61 +183,11 @@ pub fn start_p2p_executor( match cmd { NetworkCommand::ServerHandshake(username, ip) => { if let Some(sd) = shared_data.as_ref() { - println!("username:{}, ip:{}", username, ip); - let server_addr_query = get_socket_address(username.clone(), ip); - - match server_addr_query.await { - Ok(sockaddr_bytes) => { - match String::from_utf8(sockaddr_bytes.to_vec()) { - Ok(s) => { - let addresses = parse_addresses(&s); - if let Some(first) = addresses.first() { - sd.set_servername(username); - // first: &SocketAddr - start_receving_thread( - sd, - *first, // copie le SocketAddr (implémente Copy pour SocketAddr) - event_tx.clone(), // - ); - register_ip_addresses( - sd.cryptopair_ref(), - first.to_string(), - sd.senders_ref(), - sd.messages_list_ref(), - generate_id(), - ); - - //let res = event_tx - // .send(NetworkEvent::()); - } else { - //let res = event_tx.send(NetworkEvent::Error()); - let err_msg = format!( - "no valid socket addresses found in: {}", - s - ) - .to_string(); - let res = - event_tx.send(NetworkEvent::Error(err_msg)); - } - } - Err(e) => { - //let res = event_tx.send(NetworkEvent::Error()); - let err_msg = format!( - "invalid UTF-8 in socket address bytes: {}", - e - ) - .to_string(); - let res = event_tx.send(NetworkEvent::Error(err_msg)); - } - } - } - Err(e) => { - let err_msg = - format!("failed to retreive socket address: {}", e) - .to_string(); - let res = event_tx.send(NetworkEvent::Error(err_msg)); - } - } + start_receving_thread( + sd, + event_tx.clone(), // + ); + perform_handshake(&sd, username, ip, event_tx.clone()); } } NetworkCommand::ConnectPeer(addr) => { @@ -240,6 +200,12 @@ pub fn start_p2p_executor( NetworkCommand::RequestFileTree(_) => { println!("[Network] RequestFileTree() called"); } + NetworkCommand::Discover(username, hash) => { + // envoie un handshake au peer, puis un root request + } + NetworkCommand::GetChildren(username, hash) => { + // envoie un datum request au peer + } NetworkCommand::RequestDirectoryContent(_, _) => { println!("[Network] RequestDirectoryContent() called"); } diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index 9b427f5..c5bed0a 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -5,7 +5,9 @@ use crate::{ }, messages_channels::MultipleSenders, messages_structure::construct_message, + peers_refresh::HandshakeHistory, registration, + server_communication::generate_id, }; use std::{collections::HashMap, net::SocketAddr}; use std::{ @@ -14,9 +16,7 @@ use std::{ }; pub enum EventType { - ServerHelloReply, - PeerHelloReply, - PeerHello, + SendRootRequest, } const ID: usize = 4; @@ -42,11 +42,12 @@ pub fn handle_recevied_message( messages_list: &Arc>>, recevied_message: &Vec, crypto_pair: &CryptographicSignature, - socket_addr: &SocketAddr, + //socket_addr: &SocketAddr, senders: &MultipleSenders, server_name: &String, cmd_tx: crossbeam_channel::Sender, ip: SocketAddr, + handshake_history: HandshakeHistory, ) { if recevied_message.len() < 4 { return; @@ -70,13 +71,27 @@ pub fn handle_recevied_message( } } - let resp = parse_message(recevied_message.to_vec(), id, crypto_pair, cmd_tx, ip); + let resp = parse_message( + recevied_message.to_vec(), + id, + crypto_pair, + cmd_tx, + ip, + messages_list, + handshake_history, + ); match resp { None => {} Some(resp_msg) => { println!("msg_sent:{:?}", resp_msg); - senders.send_via(0, resp_msg, ip.to_string(), is_resp_to_server_handshake); + senders.send_via( + 0, + resp_msg, + ip.to_string(), + is_resp_to_server_handshake, + messages_list, + ); } } @@ -152,6 +167,8 @@ pub fn parse_message( crypto_pair: &CryptographicSignature, cmd_tx: crossbeam_channel::Sender, ip: SocketAddr, + messages_list: &Arc>>, + handhsake_history: HandshakeHistory, ) -> Option> { let cmd_tx_clone = cmd_tx.clone(); @@ -166,7 +183,6 @@ pub fn parse_message( .expect("Taille incorrecte"); let msg_length = u16::from_be_bytes(length_bytes) as usize; - // verify signature match msgtype { HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { @@ -176,10 +192,13 @@ pub fn parse_message( let received_username = String::from_utf8(received_name.to_vec()); match received_username { Ok(username) => { - let peer_pubkey = tokio::runtime::Runtime::new() - .unwrap() - .block_on(get_peer_key(&username)) - .expect("failed to retrieve public key"); + let peer_pubkey = match handhsake_history.get_peer_info_username(username) { + Some(peerinfo) => peerinfo.pubkey, + _ => tokio::runtime::Runtime::new() + .unwrap() + .block_on(get_peer_key(&username)) + .expect("failed to retrieve public key"), + }; let signature: [u8; SIGNATURE] = received_message [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] .try_into() @@ -248,7 +267,30 @@ pub fn parse_message( // // // ajoute a la liste des peers handshake - HELLOREPLY => {} + HELLOREPLY => { + // ajoute a la liste des peers handshake + handhsake_history.add_new_handshake(hash, username, ip); + // verifie s'il faut renvoyer un root request + let guard = messages_list.lock().expect("Échec du verrouillage"); + let res = guard.get(&id); + match res { + Some(ev) => { + match ev { + EventType::SendRootRequest => { + // envoyer la root request + let rootrequest = construct_message( + ROOTREQUEST, + Vec::new(), + generate_id(), + crypto_pair, + ); + return rootrequest; + } + } + } + None => {} + } + } // // ROOTREQUEST // @@ -256,7 +298,20 @@ pub fn parse_message( // // ROOTREPLY // - // envoie un datum request + ROOTREPLY => { + // recuperer le pseudo du peers ayant repondu + + // envoyer le hash a la gui + let received_hash = String::from_utf8(received_message[LENGTH..(32 + LENGTH)].to_vec()); + match received_hash { + Ok(hash) => { + cmd_tx_clone.send(NetworkEvent::FileTreeRootReceived()); + } + Err(e) => { + println!("{}", e); + } + } + } // // DATUMREQUEST // @@ -328,6 +383,6 @@ pub fn parse_message( // // envoie OK à S puis envoie un ping à S _ => return None, - } + }; constructed_message } diff --git a/client-network/src/messages_channels.rs b/client-network/src/messages_channels.rs index a76d8a9..b02f00f 100644 --- a/client-network/src/messages_channels.rs +++ b/client-network/src/messages_channels.rs @@ -2,6 +2,7 @@ use crate::P2PSharedData; use crate::cryptographic_signature::CryptographicSignature; use crate::message_handling::EventType; use crate::message_handling::handle_recevied_message; +use crate::peers_refresh::HandshakeHistory; use std::collections::HashMap; use std::net::SocketAddr; use std::net::UdpSocket; @@ -21,9 +22,9 @@ pub struct MultipleSenders { } pub struct Message { - payload: Vec, - address: String, - is_resp_to_server_handshake: bool, + pub payload: Vec, + pub address: String, + pub is_resp_to_server_handshake: bool, } struct RetryMessage { @@ -205,85 +206,90 @@ impl MultipleSenders { data: Vec, remote_addr: String, is_resp_to_server_handshake: bool, + messages_list: &Mutex>, ) { println!( "is_resp_to_server_handshake {}", is_resp_to_server_handshake ); + let msg_to_send = Message { + payload: data.clone(), + address: remote_addr, + is_resp_to_server_handshake, + }; if let Some(sender) = self.senders.get(channel_idx) { - let _ = sender.send(Message { - payload: data, - address: remote_addr, - is_resp_to_server_handshake, - }); + let _ = sender.send(msg_to_send); + let mut guard = messages_list.lock().expect("Échec du verrouillage"); + let id = i32::from_be_bytes(data[..4].try_into().unwrap()); + guard.insert(id, EventType::SendRootRequest); } } -} -/*pub fn start_receving_thread( - socket: &Arc, - messages_list: &Arc>, - crypto_pair: &Arc, - socket_addr: SocketAddr, - senders: &Arc, -) { - let sock_clone = Arc::clone(socket); - let cryptopair_clone = Arc::clone(crypto_pair); - let senders_clone = Arc::clone(senders); + /*pub fn start_receving_thread( + socket: &Arc, + messages_list: &Arc>, + crypto_pair: &Arc, + socket_addr: SocketAddr, + senders: &Arc, + ) { + let sock_clone = Arc::clone(socket); + let cryptopair_clone = Arc::clone(crypto_pair); + let senders_clone = Arc::clone(senders); - let messages_clone = Arc::clone(messages_list); - thread::spawn(move || { - let mut buf = [0u8; 1024]; + let messages_clone = Arc::clone(messages_list); + thread::spawn(move || { + let mut buf = [0u8; 1024]; - loop { - match sock_clone.recv_from(&mut buf) { - Ok((amt, src)) => { - handle_recevied_message( - &messages_clone, - &buf.to_vec(), - &cryptopair_clone, - &socket_addr, - &senders_clone, - ); - println!("Reçu {} octets de {}: {:?}", amt, src, &buf[..amt]); + loop { + match sock_clone.recv_from(&mut buf) { + Ok((amt, src)) => { + handle_recevied_message( + &messages_clone, + &buf.to_vec(), + &cryptopair_clone, + &socket_addr, + &senders_clone, + ); + println!("Reçu {} octets de {}: {:?}", amt, src, &buf[..amt]); + } + Err(e) => eprintln!("Erreur de réception: {}", e), } - Err(e) => eprintln!("Erreur de réception: {}", e), } - } - }); -}*/ + }); + }*/ -pub fn start_receving_thread( - shared_data: &P2PSharedData, - socket_addr: SocketAddr, - cmd_tx: crossbeam_channel::Sender, -) { - let sock_clone = shared_data.socket(); - let cryptopair_clone = shared_data.cryptopair(); - let senders_clone = shared_data.senders(); - let messages_clone = shared_data.messages_list(); - let servername_clone = shared_data.servername(); - thread::spawn(move || { - let mut buf = [0u8; 1024]; - loop { - match sock_clone.recv_from(&mut buf) { - Ok((amt, src)) => { - let received_data = buf[..amt].to_vec(); + pub fn start_receving_thread( + shared_data: &P2PSharedData, + cmd_tx: crossbeam_channel::Sender, + ) { + let sock_clone = shared_data.socket(); + let cryptopair_clone = shared_data.cryptopair(); + let senders_clone = shared_data.senders(); + let messages_clone = shared_data.messages_list(); + let servername_clone = shared_data.servername(); + let handshake_history = HandshakeHistory::new(); + thread::spawn(move || { + let mut buf = [0u8; 1024]; + 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, received_data); - handle_recevied_message( - &messages_clone, - &received_data, - &cryptopair_clone, - &socket_addr, - &senders_clone, - &servername_clone, - cmd_tx.clone(), - src, - ); + println!("Reçu {} octets de {}: {:?}", amt, src, received_data); + handle_recevied_message( + &messages_clone, + &received_data, + &cryptopair_clone, + &senders_clone, + &servername_clone, + cmd_tx.clone(), + src, + handshake_history, + ); + } + Err(e) => eprintln!("Erreur de réception: {}", e), } - Err(e) => eprintln!("Erreur de réception: {}", e), } - } - }); + }); + } } diff --git a/client-network/src/messages_structure.rs b/client-network/src/messages_structure.rs index 2376e83..4da9ffa 100644 --- a/client-network/src/messages_structure.rs +++ b/client-network/src/messages_structure.rs @@ -14,7 +14,7 @@ const OK: u8 = 128; const ERROR: u8 = 129; const HELLO: u8 = 1; const HELLOREPLY: u8 = 130; -const ROOTREQUEST: u8 = 2; +pub const ROOTREQUEST: u8 = 2; const ROOTREPLY: u8 = 131; const DATUMREQUEST: u8 = 3; const NODATUM: u8 = 133; @@ -46,11 +46,11 @@ pub fn construct_message( let signature = sign_message(crypto_pair, &message); return Some(signature); } - PING | OK => { + PING | OK | ROOTREQUEST => { message.extend_from_slice(&0u16.to_be_bytes()); return Some(message); } - ERROR | ROOTREQUEST | DATUMREQUEST => { + ERROR | DATUMREQUEST => { message.extend_from_slice(&payload.len().to_be_bytes()); message.extend_from_slice(&payload); return Some(message); diff --git a/client-network/src/peers_refresh.rs b/client-network/src/peers_refresh.rs index e1cd85c..cf409eb 100644 --- a/client-network/src/peers_refresh.rs +++ b/client-network/src/peers_refresh.rs @@ -11,54 +11,113 @@ use std::{ time::{self, Duration, SystemTime}, }; +use crate::NetworkEvent; +use crate::{ + P2PSharedData, construct_message, generate_id, messages_structure, + registration::perform_handshake, +}; +use crossbeam_channel::{Receiver, Sender}; +use p256::ecdsa::VerifyingKey; + +#[derive(Debug, Clone)] pub struct PeerInfo { username: String, - ip: SocketAddr, + pub pubkey: VerifyingKey, + pub ip: SocketAddr, } pub struct HandshakeHistory { - time_k_ip_v: HashMap, - ip_k_peerinfo_v: HashMap, + //time_k_ip_v: HashMap, + username_k_peerinfo_v: HashMap, + ip_k_peerinfo_v: HashMap, } impl HandshakeHistory { pub fn new() -> HandshakeHistory { HandshakeHistory { - time_k_ip_v: HashMap::new(), + //time_k_ip_v: HashMap::new(), + //ip_k_peerinfo_v: HashMap::new(), + username_k_peerinfo_v: HashMap::new(), ip_k_peerinfo_v: HashMap::new(), } } - pub fn update_handshake(&mut self) { + /*pub fn update_handshake(&self) { + let hashmap_shared = Arc::new(self.username_k_peerinfo_v); thread::spawn(move || { - let mut times_to_check = VecDeque::new(); - let current_time: u64 = SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .expect("system time before UNIX EPOCH") - .add(Duration::from_secs(10)) - .as_secs(); - // adds 10 seconds in the queue every 10 seconds + let selfhashmap = hashmap_shared.clone(); loop { - let mut child = Command::new("sleep").arg("9").spawn().unwrap(); - let _result = child.wait().unwrap(); - for n in 0..9 { - // push 9 successive seconds - times_to_check.push_back(current_time + n); - // gestion d'erreur si verrou mort + for peer in selfhashmap.keys() { + let peer_ip = selfhashmap.get(peer); + // send ping } + let mut child = Command::new("sleep").arg("10").spawn().unwrap(); + let _result = child.wait().unwrap(); + } + }); + }*/ + + pub fn get_peer_info_username(&self, username: String) -> Option<&PeerInfo> { + self.username_k_peerinfo_v.get(&username).clone() + } + + pub fn get_peer_info_ip(&self, ip: String) -> Option<&PeerInfo> { + self.ip_k_peerinfo_v.get(&ip).clone() + } + + pub fn update_handshake(&self) { + // clone the map so we own it (cheap if PeerInfo is Clone) + let map_clone: Arc> = + Arc::new(self.username_k_peerinfo_v.clone()); + //let map_ip_clone: Arc> = Arc::new(self.ip_k_peerinfo_v.clone()); + let map_for_thread = Arc::clone(&map_clone); + thread::spawn(move || { + loop { + // Arc> derefs to &HashMap so these reads work + for (peer, peerinfo) in map_for_thread.iter() { + // send ping to peerinfo + } + thread::sleep(Duration::from_secs(10)); } }); } - pub fn add_new_handshake(&mut self, hash: u64, username: String, ip: SocketAddr) { - let current_time: u64 = SystemTime::now() - .duration_since(time::UNIX_EPOCH) - .expect("system time before UNIX EPOCH") - .as_secs(); - println!("time:{}", current_time); - /*self.time_k_hash_v.insert(current_time, hash); - self.hash_k_peerinfo_v - .insert(hash, PeerInfo { username, ip });*/ + pub fn add_new_handshake(&mut self, hash: VerifyingKey, username: String, ip: SocketAddr) { + let peerinfo = PeerInfo { + username: username.clone(), + pubkey: hash, + ip, + }; + self.username_k_peerinfo_v + .insert(username, peerinfo.clone()); + self.ip_k_peerinfo_v + .insert(ip.to_string(), peerinfo.clone()); + } +} + +pub fn perform_discover( + username: String, + hash: String, + sd: &P2PSharedData, + server_ip: String, + event_tx: Sender, +) { + // first, sends handshake + if hash == "root" { + perform_handshake(sd, username, server_ip, event_tx); + if let Some(data) = construct_message( + messages_structure::ROOTREQUEST, + Vec::new(), + generate_id(), + sd.cryptopair_ref(), + ) { + if let Some(peerinfo) = sd.handshake_ref() { + sd.senders_ref() + .send_via(0, data, peerinfo.ip.to_string(), false); + } + } + } else { + // envoyer un datum request } } @@ -68,10 +127,7 @@ mod tests { use super::*; - /// - /// creates a cryptographic signature - /// - #[test] + /*#[test] fn creating_cryptographic_signature() { let mut hh = HandshakeHistory::new(); hh.add_new_handshake( @@ -79,5 +135,5 @@ mod tests { "putain".to_string(), SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 1), ); - } + }*/ } diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index 5ddcdf5..6b10813 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -1,10 +1,14 @@ use bytes::Bytes; use getrandom::Error; +use crate::NetworkEvent; +use crate::P2PSharedData; use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message}; use crate::message_handling::EventType; use crate::messages_channels::{Message, MultipleSenders}; use crate::messages_structure::construct_message; +use crate::server_communication::generate_id; +use crossbeam_channel::{Receiver, Sender}; use std::collections::HashMap; use std::net::SocketAddr; use std::net::UdpSocket; @@ -66,23 +70,66 @@ pub fn parse_addresses(input: &String) -> Vec { /// /// registers the IP addresses by sending a Hello request to the server. /// -pub fn register_ip_addresses( - crypto_pair: &CryptographicSignature, - server_uri: String, - senders: &MultipleSenders, - messages_list: &Mutex>, - id: i32, +pub async fn perform_handshake( + sd: &P2PSharedData, + username: String, + ip: String, + event_tx: Sender, ) { - 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); - match hello_handshake { - Some(handshake_message) => { - senders.send_via(0, handshake_message, server_uri, false); + let crypto_pair = sd.cryptopair_ref(); + let senders = sd.senders_ref(); + let messages_list = sd.messages_list_ref(); + let id = generate_id(); + let server_addr_query = get_socket_address(username.clone(), ip.clone()); + + match server_addr_query.await { + Ok(sockaddr_bytes) => { + match String::from_utf8(sockaddr_bytes.to_vec()) { + Ok(s) => { + let addresses = parse_addresses(&s); + if let Some(first) = addresses.first() { + sd.set_servername(username); + // first: &SocketAddr + 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); + match hello_handshake { + Some(handshake_message) => { + senders.send_via( + 0, + handshake_message, + first.to_string(), + false, + messages_list, + ); + } + None => {} + } + + //let res = event_tx + // .send(NetworkEvent::()); + } else { + //let res = event_tx.send(NetworkEvent::Error()); + let err_msg = + format!("no valid socket addresses found in: {}", s).to_string(); + let res = event_tx.send(NetworkEvent::Error(err_msg)); + } + } + Err(e) => { + //let res = event_tx.send(NetworkEvent::Error()); + let err_msg = + format!("invalid UTF-8 in socket address bytes: {}", e).to_string(); + let res = event_tx.send(NetworkEvent::Error(err_msg)); + } + } + } + Err(e) => { + let err_msg = format!("failed to retreive socket address: {}", e).to_string(); + let res = event_tx.send(NetworkEvent::Error(err_msg)); } - None => {} } + /*let mut list = messages_list.lock().expect("Failed to lock messages_list"); match list.get(&id) { Some(_) => { From c852c5bb4a72f60615d531d45bab3f3859e81dcc Mon Sep 17 00:00:00 2001 From: TIBERGHIEN corentin Date: Tue, 13 Jan 2026 17:13:35 +0100 Subject: [PATCH 3/3] root request --- client-gui/src/gui_app.rs | 24 ++++++- client-network/src/lib.rs | 65 ++++++++++++++++--- client-network/src/message_handling.rs | 84 ++++++++++++++++++------- client-network/src/messages_channels.rs | 79 ++++++++++++----------- client-network/src/peers_refresh.rs | 31 +++++++-- client-network/src/registration.rs | 5 +- 6 files changed, 210 insertions(+), 78 deletions(-) diff --git a/client-gui/src/gui_app.rs b/client-gui/src/gui_app.rs index 39bb3a5..03c508f 100644 --- a/client-gui/src/gui_app.rs +++ b/client-gui/src/gui_app.rs @@ -1,5 +1,5 @@ use client_network::{ - MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash, filename_to_string, + ChunkNode, MerkleNode, MerkleTree, NetworkCommand, NetworkEvent, NodeHash, filename_to_string, node_hash_to_hex_string, }; use crossbeam_channel::{Receiver, Sender}; @@ -129,11 +129,28 @@ impl eframe::App for P2PClientApp { NetworkEvent::FileTreeRootReceived(peer_id, root_hash) => { // todo!(); - self.status_message = format!( + /*self.status_message = format!( "🔄 Received Merkle Root from {}: {}", peer_id, &root_hash[..8] - ); + );*/ + + if let Ok(chunknode) = ChunkNode::new(Vec::new()) { + let mut data_map: HashMap = HashMap::new(); + data_map.insert(root_hash, MerkleNode::Chunk(chunknode)); + let tree = MerkleTree { + data: data_map, + root: root_hash, + }; + match &self.active_peer { + Some(activepeer) => { + self.loaded_fs.insert(activepeer.clone(), tree); + } + None => {} + } + + println!("tree created"); + } //self.active_peer_id = Some(peer_id.clone()); @@ -365,6 +382,7 @@ impl eframe::App for P2PClientApp { let _ = self.network_cmd_tx.send(NetworkCommand::Discover( peer.clone(), "root".to_string(), + self.connected_address.clone(), )); } } diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index c0dd386..44fa3ab 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -12,7 +12,7 @@ use crate::{ cryptographic_signature::CryptographicSignature, message_handling::EventType, messages_channels::{MultipleSenders, start_receving_thread}, - messages_structure::construct_message, + messages_structure::{ROOTREQUEST, construct_message}, peers_refresh::HandshakeHistory, registration::{ get_socket_address, parse_addresses, perform_handshake, register_with_the_server, @@ -123,7 +123,7 @@ pub enum NetworkCommand { RequestChunk(String, String), Disconnect(), ResetServerPeer(), - Discover(String, String), + Discover(String, String, String), GetChildren(String, String), // ... } @@ -138,7 +138,7 @@ pub enum NetworkEvent { PeerListUpdated(Vec), FileTreeReceived(String, Vec), // peer_id, content DataReceived(String, MerkleNode), - FileTreeRootReceived(String, String), + FileTreeRootReceived(String, NodeHash), HandshakeFailed(), ServerHandshakeFailed(String), // ... @@ -173,6 +173,8 @@ pub fn start_p2p_executor( // Use tokio to spawn the asynchronous networking logic tokio::task::spawn(async move { // P2P/Networking Setup goes here + let handshake_history = Arc::new(Mutex::new(HandshakeHistory::new())); + let handshake_clone = handshake_history.clone(); println!("Network executor started."); @@ -182,12 +184,13 @@ pub fn start_p2p_executor( if let Ok(cmd) = cmd_rx.try_recv() { match cmd { NetworkCommand::ServerHandshake(username, ip) => { + println!("server handshake called"); if let Some(sd) = shared_data.as_ref() { - start_receving_thread( - sd, - event_tx.clone(), // - ); - perform_handshake(&sd, username, ip, event_tx.clone()); + start_receving_thread(sd, event_tx.clone(), &handshake_clone); + let res = + perform_handshake(&sd, username, ip, event_tx.clone(), true).await; + } else { + println!("no shared data"); } } NetworkCommand::ConnectPeer(addr) => { @@ -200,8 +203,52 @@ pub fn start_p2p_executor( NetworkCommand::RequestFileTree(_) => { println!("[Network] RequestFileTree() called"); } - NetworkCommand::Discover(username, hash) => { + NetworkCommand::Discover(username, hash, ip) => { // envoie un handshake au peer, puis un root request + if let Some(sd) = shared_data.as_ref() { + let res = { + let m = handshake_clone.lock().unwrap(); + m.get_peer_info_username(username.clone()).cloned() + }; + match res { + Some(peerinfo) => { + // envoyer un root request + let rootrequest = construct_message( + ROOTREQUEST, + Vec::new(), + generate_id(), + sd.cryptopair_ref(), + ); + + match rootrequest { + None => {} + Some(resp_msg) => { + println!("msg_sent:{:?}", resp_msg); + sd.senders_ref().send_via( + 0, + resp_msg, + peerinfo.ip.to_string(), + false, + sd.messages_list_ref(), + ); + } + } + } + None => { + // envoyer un handshake + let res = perform_handshake( + &sd, + username, + ip, + event_tx.clone(), + false, + ) + .await; + } + } + } else { + println!("no shared data"); + } } NetworkCommand::GetChildren(username, hash) => { // envoie un datum request au peer diff --git a/client-network/src/message_handling.rs b/client-network/src/message_handling.rs index c5bed0a..c4793d1 100644 --- a/client-network/src/message_handling.rs +++ b/client-network/src/message_handling.rs @@ -1,5 +1,5 @@ use crate::{ - NetworkEvent, + NetworkEvent, NodeHash, cryptographic_signature::{ CryptographicSignature, get_peer_key, sign_message, verify_signature, }, @@ -47,7 +47,7 @@ pub fn handle_recevied_message( server_name: &String, cmd_tx: crossbeam_channel::Sender, ip: SocketAddr, - handshake_history: HandshakeHistory, + handhsake_history: &Arc>, ) { if recevied_message.len() < 4 { return; @@ -78,7 +78,7 @@ pub fn handle_recevied_message( cmd_tx, ip, messages_list, - handshake_history, + handhsake_history, ); match resp { @@ -168,8 +168,9 @@ pub fn parse_message( cmd_tx: crossbeam_channel::Sender, ip: SocketAddr, messages_list: &Arc>>, - handhsake_history: HandshakeHistory, + handhsake_history_mutex: &Arc>, ) -> Option> { + let mut handhsake_history = handhsake_history_mutex.lock().unwrap(); let cmd_tx_clone = cmd_tx.clone(); let id_bytes: [u8; 4] = received_message[0..ID] @@ -185,20 +186,27 @@ pub fn parse_message( let msg_length = u16::from_be_bytes(length_bytes) as usize; // verify signature match msgtype { - HELLO | HELLOREPLY | ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { + HELLO | HELLOREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => { let ilength = u16::from_be_bytes(length_bytes); println!("name received length: {}", ilength); let received_name = &received_message[LENGTH + EXTENSIONS..LENGTH + ilength as usize]; let received_username = String::from_utf8(received_name.to_vec()); match received_username { Ok(username) => { - let peer_pubkey = match handhsake_history.get_peer_info_username(username) { - Some(peerinfo) => peerinfo.pubkey, - _ => tokio::runtime::Runtime::new() - .unwrap() - .block_on(get_peer_key(&username)) - .expect("failed to retrieve public key"), - }; + let peer_pubkey = + match handhsake_history.get_peer_info_username(username.clone()) { + Some(peerinfo) => peerinfo.pubkey, + _ => tokio::runtime::Runtime::new() + .unwrap() + .block_on(get_peer_key(&username)) + .expect("failed to retrieve public key"), + }; + match msgtype { + HELLOREPLY => { + handhsake_history.add_new_handshake(peer_pubkey, "".to_string(), ip); + } + _ => {} + } let signature: [u8; SIGNATURE] = received_message [LENGTH + msg_length..LENGTH + msg_length + SIGNATURE] .try_into() @@ -217,6 +225,22 @@ pub fn parse_message( } } } + ROOTREPLY => { + let ilength = u16::from_be_bytes(length_bytes); + println!("name received length: {}", ilength); + if let Some(peerinfo) = handhsake_history.get_peer_info_ip(ip.to_string()) { + if !verify_signature(peerinfo.pubkey, &received_message) { + println!( + "incorrect signature from given peer: {}, ignoring message of type {} with id {}", + &peerinfo.username, received_message[ID], id + ); + return None; + } else { + println!("signature verified"); + } + } + } + _ => {} } @@ -268,8 +292,18 @@ pub fn parse_message( // // ajoute a la liste des peers handshake HELLOREPLY => { - // ajoute a la liste des peers handshake - handhsake_history.add_new_handshake(hash, username, ip); + // ajoute l'username a la liste des peers handshake + let received_length = u16::from_be_bytes( + received_message[TYPE..LENGTH] + .try_into() + .expect("incorrect size"), + ); + let received_username = + &received_message[LENGTH + EXTENSIONS..LENGTH + received_length as usize]; + handhsake_history.update_peer_info( + ip.to_string(), + String::from_utf8(received_username.to_vec()).expect("invalid conversion"), + ); // verifie s'il faut renvoyer un root request let guard = messages_list.lock().expect("Échec du verrouillage"); let res = guard.get(&id); @@ -300,15 +334,21 @@ pub fn parse_message( // ROOTREPLY => { // recuperer le pseudo du peers ayant repondu - - // envoyer le hash a la gui - let received_hash = String::from_utf8(received_message[LENGTH..(32 + LENGTH)].to_vec()); - match received_hash { - Ok(hash) => { - cmd_tx_clone.send(NetworkEvent::FileTreeRootReceived()); + let peers_exist = handhsake_history.get_peer_info_ip(ip.to_string()); + match peers_exist { + Some(peerinfo) => { + // envoyer le hash a la gui + let received_hash: NodeHash = received_message[LENGTH..(32 + LENGTH)] + .try_into() + .expect("incorrect size"); + let res = cmd_tx_clone.send(NetworkEvent::FileTreeRootReceived( + peerinfo.username.clone(), + received_hash, + )); + println!("file tree sent") } - Err(e) => { - println!("{}", e); + None => { + eprintln!("no peers found"); } } } diff --git a/client-network/src/messages_channels.rs b/client-network/src/messages_channels.rs index b02f00f..83c3cee 100644 --- a/client-network/src/messages_channels.rs +++ b/client-network/src/messages_channels.rs @@ -219,8 +219,11 @@ impl MultipleSenders { }; if let Some(sender) = self.senders.get(channel_idx) { let _ = sender.send(msg_to_send); - let mut guard = messages_list.lock().expect("Échec du verrouillage"); - let id = i32::from_be_bytes(data[..4].try_into().unwrap()); + } + if !is_resp_to_server_handshake { + let mut guard = messages_list.lock().unwrap(); + let message_id: [u8; 4] = data[0..4].try_into().expect("size error"); + let id = i32::from_be_bytes(message_id); guard.insert(id, EventType::SendRootRequest); } } @@ -257,39 +260,41 @@ impl MultipleSenders { } }); }*/ - - pub fn start_receving_thread( - shared_data: &P2PSharedData, - cmd_tx: crossbeam_channel::Sender, - ) { - let sock_clone = shared_data.socket(); - let cryptopair_clone = shared_data.cryptopair(); - let senders_clone = shared_data.senders(); - let messages_clone = shared_data.messages_list(); - let servername_clone = shared_data.servername(); - let handshake_history = HandshakeHistory::new(); - thread::spawn(move || { - let mut buf = [0u8; 1024]; - 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, received_data); - handle_recevied_message( - &messages_clone, - &received_data, - &cryptopair_clone, - &senders_clone, - &servername_clone, - cmd_tx.clone(), - src, - handshake_history, - ); - } - Err(e) => eprintln!("Erreur de réception: {}", e), - } - } - }); - } +} + +pub fn start_receving_thread( + shared_data: &P2PSharedData, + cmd_tx: crossbeam_channel::Sender, + handshake_history: &Arc>, +) { + let sock_clone = shared_data.socket(); + let cryptopair_clone = shared_data.cryptopair(); + let senders_clone = shared_data.senders(); + let messages_clone = shared_data.messages_list(); + let servername_clone = shared_data.servername(); + + let handshake_clone = handshake_history.clone(); + thread::spawn(move || { + let mut buf = [0u8; 1024]; + 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, received_data); + handle_recevied_message( + &messages_clone, + &received_data, + &cryptopair_clone, + &senders_clone, + &servername_clone, + cmd_tx.clone(), + src, + &handshake_clone, + ); + } + Err(e) => eprintln!("Erreur de réception: {}", e), + } + } + }); } diff --git a/client-network/src/peers_refresh.rs b/client-network/src/peers_refresh.rs index cf409eb..ea70c4a 100644 --- a/client-network/src/peers_refresh.rs +++ b/client-network/src/peers_refresh.rs @@ -3,7 +3,7 @@ use std::{ collections::{HashMap, VecDeque}, - net::{AddrParseError, SocketAddr}, + net::{AddrParseError, Ipv4Addr, SocketAddr}, ops::Add, process::Command, sync::{Arc, Mutex}, @@ -21,7 +21,7 @@ use p256::ecdsa::VerifyingKey; #[derive(Debug, Clone)] pub struct PeerInfo { - username: String, + pub username: String, pub pubkey: VerifyingKey, pub ip: SocketAddr, } @@ -82,6 +82,27 @@ impl HandshakeHistory { }); } + pub fn update_peer_info(&mut self, ip: String, username: String) { + let peerinfo = self.get_peer_info_ip(ip.clone()); + match peerinfo { + Some(peer_info) => match ip.parse::() { + Ok(addr) => { + let new_peer_info = PeerInfo { + username: username.clone(), + pubkey: peer_info.pubkey, + ip: addr, + }; + self.ip_k_peerinfo_v.insert(ip, new_peer_info.clone()); + self.username_k_peerinfo_v.insert(username, new_peer_info); + } + Err(e) => eprintln!("parse error: {}", e), + }, + None => { + eprintln!("no peer info found in hashmap") + } + } + } + pub fn add_new_handshake(&mut self, hash: VerifyingKey, username: String, ip: SocketAddr) { let peerinfo = PeerInfo { username: username.clone(), @@ -104,8 +125,8 @@ pub fn perform_discover( ) { // first, sends handshake if hash == "root" { - perform_handshake(sd, username, server_ip, event_tx); - if let Some(data) = construct_message( + perform_handshake(sd, username, server_ip, event_tx, false); + /*if let Some(data) = construct_message( messages_structure::ROOTREQUEST, Vec::new(), generate_id(), @@ -115,7 +136,7 @@ pub fn perform_discover( sd.senders_ref() .send_via(0, data, peerinfo.ip.to_string(), false); } - } + }*/ } else { // envoyer un datum request } diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index 6b10813..64a1d91 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -75,13 +75,14 @@ pub async fn perform_handshake( username: String, ip: String, event_tx: Sender, + is_server_handshake: bool, ) { + println!("username: {}, ip: {}", username.clone(), ip.clone()); let crypto_pair = sd.cryptopair_ref(); let senders = sd.senders_ref(); let messages_list = sd.messages_list_ref(); let id = generate_id(); let server_addr_query = get_socket_address(username.clone(), ip.clone()); - match server_addr_query.await { Ok(sockaddr_bytes) => { match String::from_utf8(sockaddr_bytes.to_vec()) { @@ -100,7 +101,7 @@ pub async fn perform_handshake( 0, handshake_message, first.to_string(), - false, + is_server_handshake, messages_list, ); }