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

exp backoff and theads handling

Browse Source
This commit is contained in:
TIBERGHIEN corentin
2026-01-20 01:10:09 +01:00
parent 08518892f2
commit dacedd1ceb
9 changed files with 469 additions and 331 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,20 +3,31 @@ use crate::{
cryptographic_signature::{
CryptographicSignature, get_peer_key, sign_message, verify_signature,
},
datum_parsing::parse_received_datum,
messages_channels::MultipleSenders,
messages_structure::construct_message,
peers_refresh::HandshakeHistory,
registration,
server_communication::generate_id,
};
use std::{collections::HashMap, net::SocketAddr};
use std::{
collections::HashMap,
net::{Ipv4Addr, SocketAddr},
};
use std::{
net::IpAddr,
sync::{Arc, Mutex},
};
// Types of messages that await for a response
#[derive(Debug)]
pub enum EventType {
SendRootRequest,
HelloThenRootRequest,
Hello,
RootRequest,
Ping,
NatTraversal,
DatumRequest,
}
const ID: usize = 4;
@@ -86,80 +97,14 @@ pub fn handle_recevied_message(
None => {}
Some(resp_msg) => {
println!("msg_sent:{:?}", resp_msg);
senders.send_via(
0,
senders.send_dispatch(
resp_msg,
ip.to_string(),
is_resp_to_server_handshake,
messages_list,
messages_list.clone(),
);
}
}
// Lock the mutex to access the HashMap
/*let list = messages_list.lock().unwrap();
let eventtype = list.get(&id); // Clone the enum so we can release the lock if needed
match eventtype {
Some(EventType::ServerHelloReply) => {
/*registration::register_ip_addresses(
crypto_pair,
socket_addr.to_string(),
senders,
&messages_list, // Pass the mutable reference inside the lock
546,
);*/
}
Some(_) => print!("Not implemented"),
None => {
let message_type = recevied_message[4];
// Handle handshake
if message_type == 1 {
let mut resp_to_serv = false;
println!("verify the signature");
let parsed_received_message = HandshakeMessage::parse(recevied_message.to_vec());
let received_name = String::from_utf8(parsed_received_message.name).expect("error");
let peer_pubkey = tokio::runtime::Runtime::new()
.unwrap()
.block_on(get_peer_key(&received_name))
.expect("failed to retrieve public key");
if received_name == server_name.to_string() {
resp_to_serv = true;
}
if !verify_signature(peer_pubkey, recevied_message) {
println!(
"incorrect signature from given peer: {}, ignoring message {}",
&received_name, id
);
} else {
// verify if this is a server handshake request
let username_size = crypto_pair.username.len();
let hello_handshake = HandshakeMessage::helloReply(
id as u32,
username_size as u16 + 4,
crypto_pair.username.clone(),
);
//HandshakeMessage::display(&hello_handshake);
let hello_handshake_serialized = hello_handshake.serialize();
let message_signed = sign_message(crypto_pair, &hello_handshake_serialized);
senders.send_via(0, message_signed, socket_addr.to_string(), resp_to_serv);
let mut list = messages_list.lock().expect("Failed to lock messages_list");
match list.get(&id) {
Some(_) => {
list.remove(&id);
}
None => {
list.insert(id, EventType::ServerHelloReply);
}
}
}
}
print!("Message not found for ID: {}", id)
}
}*/
}
pub fn parse_message(
@@ -188,7 +133,7 @@ pub fn parse_message(
let msg_length = u16::from_be_bytes(length_bytes) as usize;
// verify signature
match msgtype {
HELLO | HELLOREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => {
HELLO | HELLOREPLY => {
let ilength = u16::from_be_bytes(length_bytes);
println!("name received length: {}", ilength);
let received_name = &received_message[LENGTH + EXTENSIONS..LENGTH + ilength as usize];
@@ -227,7 +172,7 @@ pub fn parse_message(
}
}
}
ROOTREPLY => {
ROOTREPLY | NODATUM | NATTRAVERSALREQUEST | NATTRAVERSALREQUEST2 => {
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()) {
@@ -257,6 +202,20 @@ pub fn parse_message(
}
//
// OK
OK => {
let mut guard = messages_list.lock().unwrap();
let res = guard.get(&id);
match res {
Some(ev) => {
println!("{:?}", ev);
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id);
}
None => {
println!("ping non trouvé");
}
}
}
//
// rien ?
// si NATTRAVERSALREQUEST alors
@@ -276,12 +235,11 @@ pub fn parse_message(
crypto_pair,
);
senders.send_via(
0,
senders.send_dispatch(
natreq2.expect("couldnt construct message nattraversalrequest2"),
address,
false,
&messages_list,
messages_list.clone(),
);
}
@@ -291,17 +249,33 @@ pub fn parse_message(
let ilength = u16::from_be_bytes(length_bytes);
let received_address = &received_message[LENGTH..LENGTH + ilength as usize];
let address = String::from_utf8(received_address.to_vec()).expect("wrong name");
println!("received_address:{:?}", received_message);
let addressv4 = IpAddr::V4(Ipv4Addr::from_octets(
received_address[0..4].try_into().expect("incorrect size"),
));
let address = SocketAddr::new(
addressv4,
u16::from_be_bytes(received_address[4..6].try_into().expect("incorrect size")),
);
println!("ip: {}", address);
let pingreq = construct_message(PING, Vec::new(), id, crypto_pair);
senders.send_via(
0,
pingreq.expect("couldnt construct message ping request"),
address,
senders.send_dispatch(
constructed_message.expect("couldnt construct message ping request"),
ip.to_string(),
false,
&messages_list,
messages_list.clone(),
);
senders.send_dispatch(
pingreq.expect("couldnt construct message ping request"),
address.to_string(),
false,
messages_list.clone(),
);
constructed_message = None;
}
//
// ERROR
@@ -325,6 +299,18 @@ pub fn parse_message(
HELLO => {
let mut payload = Vec::new();
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"),
);
payload.extend_from_slice(&0u32.to_be_bytes());
payload.extend_from_slice(&crypto_pair.username.clone().as_bytes());
@@ -350,21 +336,30 @@ pub fn parse_message(
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 mut guard = messages_list.lock().expect("Échec du verrouillage");
let res = guard.get(&id);
match res {
Some(ev) => {
match ev {
EventType::SendRootRequest => {
EventType::HelloThenRootRequest => {
// envoyer la root request
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id);
let rootrequest = construct_message(
ROOTREQUEST,
Vec::new(),
generate_id(),
crypto_pair,
);
//&guard.insert(, v)
return rootrequest;
}
EventType::Hello => {
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id);
}
_ => {}
}
}
None => {}
@@ -382,15 +377,45 @@ pub fn parse_message(
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")
let mut guard = messages_list.lock().expect("Échec du verrouillage");
let res = guard.get(&id);
match res {
Some(ev) => {
match ev {
EventType::RootRequest => {
// envoyer la root request
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id);
// 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");
// envoyer un datum
let mut payload = Vec::new();
payload.extend_from_slice(&received_hash);
let new_id = generate_id();
let datumreqest = construct_message(
DATUMREQUEST,
payload,
new_id,
crypto_pair,
);
constructed_message = datumreqest;
guard.insert(new_id, EventType::DatumRequest);
}
_ => {}
}
}
None => {}
}
}
None => {
eprintln!("no peers found");
@@ -407,7 +432,35 @@ pub fn parse_message(
// affiche un msg d'erreur
//
// DATUM
//
DATUM => {
let mut guard = messages_list.lock().expect("Échec du verrouillage");
let res = guard.get(&id);
match res {
Some(ev) => match ev {
EventType::DatumRequest => {
let _ = &guard.remove_entry(&id);
println!("message {} retiré de la liste", id);
let received_length = u16::from_be_bytes(
received_message[TYPE..LENGTH]
.try_into()
.expect("incorrect size"),
);
let received_datum = &received_message[LENGTH..];
let parsed_node =
parse_received_datum(received_datum.to_vec(), received_length as usize);
match parsed_node {
Some(tuple) => {
let _ =
cmd_tx.send(NetworkEvent::FileTreeReceived(tuple.0, tuple.1));
}
None => {}
}
}
_ => {}
},
None => {}
}
}
// parcourt le directory recu ou le big directory et renvoie une DATUMREQUEST pour chaque
// directory ou big directory lu
//