From 732daf05782ec3bb2f0caeaa45c4c07e7ab9e740 Mon Sep 17 00:00:00 2001 From: Tiago Batista Cardoso Date: Wed, 21 Jan 2026 22:48:05 +0100 Subject: [PATCH] work --- client-network/src/lib.rs | 114 +++++++++++++++++++---------- client-network/src/registration.rs | 27 ++++--- 2 files changed, 89 insertions(+), 52 deletions(-) diff --git a/client-network/src/lib.rs b/client-network/src/lib.rs index 1c61d6e..3d44647 100644 --- a/client-network/src/lib.rs +++ b/client-network/src/lib.rs @@ -27,7 +27,6 @@ use crate::{ }; use std::collections::HashSet; use std::{ - clone, io::Error, net::{IpAddr, Ipv4Addr, UdpSocket}, time::Duration, @@ -43,12 +42,12 @@ pub struct P2PSharedData { shared_messageslist: Arc>>, shared_senders: Arc, server_name: Arc>, + server_address: Arc>, handshake_peers: Arc, threads: Vec, } use bytes::Bytes; -use p256::pkcs8::der::pem::Base64Encoder; use reqwest::Client; impl P2PSharedData { @@ -69,6 +68,7 @@ impl P2PSharedData { let senders = MultipleSenders::new(1, &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())); let handhsake_peers = Arc::new(HandshakeHistory::new()); Ok(P2PSharedData { @@ -77,6 +77,7 @@ impl P2PSharedData { shared_messageslist: shared_messageslist, shared_senders: shared_senders, server_name: server_name, + server_address: server_address, handshake_peers: handhsake_peers, threads, }) @@ -95,10 +96,18 @@ impl P2PSharedData { let guard = self.server_name.lock().unwrap(); guard.to_string() } + pub fn serveraddress(&self) -> String { + let guard = self.server_address.lock().unwrap(); + guard.to_string() + } pub fn set_servername(&self, new: String) { let mut guard = self.server_name.lock().unwrap(); *guard = new } + pub fn set_serveraddress(&self, new: String) { + let mut guard = self.server_address.lock().unwrap(); + *guard = new + } pub fn senders(&self) -> Arc { self.shared_senders.clone() } @@ -496,7 +505,8 @@ pub fn start_p2p_executor( sd.add_message(id, EventType::Ping); let pingrequest = construct_message(PING, Vec::new(), id, sd.cryptopair_ref()); - let peer_address = get_socket_address(str, ip).await; + let peer_address = + get_socket_address(str, ip, shared_data.as_ref()).await; match peer_address { Some(addr) => { if let Some(ping) = pingrequest { @@ -542,9 +552,16 @@ pub fn start_p2p_executor( if let Some(sd) = shared_data.as_ref() { println!("username:{}, ip:{}", username, ip); // user server to send nattraversal request - let server_addr_query = - get_socket_address(sd.servername().clone(), ip.clone()); - let peer_addr_query = get_socket_address(username.clone(), ip.clone()); + let server_addr_query = get_socket_address( + sd.servername().clone(), + ip.clone(), + shared_data.as_ref(), + ); + let peer_addr_query = get_socket_address( + username.clone(), + ip.clone(), + shared_data.as_ref(), + ); match server_addr_query.await { Some(server_addr) => match peer_addr_query.await { @@ -634,7 +651,13 @@ fn quick_ping(addr: &SocketAddr, timeout_ms: u64) -> bool { /// sends a get request to the server to get the socket address of the given peer /// -pub async fn get_socket_address(username: String, ip: String) -> Option { +pub async fn get_socket_address( + username: String, + ip: String, + shared_data: Option<&P2PSharedData>, +) -> Option { + let sd = shared_data.expect("No shared data"); + let client = match Client::builder().timeout(Duration::from_secs(5)).build() { Ok(c) => c, Err(e) => { @@ -680,14 +703,29 @@ pub async fn get_socket_address(username: String, ip: String) -> Option Vec for addr in addresses { - if quick_ping(&addr, 300) { + println!("trying address : {}", addr); + if quick_ping(&addr, 1000) { return Some(addr); } // TODO: nat_traversal(&addr).await; // after NAT traversal attempt, ping again - if quick_ping(&addr, 300) { + let natreq = construct_message( + NATTRAVERSALREQUEST, + addr.to_string().into_bytes(), + generate_id(), + &sd.shared_cryptopair, + ); + + sd.senders_ref().send_dispatch( + natreq.expect("couldnt construct message nattraversalrequest2"), + sd.serveraddress(), + false, + sd.messages_list().clone(), + ); + + if quick_ping(&addr, 1500) { return Some(addr); } } @@ -695,32 +733,32 @@ pub async fn get_socket_address(username: String, ip: String) -> Option Option { -// let client = Client::builder() -// .timeout(Duration::from_secs(5)) -// .build() -// .expect("cannot create client"); -// let uri = format!("{}/peers/{}/addresses", ip, username); -// let res = client.get(uri).send().await.expect("couldnt get response"); -// if res.status().is_success() { -// println!("Successfully retreived the addresses. {}", res.status()); -// } else { -// eprintln!( -// "Failed to get the peers addresses from the server. Status: {}", -// res.status() -// ); -// } -// let body: Bytes = res.bytes().await.expect("couldnt get bytes"); -// -// match String::from_utf8(body.to_vec()) { -// Ok(s) => { -// let addresses = parse_addresses(&s); -// if let Some(first) = addresses.first() { -// Some(first.clone()) -// } else { -// None -// } -// } -// Err(_) => None, -// } -//} +pub async fn get_server_address(username: String, ip: String) -> Option { + let client = Client::builder() + .timeout(Duration::from_secs(5)) + .build() + .expect("cannot create client"); + let uri = format!("{}/peers/{}/addresses", ip, username); + let res = client.get(uri).send().await.expect("couldnt get response"); + if res.status().is_success() { + println!("Successfully retreived the addresses. {}", res.status()); + } else { + eprintln!( + "Failed to get the peers addresses from the server. Status: {}", + res.status() + ); + } + let body: Bytes = res.bytes().await.expect("couldnt get bytes"); + + match String::from_utf8(body.to_vec()) { + Ok(s) => { + let addresses = parse_addresses(&s); + if let Some(first) = addresses.first() { + Some(first.clone()) + } else { + None + } + } + Err(_) => None, + } +} diff --git a/client-network/src/registration.rs b/client-network/src/registration.rs index 0efd8e6..8d83ba5 100644 --- a/client-network/src/registration.rs +++ b/client-network/src/registration.rs @@ -1,19 +1,14 @@ -use bytes::Bytes; - use crate::NetworkEvent; use crate::P2PSharedData; -use crate::cryptographic_signature::{CryptographicSignature, formatPubKey, sign_message}; -use crate::get_socket_address; +use crate::cryptographic_signature::CryptographicSignature; +use crate::get_server_address; use crate::message_handling::EventType; -use crate::messages_channels::MultipleSenders; use crate::messages_structure::construct_message; use crate::server_communication::generate_id; -use crossbeam_channel::{Receiver, Sender}; -use std::collections::HashMap; +use crossbeam_channel::Sender; use std::net::SocketAddr; -use std::net::UdpSocket; use std::str::FromStr; -use std::sync::{Arc, Mutex}; +use std::sync::Arc; /// /// sends the cryptographic signature to the server using a PUT request over the HTTP API. @@ -29,8 +24,13 @@ pub async fn register_with_the_server( let pubkey_bytes_minus = pubkey_bytes[1..].to_vec(); let res = client.put(uri).body(pubkey_bytes_minus).send().await?; let res = res.error_for_status()?; - println!("register ip adresses"); - Ok(()) + match res.error_for_status() { + Ok(_) => { + println!("register ip adresses"); + Ok(()) + } + Err(e) => Err(e), + } } pub fn parse_addresses(input: &String) -> Vec { @@ -62,10 +62,11 @@ pub async fn perform_handshake( let senders = sd.senders_ref(); let id = generate_id(); - let server_addr_query = get_socket_address(username.clone(), ip.clone()); + let server_addr_query = get_server_address(username.clone(), ip.clone()); match server_addr_query.await { Some(sockaddr_bytes) => { sd.set_servername(username); + sd.set_serveraddress(sockaddr_bytes.to_string()); // first: &SocketAddr let mut payload = Vec::new(); payload.extend_from_slice(&0u32.to_be_bytes()); @@ -115,8 +116,6 @@ pub async fn perform_handshake( #[cfg(test)] mod tests { - // Note this useful idiom: importing names from outer (for mod tests) scope. - use super::*; /*/// /// does the procedure to register with the server