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 524eaec76d
commit cb2e89b1e9
6 changed files with 268 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
client-network/src/fetchsocketaddresserror.rs Normal file
View File

@@ -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)
}
}
}
}

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,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, timeout};
use tokio::time::sleep;
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) => {
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");
}
@@ -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 => {
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);
}
}
}
}
}
@@ -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 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() {
@@ -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 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();
@@ -604,12 +649,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> {

41
client-network/src/message_handling.rs
View File

@@ -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");

2
client-network/src/messages_channels.rs
View File

@@ -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,

46
client-network/src/timestamp.rs Normal file
View File

@@ -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)
}
}