bob/p2p
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

working

Browse Source
This commit is contained in:
Tiago Batista Cardoso
2026-01-24 19:47:15 +01:00
parent f8e3e46672
commit a3648c2116
9 changed files with 270 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
client-network/src/lib.rs
View File

@@ -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,9 +10,12 @@ mod peers_refresh;
mod registration;
mod server_communication;
mod threads_handling;
mod timestamp;
use crate::fetchsocketaddresserror::FetchSocketAddressError;
use crate::messages_structure::ROOTREPLY;
use crate::peers_refresh::*;
use crate::timestamp::Timestamp;
use crate::{
cryptographic_signature::CryptographicSignature,
message_handling::EventType,
@@ -26,7 +30,6 @@ use crate::{
threads_handling::Worker,
};
use std::collections::HashSet;
use std::{
io::Error,
net::{IpAddr, Ipv4Addr, UdpSocket},
@@ -41,6 +44,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>>,
@@ -50,8 +54,7 @@ pub struct P2PSharedData {
use bytes::Bytes;
use reqwest::Client;
use tokio::sync::oneshot;
use tokio::time::{sleep, timeout};
use tokio::time::sleep;
impl P2PSharedData {
pub fn new(
@@ -59,12 +62,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();
@@ -78,6 +83,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,
@@ -95,12 +101,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) {
@@ -128,6 +143,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
}
@@ -176,6 +195,7 @@ pub enum NetworkEvent {
ConnectedHandshake(),
Disconnected(),
Error(String),
Success(String),
PeerConnected(String),
PeerListUpdated(Vec<(String, bool)>),
FileTreeReceived([u8; 32], MerkleNode, String), // peer_id, content
@@ -468,6 +488,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(),
@@ -497,12 +518,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);
@@ -511,35 +532,51 @@ pub fn start_p2p_executor(
let peer_address =
get_socket_address(str, ip, shared_data.as_ref()).await;
match peer_address {
Some(addr) => {
if let Some(ping) = pingrequest {
sd.senders_ref().add_message_to_retry_queue(
ping.clone(),
addr.to_string(),
false,
);
sd.senders_ref().send_dispatch(
ping,
addr.to_string(),
false,
sd.messages_list(),
);
}
Ok(addr) => {
//if let Some(ping) = pingrequest {
// sd.senders_ref().add_message_to_retry_queue(
// ping.clone(),
// addr.to_string(),
// false,
// );
// sd.senders_ref().send_dispatch(
// ping,
// addr.to_string(),
// false,
// 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);
}
};
}
None => {
let err_msg =
format!("failed to retreive socket address:").to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
Err(err_msg) => {
match event_tx.send(NetworkEvent::Error(err_msg.to_string())) {
Ok(_) => {}
Err(e) => {
eprintln!("NetworkEvent error : {}", e);
}
}
}
}
}
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");
}
@@ -563,7 +600,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());
@@ -586,10 +623,13 @@ pub fn start_p2p_executor(
sd.messages_list(),
);
}
None => {
let err_msg =
format!("failed to retreive socket address").to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg));
Err(err_msg) => {
match event_tx.send(NetworkEvent::Error(err_msg.to_string())) {
Ok(_) => {}
Err(e) => {
eprintln!("NetworkEvent error : {}", e);
}
}
}
}
}
@@ -603,7 +643,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;
}
})
}
@@ -634,7 +674,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 {
@@ -645,7 +685,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
}
///
@@ -656,24 +704,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 None;
return Err(FetchSocketAddressError::ClientError(e.to_string()));
}
};
let uri = format!("{}/peers/{}/addresses", ip, username);
let res = match client.get(&uri).send().await {
Ok(r) => r,
Err(e) => {
eprintln!("HTTP request error: {}", e);
return None;
}
Err(e) => return Err(FetchSocketAddressError::ClientError(e.to_string())),
};
if res.status().is_success() {
@@ -688,29 +732,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 None;
return Err(FetchSocketAddressError::ClientError(e.to_string()));
}
};
let s = match String::from_utf8(body.to_vec()) {
Ok(st) => st,
Err(e) => {
eprintln!("Response not valid UTF-8: {}", e);
return None;
return Err(FetchSocketAddressError::ClientError(e.to_string()));
}
};
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 {
return Some(addr);
if quick_ping(&addr, 5000, sd).await {
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();
@@ -724,12 +769,27 @@ pub async fn get_socket_address(
sd.messages_list(),
);
sleep(Duration::from_millis(5000)).await;
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);
}
}
if quick_ping(&addr, 15000, sd).await {
return Some(addr);
return Ok(addr);
}
}
None
Err(FetchSocketAddressError::NoResponseFromUser)
}
pub async fn get_server_address(username: String, ip: String) -> Option<SocketAddr> {