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

Merge remote-tracking branch 'origin' into bigfix

Browse Source
This commit is contained in:
TIBERGHIEN corentin
2026-01-25 03:46:19 +01:00
parent fbbd8cd640 5378474397
commit b4c4f8f1be
6 changed files with 435 additions and 353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -196,7 +196,6 @@ pub enum NetworkEvent {
Disconnected(),
Error(String, String),
Success(String, String),
PeerConnected(String),
PeerListUpdated(Vec<(String, bool)>),
FileTreeReceived([u8; 32], MerkleNode, String), // peer_id, content
DataReceived([u8; 32], MerkleNode, String),
@@ -340,9 +339,53 @@ pub fn start_p2p_executor(
sd.messages_list(),
sd.handshake_peers.get_username_peerinfo_map(),
);
let server_address = {
match get_server_address(username.to_owned(), ip.to_owned()).await {
Some(addr) => addr.to_string(),
None => {
match event_tx.send(NetworkEvent::Error(
"Couldn't fetch server socket address.".to_owned(),
username.to_owned(),
)) {
Ok(_) => {}
Err(e) => {
println!("Network Event Error : {}", e.to_string());
}
}
"".to_owned()
}
}
};
if server_address.to_owned().eq(&"".to_owned()) {
continue;
}
let res =
perform_handshake(&sd, username, ip, event_tx.clone(), true).await;
sd.set_servername(username.to_owned());
sd.set_serveraddress(server_address.to_string());
println!("SET SERVERADDRESS");
match perform_handshake(
&sd,
username.to_owned(),
ip,
event_tx.clone(),
(true, server_address.to_string()),
)
.await
{
true => {
match event_tx.send(NetworkEvent::Success(
"Handshake established ✔️".to_string(),
username.to_owned(),
)) {
Ok(_) => {}
Err(err) => {
println!("Network Event Error : {}", err.to_string());
}
};
}
false => {}
};
} else {
println!("no shared data");
}
@@ -360,7 +403,9 @@ pub fn start_p2p_executor(
NetworkCommand::Discover(username, hash, ip) => {
// envoie un handshake au peer, puis un root request
if let Some(sd) = shared_data.as_ref() {
let res = sd.handshake_peers.get_peer_info_username(username.clone());
let res = sd
.handshake_peers
.get_peer_info_username(username.to_owned());
match res {
Some(peerinfo) => {
let id = generate_id();
@@ -395,14 +440,31 @@ pub fn start_p2p_executor(
}
None => {
// envoyer un handshake
let res = perform_handshake(
match perform_handshake(
&sd,
username,
username.to_owned(),
ip,
event_tx.clone(),
false,
(false, "".to_string()),
)
.await;
.await
{
true => {
match event_tx.send(NetworkEvent::Success(
"Handshake established ✔️".to_string(),
username.to_owned(),
)) {
Ok(_) => {}
Err(err) => {
println!(
"Network Event Error : {}",
err.to_string()
);
}
};
}
false => {}
}
}
}
} else {
@@ -514,14 +576,21 @@ pub fn start_p2p_executor(
current.push(i);
}
}
let res =
event_tx.send(NetworkEvent::PeerListUpdated(peers));
match event_tx.send(NetworkEvent::PeerListUpdated(peers)) {
Ok(_) => {}
Err(err) => {
println!(
"Network Event Error : {}",
err.to_string()
);
}
};
}
Err(e) => {
eprintln!("invalid UTF-8 in socket address bytes: {}", e);
}
},
Err(e) => println!("error"),
Err(e) => println!("error : {}", e),
}
}
}
@@ -533,25 +602,10 @@ pub fn start_p2p_executor(
if let Some(sd) = shared_data.as_ref() {
let id = generate_id();
sd.add_message(id, EventType::Ping);
let pingrequest =
construct_message(PING, Vec::new(), id, sd.cryptopair_ref());
let peer_address =
get_socket_address(str.to_owned(), ip, shared_data.as_ref()).await;
match peer_address {
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 {}.",
@@ -756,7 +810,16 @@ pub async fn get_socket_address(
}
};
let addresses = parse_addresses(&s); // assumes parse_addresses: &str -> Vec<SocketAddr>
let addresses: Vec<SocketAddr> = {
let temp = parse_addresses(&s);
temp.iter()
.filter_map(|a| match a {
SocketAddr::V4(_) => Some(*a),
SocketAddr::V6(_) => None,
})
.collect()
};
if addresses.is_empty() {
return Err(FetchSocketAddressError::NoRegisteredAddresses);
} else if !addresses.iter().any(|a| matches!(a, SocketAddr::V4(_))) {

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

@@ -314,7 +314,7 @@ pub fn parse_message(
ERROR => {
if let Ok(err_received) =
String::from_utf8(received_message[LENGTH..(msg_length + LENGTH + 4)].to_vec())
String::from_utf8(received_message[LENGTH..(msg_length + LENGTH)].to_vec())
{
let err_msg = format!("Error received from peer {} : {}", ip, err_received);
let _ = cmd_tx_clone.send(NetworkEvent::Error(err_msg, "".to_owned()));

121
client-network/src/registration.rs
View File

@@ -2,6 +2,7 @@ use crate::NetworkEvent;
use crate::P2PSharedData;
use crate::cryptographic_signature::CryptographicSignature;
use crate::get_server_address;
use crate::get_socket_address;
use crate::message_handling::EventType;
use crate::messages_structure::construct_message;
use crate::server_communication::generate_id;
@@ -50,53 +51,77 @@ pub fn parse_addresses(input: &String) -> Vec<SocketAddr> {
///
/// registers the IP addresses by sending a Hello request to the server.
///
pub async fn perform_handshake(
sd: &P2PSharedData,
username: String,
ip: String,
event_tx: Sender<NetworkEvent>,
is_server_handshake: bool,
) {
is_server_handshake: (bool, String),
) -> bool {
println!("username: {}, ip: {}", username.clone(), ip.clone());
let crypto_pair = sd.cryptopair_ref();
let senders = sd.senders_ref();
let id = generate_id();
let server_addr_query = get_server_address(username.clone(), ip.clone());
match server_addr_query.await {
Some(sockaddr_bytes) => {
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);
if is_server_handshake {
sd.add_message(id, EventType::Hello);
sd.set_serveraddress(sockaddr_bytes.to_string());
} else {
println!("hello the nroot");
sd.add_message(id, EventType::HelloThenRootRequest);
}
match hello_handshake {
Some(handshake_message) => {
senders.send_dispatch(
handshake_message,
sockaddr_bytes.to_string(),
is_server_handshake,
sd.messages_list(),
);
let address = {
if is_server_handshake.0 {
is_server_handshake.1
} else {
let server_addr_query =
get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
match server_addr_query {
Ok(sockaddr_bytes) => sockaddr_bytes.to_string(),
Err(err_msg) => {
match event_tx.send(NetworkEvent::Error(
err_msg.to_string(),
username.to_owned(),
)) {
Ok(_) => {}
Err(err) => {
println!("Network Event Error : {}", err.to_string());
}
}
"".to_string()
}
None => {}
}
}
None => {
let err_msg = format!("failed to retreive socket address:").to_string();
let res = event_tx.send(NetworkEvent::Error(err_msg, "".to_owned()));
}
};
if address.eq(&"".to_string()) {
return false;
}
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);
if is_server_handshake.0 {
sd.add_message(id, EventType::Hello);
} else {
sd.add_message(id, EventType::HelloThenRootRequest);
}
match hello_handshake {
Some(handshake_message) => {
senders.send_dispatch(
handshake_message,
address,
is_server_handshake.0,
sd.messages_list(),
);
}
None => {}
}
//let server_addr_query = get_socket_address(username.clone(), ip.clone(), Some(sd)).await;
//match server_addr_query {
// Ok(sockaddr_bytes) => {}
// Err(err_msg) => {}
//}
/*let mut list = messages_list.lock().expect("Failed to lock messages_list");
match list.get(&id) {
Some(_) => {
@@ -113,37 +138,5 @@ pub async fn perform_handshake(
let hello_handshake_received = UDPMessage::parse(buf.to_vec());
hello_handshake_received.display();*/
//TODO
}
#[cfg(test)]
mod tests {
/*///
/// does the procedure to register with the server
///
#[tokio::test]
async fn registering_with_server() {
let username = String::from("gameixtreize");
let server_uri = String::from("https://jch.irif.fr:8443");
let crypto_pair = CryptographicSignature::new(username);
if let Err(e) = register_with_the_server(crypto_pair, server_uri).await {
eprintln!("Error during registration: {}", e);
}
}*/
/*///
/// retreives the socket address of a given peer
///
#[tokio::test]
async fn retreive_socket_addr() {
let username = String::from("ipjkndqfshjldfsjlbsdfjhhj");
match get_socket_address(username).await {
Ok(body) => {
println!("{:?}", body);
}
Err(e) => {
eprintln!("Erreur HTTP: {}", e);
}
}
}*/
return true;
}